diff --git a/.gitignore b/.gitignore index a9c9f1dc..5f7aa648 100644 --- a/.gitignore +++ b/.gitignore @@ -1,12 +1,7 @@ *.egg-info *.pyc *.png -assets/shared_data_bucket/* -assets/test_results/* -!assets/test_results/README.md -assets/bop/* -assets/nuscenes/* -assets/ycbineoat/* +assets/* **/.ipynb_checkpoints **/**.mp4 **/**.npz @@ -24,3 +19,7 @@ assets/kitti/* __pycache__/ *.py[cod] docs/* +test_results/ +.pixi/* +saved_traces/* +.DS_Store diff --git a/analysis.ipynb b/analysis.ipynb new file mode 100644 index 00000000..8f66d305 --- /dev/null +++ b/analysis.ipynb @@ -0,0 +1,26311 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import io\n", + "import json\n", + "import os\n", + "from functools import reduce\n", + "from os import listdir\n", + "from os.path import isfile, join\n", + "import h5py\n", + "import numpy as np\n", + "import trimesh\n", + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", + "from scipy.spatial.transform import Rotation" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# config = 'pilot_it2_collision_non-sphere_tdw_1_dis_1_occ'\n", + "# trial_index = str(25)\n", + "\n", + "# config = 'pilot_it2_collision_non-sphere_tdw_1_dis_1_occ'\n", + "# trial_index = str(39)\n", + "\n", + "# config = 'pilot_it2_collision_non-sphere_tdw_1_dis_1_occ'\n", + "# trial_index = str(15)\n", + "\n", + "# config = 'pilot_it2_collision_non-sphere_tdw_1_dis_1_occ'\n", + "# trial_index = str(11)\n", + "\n", + "# config = 'pilot_it2_collision_non-sphere_tdw_1_dis_1_occ'\n", + "# trial_index = str(17)\n", + "\n", + "# config = 'pilot_it2_collision_non-sphere_box'\n", + "# trial_index = str(12)\n", + "\n", + "# config = 'pilot_it2_collision_non-sphere_box'\n", + "# trial_index = str(15)\n", + "\n", + "# config = 'pilot_it2_collision_non-sphere_box'\n", + "# trial_index = str(32)\n", + "\n", + "# config = 'pilot_it2_collision_non-sphere_box'\n", + "# trial_index = str(17)\n", + "\n", + "# config = 'pilot_it2_collision_non-sphere_box'\n", + "# trial_index = str(2)\n", + "\n", + "config = 'pilot_it2_collision_simple_box_1_dis_1_occ'\n", + "trial_index = str(34)\n", + "\n", + "# config = 'pilot_it2_collision_non-sphere_box'\n", + "# trial_index = str(23)\n", + "\n", + "# json_file_path = f'/ccn2/u/haw027/b3d_ipe/b3d_tdw_joint/b3d_tracking_results/first_scale/gt/{config}.json'\n", + "# with open(json_file_path) as f:\n", + "# json_file = json.load(f)\n", + "# tracking_per_frame = json_file[trial_index]\n", + "\n", + "gt_hdf5_file_path = f'/home/haoliangwang/data/physion_hdf5/collide_all_movies/{config}_{trial_index.zfill(4)}.hdf5'\n", + "# file_4x5 = f'/ccn2/u/haw027/b3d_ipe/b3d_tdw_joint/tdw_simulation_results/first_scale/gt_all_info_0.01_std_all_gt/collide/{config}/{trial_index.zfill(4)}.hdf5'\n", + "\n", + "with open(f'/home/haoliangwang/data/b3d_tracking_results/test/collide_verbose/{config}_{trial_index.zfill(4)}.json') as f:\n", + " tracking_per_frame = json.load(f)\n", + "with open(f'/home/haoliangwang/data/b3d_tracking_results/test/collide/{config}_{trial_index.zfill(4)}.json') as f:\n", + " tracking_final_frame = json.load(f)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def quaternion_to_euler_angles(quaternion):\n", + " rot = Rotation.from_quat(quaternion)\n", + " rot_euler = rot.as_euler(\"xyz\", degrees=True)\n", + " return rot_euler\n", + "\n", + "def blackout_image(depth_map, area):\n", + " # zero_depth_map = np.ones(depth_map.shape)\n", + " zero_depth_map = np.zeros(depth_map.shape)\n", + " zero_depth_map[area] = depth_map[area]\n", + " return zero_depth_map\n", + "\n", + "def get_mask_area(seg_img, colors):\n", + " arrs = []\n", + " for color in colors:\n", + " arr = seg_img == color\n", + " arr = arr.min(-1).astype('float32')\n", + " arr = arr.reshape((arr.shape[-1], arr.shape[-1])).astype(bool)\n", + " arrs.append(arr)\n", + " return reduce(np.logical_or, arrs)\n", + "\n", + "def set_axes_equal(ax):\n", + " \"\"\"\n", + " Make axes of 3D plot have equal scale so that spheres appear as spheres,\n", + " cubes as cubes, etc.\n", + "\n", + " Input\n", + " ax: a matplotlib axis, e.g., as output from plt.gca().\n", + " \"\"\"\n", + "\n", + " x_limits = ax.get_xlim3d()\n", + " y_limits = ax.get_ylim3d()\n", + " z_limits = ax.get_zlim3d()\n", + "\n", + " x_range = abs(x_limits[1] - x_limits[0])\n", + " x_middle = np.mean(x_limits)\n", + " y_range = abs(y_limits[1] - y_limits[0])\n", + " y_middle = np.mean(y_limits)\n", + " z_range = abs(z_limits[1] - z_limits[0])\n", + " z_middle = np.mean(z_limits)\n", + "\n", + " # The plot bounding box is a sphere in the sense of the infinity\n", + " # norm, hence I call half the max range the plot radius.\n", + " plot_radius = 0.5*max([x_range, y_range, z_range])\n", + "\n", + " ax.set_xlim3d([x_middle - plot_radius, x_middle + plot_radius])\n", + " ax.set_ylim3d([y_middle - plot_radius, y_middle + plot_radius])\n", + " ax.set_zlim3d([z_middle - plot_radius, z_middle + plot_radius])\n", + "\n", + "def scale_mesh(vertices, scale_factor):\n", + " vertices[:, 0] *= scale_factor[0]\n", + " vertices[:, 1] *= scale_factor[1]\n", + " vertices[:, 2] *= scale_factor[2]\n", + " # vertices[:,[2,1]] = vertices[:,[1,2]]\n", + " return vertices\n", + "\n", + "def apply(position, rotation, vec):\n", + " \"\"\"Apply pose to vectors.\"\"\"\n", + " return Rotation.from_quat(rotation).apply(vec) + position\n", + "\n", + "def compute_center_of_mass(mesh, position, rotation):\n", + " q = rotation\n", + " mesh_transform = apply(position, rotation, mesh.vertices)\n", + " mesh_transform = trimesh.Trimesh(\n", + " mesh_transform, mesh.faces\n", + " )\n", + " center_of_mass = mesh_transform.center_mass\n", + " return center_of_mass, q\n", + "\n", + "def compute_angular_velocity(q1, q2, delta_t):\n", + " # Convert quaternions to scipy Rotation objects\n", + " rot1 = Rotation.from_quat(q1)\n", + " rot2 = Rotation.from_quat(q2)\n", + " \n", + " # Compute the relative rotation\n", + " relative_rotation = rot2 * rot1.inv()\n", + " \n", + " # Convert the relative rotation to angle-axis representation\n", + " angle = relative_rotation.magnitude() # Rotation angle in radians\n", + " axis = relative_rotation.as_rotvec() / angle if angle != 0 else np.zeros(3) # Rotation axis\n", + " \n", + " # Compute angular velocity\n", + " angular_velocity = (axis * angle) / delta_t\n", + " return angular_velocity\n", + "\n", + "def compute_velocity(\n", + " mesh,\n", + " position_last, rotation_last,\n", + " position_window, rotation_window,\n", + " dt,\n", + "):\n", + " pos_now, q_now = compute_center_of_mass(mesh, position_last, rotation_last)\n", + " pos_last, q_last = compute_center_of_mass(mesh, position_window, rotation_window)\n", + " linear_vel = (pos_now - pos_last) / dt\n", + " angular_velocity = compute_angular_velocity(q_last, q_now, dt)\n", + "\n", + " return linear_vel, angular_velocity\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "position_arr = []\n", + "rotation_arr = []\n", + "velocity_arr = []\n", + "center_arr = []\n", + "angular_velocity_arr = []\n", + "\n", + "img_arr = []\n", + "with h5py.File(gt_hdf5_file_path, \"r\") as f:\n", + " depth = np.array(f[\"frames\"][\"0000\"][\"images\"][\"_depth_cam0\"])\n", + " image = (\n", + " np.array(\n", + " Image.open(\n", + " io.BytesIO(f[\"frames\"][\"0000\"][\"images\"][\"_img_cam0\"][:])\n", + " )\n", + " )\n", + " / 255\n", + " )\n", + " im_seg = np.array(\n", + " Image.open(io.BytesIO(f[\"frames\"][\"0000\"][\"images\"][\"_id_cam0\"][:]))\n", + " )\n", + "\n", + " scales = np.array(f[\"static\"][\"scale\"])\n", + "\n", + " distractors = (\n", + " np.array(f[\"static\"][\"distractors\"])\n", + " if np.array(f[\"static\"][\"distractors\"]).size != 0\n", + " else []\n", + " )\n", + " occluders = (\n", + " np.array(f[\"static\"][\"occluders\"])\n", + " if np.array(f[\"static\"][\"occluders\"]).size != 0\n", + " else []\n", + " )\n", + " distractors_occluders = np.concatenate([distractors, occluders])\n", + " if len(distractors_occluders):\n", + " scales = scales[: -len(distractors_occluders)]\n", + "\n", + " for frame in f[\"frames\"].keys():\n", + " img_arr.append(np.array(\n", + " Image.open(\n", + " io.BytesIO(f[\"frames\"][frame][\"images\"][\"_img_cam0\"][:])\n", + " ).resize((350, 350))\n", + " ))\n", + " \n", + " positions = np.array(f[\"frames\"][frame][\"objects\"][\"positions_cam0\"])\n", + " centers = np.array(f[\"frames\"][frame][\"objects\"][\"center_cam0\"])\n", + " rotations = np.array(f[\"frames\"][frame][\"objects\"][\"rotations_cam0\"][:])\n", + " velocities = np.array(f[\"frames\"][frame][\"objects\"][\"velocities\"][:])\n", + " angular_velocities = np.array(f[\"frames\"][frame][\"objects\"][\"angular_velocities\"][:])\n", + " if len(distractors_occluders):\n", + " positions = positions[\n", + " : -len(distractors_occluders)\n", + " ]\n", + " rotations = rotations[\n", + " : -len(distractors_occluders)\n", + " ]\n", + " velocities = velocities[\n", + " : -len(distractors_occluders)\n", + " ]\n", + " angular_velocities = angular_velocities[\n", + " : -len(distractors_occluders)\n", + " ]\n", + " centers = centers[\n", + " : -len(distractors_occluders)\n", + " ]\n", + "\n", + " position_arr.append(positions)\n", + " center_arr.append(centers)\n", + " rotation_arr.append(rotations)\n", + " velocity_arr.append(velocities)\n", + " angular_velocity_arr.append(angular_velocities)\n", + "\n", + " # extract object info\n", + " object_ids = np.array(f[\"static\"][\"object_ids\"])\n", + " model_names = np.array(f[\"static\"][\"model_names\"])\n", + " object_segmentation_colors = np.array(\n", + " f[\"static\"][\"object_segmentation_colors\"]\n", + " )\n", + " initial_positions = np.array(f[\"static\"][\"initial_position\"])\n", + " initial_rotations = np.array(f[\"static\"][\"initial_rotation\"])\n", + " assert (\n", + " len(object_ids) == len(model_names) == len(object_segmentation_colors)\n", + " )\n", + " \n", + " if len(distractors_occluders):\n", + " object_ids = object_ids[: -len(distractors_occluders)]\n", + " model_names = model_names[: -len(distractors_occluders)]\n", + " object_segmentation_colors = object_segmentation_colors[\n", + " : -len(distractors_occluders)\n", + " ]\n", + " initial_positions = initial_positions[\n", + " : -len(distractors_occluders)\n", + " ]\n", + " initial_rotations = initial_rotations[\n", + " : -len(distractors_occluders)\n", + " ]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "mesh_file_path = '/home/haoliangwang/data/all_flex_meshes/core/'\n", + "object_meshes = []\n", + "for idx, model_name in enumerate(model_names):\n", + " trim = trimesh.load(os.path.join(mesh_file_path, f\"{model_name.decode('UTF-8')}.obj\"))\n", + " object_meshes.append(trimesh.Trimesh(scale_mesh(trim.vertices, scales[idx]), trim.faces))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## visualize the objects" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcsAAAHBCAYAAAAGmZAhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAzGklEQVR4nO3de5BcdZ3//9c5py/Tc0nnRqYzJEDiZpfLBMQgl5AlCBJdiSxf67dihMAW7gU1kRhFQKwvYGmSpXZZy0JB3C3WLXRDUQRLLTfroBjNL0GyuWgSVHQJuTGTyWWme2a6+/S5vL9/jPYyBDgBOkwuz0fV5485/emeT38q+uR0n+5xzMwEAABekzvaCwAA4FhHLAEASEAsAQBIQCwBAEhALAEASEAsAQBIQCwBAEhALAEASEAsAQBIQCyBE8iWLVt09dVX67TTTlMul9P48eN1ySWX6NFHHx3tpQHHtdRoLwBA4/T392vq1KlasGCBTj31VA0NDenb3/62Fi5cqBdffFFf+MIXRnuJwHHJ4bthgRPfxRdfrJdeekm7du0a7aUAxyVehgVOAhMnTlQqxQtJwJvF/3qAE1Acx4rjWH19fXr88cf1X//1X3rggQdGe1nAcYtYAiegT3ziE/rGN74hScpkMvrqV7+qv//7vx/lVQHHL96zBE5Au3btUm9vr3p7e/X9739fDz/8sP7hH/5Bn/3sZ0d7acBxiVgCJ4GPf/zj+pd/+Re99NJLOuWUU0Z7OcBxhwt8gJPAhRdeqDAM9cILL4z2UoDjErEETgJPP/20XNfV9OnTR3spwHGJC3yAE8jf/d3facyYMbrwwgvV3t6uAwcO6PHHH9djjz2m2267jZdggTeJ9yyBE8gjjzyiRx55RL/+9a/V39+v1tZWnXfeefqbv/kb3XDDDaO9POC4RSwBAEjAe5YAACQglgAAJCCWAAAkOOZj+fWvf13Tpk1TU1OTZs2apZ///OejvSQAwEnmmI7lY489piVLluiuu+7S5s2b9ed//uf6i7/4C/7MEADgbXVMXw170UUX6V3vepcefPDB+rGzzjpL1157rZYvXz6KKwMAnEyO2S8lqNVq2rhxo+64444Rx+fNm6d169YdNt/3ffm+X/85jmMdOnRIEyZMkOM4R329AIBjh5lpYGBAHR0dct23/iLqMRvLAwcOKIoitbe3jzje3t6unp6ew+YvX75c995779u1PADAcWD37t2aMmXKW36cY/o9S0mHnRWa2aueKd55550qFov1wfuaAIC2traGPM4xe2Y5ceJEeZ532Flkb2/vYWebkpTNZpXNZt+u5QEAjgONehvumD2zzGQymjVrlrq6ukYc7+rq0uzZs0dpVQCAk9Exe2YpSUuXLtXChQt1wQUX6JJLLtHDDz+sXbt26ZZbbhntpQEATiLHdCyvu+46HTx4UF/84hfV3d2tzs5O/fCHP9Tpp58+2ksDAJxEjunPWb4VpVJJ+Xx+tJcBABhFxWJRY8aMecuPc8y+ZwkAwLGCWAIAkIBYAgCQgFgCAJCAWAIAkIBYAgCQgFgCAJCAWAIAkIBYAgCQgFgCAJCAWAIAkIBYAgCQgFgCAJCAWAIAkIBYAgCQgFgCAJCAWAIAkIBYAgCQgFgCAJCAWAIAkIBYAgCQgFgCAJCAWAIAkIBYAgCQgFgCAJCAWAIAkIBYAgCQgFgCAJCAWAIAkIBYAgCQgFgCAJCAWAIAkIBYAgCQgFgCAJCAWAIAkIBYAgCQgFgCAJCAWAIAkIBYAgCQgFgCAJCAWAIAkIBYAgCQgFgCAJCAWAIAkIBYAgCQgFgCAJCAWAIAkIBYAgCQgFgCAJCAWAIAkIBYAgCQgFgCAJCAWAIAkIBYAgCQgFgCAJCAWAIAkIBYAgCQgFgCAJCAWAIAkIBYAgCQgFgCAJCAWAIAkIBYAgCQgFgCAJCg4bFcvny53v3ud6utrU2TJk3Stddeq9/+9rcj5piZ7rnnHnV0dCiXy+nyyy/X9u3bR8zxfV+LFy/WxIkT1dLSomuuuUZ79uxp9HIBAEjU8FiuWbNGn/zkJ/XMM8+oq6tLYRhq3rx5Ghoaqs+57777dP/99+uBBx7Qhg0bVCgUdNVVV2lgYKA+Z8mSJXryySe1cuVKrV27VoODg5o/f76iKGr0kgEAeH12lPX29pokW7NmjZmZxXFshULBVqxYUZ9TrVYtn8/bQw89ZGZm/f39lk6nbeXKlfU5e/fuNdd1bfXq1Uf0e4vFokliMBgMxkk8isViQ1p21N+zLBaLkqTx48dLknbs2KGenh7NmzevPiebzWru3Llat26dJGnjxo0KgmDEnI6ODnV2dtbnAADwdkkdzQc3My1dulRz5sxRZ2enJKmnp0eS1N7ePmJue3u7du7cWZ+TyWQ0bty4w+b88f6v5Pu+fN+v/1wqlRr2PAAAJ7ejema5aNEi/epXv9J//Md/HHab4zgjfjazw4690uvNWb58ufL5fH1MnTr1zS8cAICXOWqxXLx4sb73ve/p6aef1pQpU+rHC4WCJB12htjb21s/2ywUCqrVaurr63vNOa905513qlgs1sfu3bsb+XQAACexhsfSzLRo0SKtWrVKP/nJTzRt2rQRt0+bNk2FQkFdXV31Y7VaTWvWrNHs2bMlSbNmzVI6nR4xp7u7W9u2bavPeaVsNqsxY8aMGAAANERDLhN6mY9//OOWz+ftpz/9qXV3d9dHuVyuz1mxYoXl83lbtWqVbd261RYsWGCTJ0+2UqlUn3PLLbfYlClT7KmnnrJNmzbZFVdcYeedd56FYXhE6+BqWAaDwWA06mrYhsfytRb8yCOP1OfEcWx33323FQoFy2azdtlll9nWrVtHPE6lUrFFixbZ+PHjLZfL2fz5823Xrl1HvA5iyWAwGIxGxdL5Q+BOOKVSSfl8frSXAQAYRcVisSFvy/HdsAAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJDjqsVy+fLkcx9GSJUvqx8xM99xzjzo6OpTL5XT55Zdr+/btI+7n+74WL16siRMnqqWlRddcc4327NlztJcLAMBhjmosN2zYoIcffljnnnvuiOP33Xef7r//fj3wwAPasGGDCoWCrrrqKg0MDNTnLFmyRE8++aRWrlyptWvXanBwUPPnz1cURUdzyQAAHM6OkoGBAZsxY4Z1dXXZ3Llz7dZbbzUzsziOrVAo2IoVK+pzq9Wq5fN5e+ihh8zMrL+/39LptK1cubI+Z+/evea6rq1evfqIfn+xWDRJDAaDwTiJR7FYbEjTjtqZ5Sc/+UldffXVeu973zvi+I4dO9TT06N58+bVj2WzWc2dO1fr1q2TJG3cuFFBEIyY09HRoc7OzvocAADeLqmj8aArV67Upk2btGHDhsNu6+npkSS1t7ePON7e3q6dO3fW52QyGY0bN+6wOX+8/yv5vi/f9+s/l0qlt/QcAAD4o4afWe7evVu33nqrHn30UTU1Nb3mPMdxRvxsZocde6XXm7N8+XLl8/n6mDp16htfPAAAr6Lhsdy4caN6e3s1a9YspVIppVIprVmzRl/96leVSqXqZ5SvPEPs7e2t31YoFFSr1dTX1/eac17pzjvvVLFYrI/du3c3+qkBAE5SDY/llVdeqa1bt2rLli31ccEFF+j666/Xli1bNH36dBUKBXV1ddXvU6vVtGbNGs2ePVuSNGvWLKXT6RFzuru7tW3btvqcV8pmsxozZsyIAQBAIzT8Pcu2tjZ1dnaOONbS0qIJEybUjy9ZskTLli3TjBkzNGPGDC1btkzNzc366Ec/KknK5/P62Mc+ps985jOaMGGCxo8fr89+9rOaOXPmYRcMAQBwtB2VC3ySfO5zn1OlUtEnPvEJ9fX16aKLLtKPfvQjtbW11ef88z//s1KplD784Q+rUqnoyiuv1L/927/J87zRWDIA4CTmmJmN9iKOhlKppHw+P9rLAACMomKx2JC35fhuWAAAEhBLAAASEEsAABIQSwAAEhBLAAASEEsAABIQSwAAEhBLAAASEEsAABIQSwAAEhBLAAASEEsAABIQSwAAEhBLAAASEEsAABIQSwAAEhBLAAASEEsAABIQSwAAEhBLAAASEEsAABIQSwAAEhBLAAASEEsAABIQSwAAEhBLAAASEEsAABIQSwAAEhBLAAASEEsAABIQSwAAEhBLAAASEEsAABIQSwAAEhBLAAASEEsAABIQSwAAEhBLAAASEEsAABIQSwAAEhBLAAASEEsAABIQSwAAEhBLAAASEEsAABIQSwAAEhBLAAASEEsAABIQSwAAEhBLAAASEEsAABIQSwAAEhBLAAASEEsAABIQSwAAEhBLAAASEEsAABIQSwAAEhBLAAASEEsAABIQSwAAEhBLAAASEEsAABIQSwAAEhBLAAASHJVY7t27VzfccIMmTJig5uZmvfOd79TGjRvrt5uZ7rnnHnV0dCiXy+nyyy/X9u3bRzyG7/tavHixJk6cqJaWFl1zzTXas2fP0VguAACvq+Gx7Ovr06WXXqp0Oq3//M//1HPPPad/+qd/0tixY+tz7rvvPt1///164IEHtGHDBhUKBV111VUaGBioz1myZImefPJJrVy5UmvXrtXg4KDmz5+vKIoavWQAAF6fNdjtt99uc+bMec3b4zi2QqFgK1asqB+rVquWz+ftoYceMjOz/v5+S6fTtnLlyvqcvXv3muu6tnr16iNaR7FYNEmM43E4slQ6ZdNmTLMzzvoTO+2sGXbe7Hfbzbd9ws6/7CI77c+m28T2iea4rjmOM/rrZTAYx+woFotvsmYjOWZmaqCzzz5b73vf+7Rnzx6tWbNGp556qj7xiU/ob//2byVJL7zwgt7xjndo06ZNOv/88+v3+8u//EuNHTtW3/rWt/STn/xEV155pQ4dOqRx48bV55x33nm69tprde+99x72e33fl+/79Z9LpZKmTp3ayKeGo8jzXI2dMF5nnPWneucVl+qMc89R+xkdqihWYKbmbE5jm1s1VC2rUi2reOCgBnsPyikO6L9/sk7//fQ69R/sG+2nAeAYUywWNWbMmLf8OKkGrGWEF154QQ8++KCWLl2qz3/+83r22Wf1qU99StlsVjfeeKN6enokSe3t7SPu197erp07d0qSenp6lMlkRoTyj3P+eP9XWr58+atGFMc2z/P0jnPO1PybF+jcuZcoaMqoP6iqe99ebd24VqXiIU08Y5rmzLxYsespk2uRm8lIuZzc9vGKg1DvvbBTV9z8/+mn//6knl71nwpqwWg/LQAnmIbHMo5jXXDBBVq2bJkk6fzzz9f27dv14IMP6sYbb6zPcxxnxP3M7LBjr/R6c+68804tXbq0/jNnlse+sRPH6//c8tea+5FrpeYmlWpV/eal/9Hzv/6laqWS8hNO0dSzz9Epp7TrUK2kyImU83JyHE+5TE6xpP54UOVaqDDfpDmful7nXDlbT//7Km17ZpPCIBztpwjgBNHwWE6ePFlnn332iGNnnXWWnnjiCUlSoVCQNHz2OHny5Pqc3t7e+tlmoVBQrVZTX1/fiLPL3t5ezZ49+1V/bzabVTabbehzwdGRbcqqc/a79X+W/r1OO+cshTLtrwzp9707Va2U9Gdnd6qtZYxy2ZyiKNDe3pfU7ZjGtLSqY+xk5bNjlPHSak43yST1Rv0yy2pfdVBNZ56qj97/eW34zvf05AP/TjABNETDr4a99NJL9dvf/nbEseeff16nn366JGnatGkqFArq6uqq316r1bRmzZp6CGfNmqV0Oj1iTnd3t7Zt2/aascTxoaWtRUtWfEF/98AyTe08W6Gk7nJJfdWS8i2tmj5luiZPPFVtuTbFcazeg/vVt2+vSr37dGD/Pv1uz/PasX+n/KAqScp6aU1oHiM5jpx0RgNBoN+XenXORz6gv172WZ0y+ZTRfcIATggNP7P89Kc/rdmzZ2vZsmX68Ic/rGeffVYPP/ywHn74YUnDL78uWbJEy5Yt04wZMzRjxgwtW7ZMzc3N+uhHPypJyufz+tjHPqbPfOYzmjBhgsaPH6/Pfvazmjlzpt773vc2esl4m7S0tujmez6tyfNmy7IZhWYq1soaCgbluY5a0i0yM5X9ssrVihyTmtJpjctPkl8eUjRUVTkIVa1UVCr2aeYZnVIqraZUVqe0jtXu/n1KNTWrf6BPL/Qf0NTL3qUPNXv6wT8+or0vvjR8bRwAvAkNvxpWkn7wgx/ozjvv1O9+9ztNmzZNS5curV8NKw2/93jvvffqG9/4hvr6+nTRRRfpa1/7mjo7O+tzqtWqbrvtNn3nO99RpVLRlVdeqa9//etH/D5kqVRSPp9v9FPDm9TS2qKP3PG3mvr+P5ebbR5+/9lNabBWluc4cs0URZGGyoOyKJLrptSUyiifa9ahvkMqlfoU+b6CqKZaEMqPAk2a1KGz39EpL51WLY40VCvrxUP7FMSx+voPaVxLi9pbW6Vdu/T015/Qxp9vGu1tAPA2a9TVsEcllscCYnnsaGlt0d/cs0STrpilIUcaDGsKIpNiRy3ZrFKS9h/sVlMqp1Qqo5pfVq1aVaFtvMaPGaswNh3s61W5MqRKqahid4+CVEqKYk2cPk1n/elMmespltQzeEj7Sv0aKg+qUh3S5HHjNTad1uB//0rf/r/fULVcHe3tAPA2OmY/OgKM4Di65ubr9I6/uEwv+UVFltKA76spnVPKjeWY5DpSynFkZorCQOUDByU52rNrv/oKE5QfP07pdFbpakW5XLOCyZPltrUprlSVa2vTzn07FLmeHC8tL5WRWSR5nuS52j9QVGrsBLnTT9WMWX+mrT//5WjvCIDjELHEUTWxcIouvu4vtc8fVCBHfhzIZJLV5LmeXJlkkuem5DqOHJMyLS3yXE9Rplk1OQoiKSj3y/OrKtdqSufHyR8aUOv48UqnUxqsDqkchQpMihxHkWKlvKzcVFrl8pAOlPo1tqlJZ8+/SHt/u0uHevnyAgBvDH91BEdNKpXS1X9zvdyJY3WoVlE1ipRyPGW8lCyOFYahwrCmMAplchSEoUKTWvLjlR87Qe0dHWod06ZKZVCVmq+BKFLU1KRUHMv1HDkWqzRUUi2OFTuO5DgKo1BpL6tsOiVZrKGhQR0qlTQQ1lRpa9JZczql1/84LwAchjNLHDXvOPcsXXrdtdrrD6kc+srIkSNHrsVyTXJMip1YKcdTOpVWf2VQlUq/ZLHSjivHceTKkReb0q1jFPQfUjUIZX5Z6dYWlUtF1VxJ6fQfziglx3Hlep4Gq2VV/arCOFalFmjvSy8pJ+mUmadp/M/H6dB+zi4BHDnOLHHUnHPZRYqaMvLjWH4YKoojRXEoyVUUxXLkynVSct2Uan6gg4cOqeIHCs1R5HqqBpEGBwflu46CSlmR46haHVSYGr7/QHlIgUxhbJIcmYa/Pi+OQ9VqNQ0US0plm1UdHNTAwYMaqlQ0JFPHn04Z5Z0BcLzhzBJHRVOuSWdedpFqFimwUEE0PBwzKTKlJAVxTWEwHL09B/YplMmJY8VRLD+qKQwCOUGgcHBQNZliSemUp1Qmq6G+fkXZjMzx5MpRGNaUymYVRKEs9BWFsWpBoFxTqyrFfll/UcqmZH0DmnLudP36me2Koni0twnAcYIzSxwVHX9yusa9Y6rCOFYYS7FJFkdy5SjjpeQ6rqpBVWFY066dL6h08IBqQwMK/bLCWqA4iuR5aaWa21SNY5WjSOVqVW5zq0qlAQ1GoeJUSnJd+YEveZ6GKlVFYaRKpaZyf1GpbEZ+dUhOU5PCwFQ9OKChnT1qnpRX29i20d4iAMcRYomj4py571acTqkahXJcR7FJsZlii1QJfJWDmqLY0cH+fvlRqGzT8Hf7emlPYVRR4A+qVimqVhlQWKuoPDSoTGuL/DCUX6vKMmlFkoKwJnmOojhWHEeq+L6cQCqWS3I9T7HFiiRpbJsiP1BYKmtwcEBnnHXG6G4QgOMKL8Oi4TLZjGZcer7KYU3ZdE6OXHmuJ5kjV57MlWKL5XieWtva1NzSqjga/sLzMI6kP8y3OJJf81UNQ5lF8tIZ1coVWSYrS7kyR6qFkdLplKrlqty0Jzd2dah/v9K5ZsXmKIpDxRbLPFfya4olDQ6V9a6Lz9OWtXzmEsCRIZZouGl/cppaJk+QH9fkxhm5jqO0l1YQ1VQJXEVRJJnJdWz4IyRBIMmR46bkptKK41BRFAzfL5OV63pKe66CKFIpCuR6nlKptGqBryiO5fuB0tmsKkNV1cq+LJNVza+orbVVfq0qyVEcBHJcSdmMojBSFPHXSAAcOWKJhktlUqpEvsIwlLm+PNdRU7pJRb+sTNqTSQrDmoIwkOO6siiWzJGFgSJHihUrlc5KYag4DOR4noaimsIwUKhYjpmCWqwwCuU5aZmkoXJZbuyqUhlS6DjKtLQoimK5XkrmeIpKA/IcR3FzRuaYypWh0d4mAMcRYomGqwxWdPDQQaWaWmSOp9Zsi9JuSqHFCqJAjuMpsljpTEZRFCqWSY6jOOXI5EkKVav5stjkuo78akVBGMj1XIVypMgURaFcx1XgV+Sm0nJTGfWX+qRUWnFYk5tO1c9Y4/5+6UC/LI5lzVlFrieF0SjvEoDjCRf4oOF2vrhXu/e8pL7BAVXCQGaxhj+k4apa8xVGUiqVVWyugiBULCl2HYUm+bWy/GpVsUxBHGiwMqTAIqWbmuV4GZk8Vf2aojBSdWBI5rqyMFZlcFCRmWp+RbmxY4dforVYleKAwp0vyWqRYjOZ6yr2HLkxX+MD4MhxZomjIvR99fbtV651jAZrVaU8T5KnUrkoRUPKZXOSE8txXTmOFAa+otjkeimFilWLQoVxLMdLyXMcBX5VtaAmk+SmUgoGy/JSKdVqvtzY1aBfURTUlBs7Vn61KrlSUPZV3dstCyKp4svamhSn08NnptVgtLcIwHGEWOKoSFdrOjhQlB/VdKhqcuTJD0J56Zw8zzTk11SrlBUGVcVRLMccOa4nx/NkJsVuJNfxJOd/3+N0HVeSK4sjhSZFg1WlMlkVB/tljqN0c06xpCCoyZWpvP+Aou4DUnFA5jiSl5LnuHIHq/rvDf8zyjsE4HhCLNFwrqRxbkovFUvad+igxubHyTENvyxarijlpZTJZOS5KQVhTqlUWsFgWUG1IiebUTqbVVitKg5qcpxIcWzKup6CIFAsV2EYqlatKpNq0sBAUbFFcrMZpbJZVQYH5WZSqvT1K9zTKxusyPxA8bgxcuXIjSI1DdbU5PBPH8CR4/8x0HBhGGnPb15U6p2n66XuPcrkcqqFoRxHah0zRp7jynFcBWEgC4c/T6mmtOQ5ii1WqVSUXxqQU4vkeSm5kmKZzHMURpGiKFYYx6pVioqjUG7KU7qlRZXBATmOK7+/qKDngNQ/IFWHv8AgTnnyKr6cWig3ML24q3u0twnAcYRYouHMTNV9/WpxputAf5/2HtyvsW15+b4vNwrVlMoqnUqrKdOkOJZS6awyGan6h89EZptbFOTHKogixbEU1XwpChUHoZwokgU1pRyTf6gki2K5rS2q9PVLXkpRpazw4CHZvkNy/EAWmaKmjJxSWY7jyCv7imJPIVfDAngDiCWOihd//aIu/IsLlI5jvbSvW7GTVi6dUspLq+z7Cvr65Hppeem00umMPNcd/tyk5ymIAgVhJEdSyvPkpjOKPE+xm5ZFkTxv+IsNLJOV4zkKBoYk15UVywqLA3Je2i8nCBTJUey4srIvL47kyVEmihXWjFgCeEOIJY6KoYMDCg8Ulc268lTWweIBteRalXE8ZV1PueZWRVGsTCqtWhioZqbYHFkQynM9pbyUojBUpRbK4lBBEEkWK45MUegojh05uSZF/UXJcWT9g4r6SnK690u1UJHjKA4jRbLhl1/TnlJBqHxrq379652jvT0AjjPEEkeF79eU3l/SuD+ZpFJfSeX0cBTTTkpZJ62WVFquHPlhoGq5Isf1FIehFNSUbmqSea5i0/Cf9DKTYlMYhLLYFFSqisNAcRjIhqpySoOyvpKcQyUpCGW1QLHjKI5jOb4vNWflVXy1ZNLat+egDvWVRnt7ABxniCWOmnXf/f81+1N/qf5sVpWeg6pOiFVuyinlV1Tu3qfsmFZ5zS3ymrKK5SgMY6UcU7k0KMXx8J/0il3Fvj/8DT/xcExViyW/JvN9Of0l2f6iVAulKJL5viLXHb4gKIjkNGfkVWrKuo7aUin9cu+B0d4WAMchYomjpniwqP/5/i/U/uE5qlSq8nd3K0pnFOVa5Bzok7ujW2EmJTVlpExGjuMqTKVkcSwniuSYKY5dKQzkBKGcKJZqNTlBJAsCuX6g2K/JTMMvxUax4lT6D2edoZymjFy/Ji8yjc01qXRwSFW/NtrbAuA4RCxxVO345f9o3J92qPWsKRosDSnsLyk+VFIgk9OUUjqI5A5W5ThVKYhk3vCXEFgUS9Hwy69OPPzXo90oksJQkiOFoZwwlAWhzHFlKU9RU1ZWLkty5GTScmuBUlGstkxaVon0ws59o7wbAI5XxBJHVRCE+l3XZv3ZhFYNjmtRHAYqD1YVmaOa6yo2UyaKpJQnzzG5VV+OTOZ4kkzD5TQ5tdrwS7Mvv4o1ioffm5TJHJNVK5LnyOJIXjVQ2qSWtKtULdL23+9RGMWjtQ0AjnN8kTqOukP7+3Xg6a1q3bVfrc05ZXNZOa7JwpoiC1RzpKjqK/J9RRbJwkhOtSrFsWJHUhDIiSIpjuU4Nnx2WQsUyRSlXcVNaVnak7mOrOLLq/hKRbGaHamjuVUHekuEEsBbwpkl3ha/2/aicrt79Y4rZioa16JaS041k+JaKCv7sjBWrFhuLHlRLDc2uf7wz7Lh2yyOJTmKHcmaUsOfrXQcxVEklatyhipKxaa0pCbX1eTWVv3+hR7t7xsY5WcP4HjnmJmN9iKOhlKppHw+P9rLwCu0jm3Rn152jg7kPPW7rqqOFLmezHWlyOT5gVzXlYJQThjJq4XywlgKI4Vy5JpJ3vDLtypX5AxV5fiB3ChWSqaMpKznKRM76u7p02DZH+2nDGAUFYtFjRkz5i0/DmeWeFsN9g/pf362Xededo6yXqiSH6gSm4LYFLqu4mxmOIRxJKcWKgpjeVE8fLWr6yquhXIGhuSUq3KjWG4UyzNTyqSM5yrnuhosVrT7QGn4cQCgATizxKhoasqo44xJyhXyqnqOykGoahApkIa/fUcmJ4ykcPiqWCeK5cTDX1DgRrG82OTGw6HMSGrLZhRWA/Xs69dQhY+HABjWqDNLYolR5bqO8hPaNH7qBKVbmzRUC1SLIoWxKY5NcTj8sRFHGr7AJzJ5cSzXTFnHVdYchbVQtWqgnoNFxfEJ+c8ZwJvEy7A4IcSxqW9/Sf0HB3TKhDHymjKaOKFNvpnG5ttUqdY0WK4qCkO5Zkq5jpzYUVANVRoY1EuDVUUxV7oCOLqIJY4JFpt69xclSd279yud8tTblFUUxwqjSPEfguhIiiIjkADeVsQSx6QgjBQMlkd7GQAgiS8lAAAgEbEEACABsQQAIAGxBAAgAbEEACABsQQAIAGxBAAgAbEEACABsQQAIAGxBAAgAbEEACABsQQAIAGxBAAgAbEEACABsQQAIAGxBAAgAbEEACABsQQAIAGxBAAgAbEEACABsQQAIAGxBAAgAbEEACABsQQAIAGxBAAgAbEEACABsQQAIAGxBAAgAbEEACABsQQAIEHDYxmGob7whS9o2rRpyuVymj59ur74xS8qjuP6HDPTPffco46ODuVyOV1++eXavn37iMfxfV+LFy/WxIkT1dLSomuuuUZ79uxp9HIBAEhmDfalL33JJkyYYD/4wQ9sx44d9vjjj1tra6t95Stfqc9ZsWKFtbW12RNPPGFbt2616667ziZPnmylUqk+55ZbbrFTTz3Vurq6bNOmTfae97zHzjvvPAvD8IjWUSwWTRKDwWAwTuJRLBYb0raGx/Lqq6+2m2++ecSxD33oQ3bDDTeYmVkcx1YoFGzFihX126vVquXzeXvooYfMzKy/v9/S6bStXLmyPmfv3r3muq6tXr36iNZBLBkMBoPRqFg2/GXYOXPm6Mc//rGef/55SdIvf/lLrV27Vh/4wAckSTt27FBPT4/mzZtXv082m9XcuXO1bt06SdLGjRsVBMGIOR0dHers7KzPeSXf91UqlUYMAAAaIdXoB7z99ttVLBZ15plnyvM8RVGkL3/5y1qwYIEkqaenR5LU3t4+4n7t7e3auXNnfU4mk9G4ceMOm/PH+7/S8uXLde+99zb66QAA0PgLfB577DE9+uij+s53vqNNmzbpW9/6lv7xH/9R3/rWt0bMcxxnxM9mdtixV3q9OXfeeaeKxWJ97N69+609EQAA/qDhZ5a33Xab7rjjDn3kIx+RJM2cOVM7d+7U8uXLddNNN6lQKEgaPnucPHly/X69vb31s81CoaBaraa+vr4RZ5e9vb2aPXv2q/7ebDarbDbb6KcDAEDjzyzL5bJcd+TDep5X/+jItGnTVCgU1NXVVb+9VqtpzZo19RDOmjVL6XR6xJzu7m5t27btNWMJAMBR05DLhF7mpptuslNPPbX+0ZFVq1bZxIkT7XOf+1x9zooVKyyfz9uqVats69attmDBglf96MiUKVPsqaeesk2bNtkVV1zBR0cYDAaD8YbGMfvRkVKpZLfeequddtpp1tTUZNOnT7e77rrLfN+vz4nj2O6++24rFAqWzWbtsssus61bt454nEqlYosWLbLx48dbLpez+fPn265du454HcSSwWAwGI2KpWNmphNQqVRSPp8f7WUAAEZRsVjUmDFj3vLj8N2wAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkeMOx/NnPfqYPfvCD6ujokOM4+u53vzvidjPTPffco46ODuVyOV1++eXavn37iDm+72vx4sWaOHGiWlpadM0112jPnj0j5vT19WnhwoXK5/PK5/NauHCh+vv73/ATBADgrXrDsRwaGtJ5552nBx544FVvv++++3T//ffrgQce0IYNG1QoFHTVVVdpYGCgPmfJkiV68skntXLlSq1du1aDg4OaP3++oiiqz/noRz+qLVu2aPXq1Vq9erW2bNmihQsXvomnCADAW2RvgSR78skn6z/HcWyFQsFWrFhRP1atVi2fz9tDDz1kZmb9/f2WTqdt5cqV9Tl79+4113Vt9erVZmb23HPPmSR75pln6nPWr19vkuw3v/nNEa2tWCyaJAaDwWCcxKNYLL6VzNU19D3LHTt2qKenR/Pmzasfy2azmjt3rtatWydJ2rhxo4IgGDGno6NDnZ2d9Tnr169XPp/XRRddVJ9z8cUXK5/P1+e8ku/7KpVKIwYAAI3Q0Fj29PRIktrb20ccb29vr9/W09OjTCajcePGve6cSZMmHfb4kyZNqs95peXLl9ff38zn85o6depbfj4AAEhH6WpYx3FG/Gxmhx17pVfOebX5r/c4d955p4rFYn3s3r37TawcAIDDNTSWhUJBkg47++vt7a2fbRYKBdVqNfX19b3unH379h32+Pv37z/srPWPstmsxowZM2IAANAIDY3ltGnTVCgU1NXVVT9Wq9W0Zs0azZ49W5I0a9YspdPpEXO6u7u1bdu2+pxLLrlExWJRzz77bH3OL37xCxWLxfocAADeNm/0iqCBgQHbvHmzbd682STZ/fffb5s3b7adO3eamdmKFSssn8/bqlWrbOvWrbZgwQKbPHmylUql+mPccsstNmXKFHvqqads06ZNdsUVV9h5551nYRjW57z//e+3c88919avX2/r16+3mTNn2vz58494nVwNy2AwGIxGXQ37hmP59NNPv+qCbrrpJjMb/vjI3XffbYVCwbLZrF122WW2devWEY9RqVRs0aJFNn78eMvlcjZ//nzbtWvXiDkHDx6066+/3tra2qytrc2uv/566+vrO+J1EksGg8FgNCqWjpmZTkClUkn5fH60lwEAGEXFYrEh17Dw3bAAACQ4YWN5gp4wAwDegEa14ISN5cGDB0d7CQCAUfby7yV/K1INeZRj0Pjx4yVJu3bt4r3LI1AqlTR16lTt3r2bz6gmYK+OHHt15NirI3cke2VmGhgYUEdHR0N+5wkbS9cdPmnO5/P8w3sD+EKHI8deHTn26sixV0cuaa8aeaJ0wr4MCwBAoxBLAAASnLCxzGazuvvuu5XNZkd7KccF9uvIsVdHjr06cuzVkRuNvTphv5QAAIBGOWHPLAEAaBRiCQBAAmIJAEACYgkAQIITNpZf//rXNW3aNDU1NWnWrFn6+c9/PtpLelstX75c7373u9XW1qZJkybp2muv1W9/+9sRc8xM99xzjzo6OpTL5XT55Zdr+/btI+b4vq/Fixdr4sSJamlp0TXXXKM9e/a8nU/lbbd8+XI5jqMlS5bUj7FXI+3du1c33HCDJkyYoObmZr3zne/Uxo0b67ezX8PCMNQXvvAFTZs2TblcTtOnT9cXv/hFxXFcn3Oy7tXPfvYzffCDH1RHR4ccx9F3v/vdEbc3al/6+vq0cOFC5fN55fN5LVy4UP39/W98wQ35Q1/HmJUrV1o6nbZvfvOb9txzz9mtt95qLS0t9T9QfTJ43/veZ4888oht27bNtmzZYldffbWddtppNjg4WJ+zYsUKa2trsyeeeMK2bt1q11133av+oe5TTz3Vurq6bNOmTfae97znsD/UfSJ59tln7YwzzrBzzz3Xbr311vpx9up/HTp0yE4//XT767/+a/vFL35hO3bssKeeesp+//vf1+ewX8O+9KUv2YQJE+wHP/iB7dixwx5//HFrbW21r3zlK/U5J+te/fCHP7S77rrLnnjiCZNkTz755IjbG7Uv73//+62zs9PWrVtn69ats87OTps/f/4bXu8JGcsLL7zQbrnllhHHzjzzTLvjjjtGaUWjr7e31yTZmjVrzGz4j3QXCgVbsWJFfU61WrV8Pm8PPfSQmZn19/dbOp22lStX1ufs3bvXXNe11atXv71P4G0wMDBgM2bMsK6uLps7d249luzVSLfffrvNmTPnNW9nv/7X1VdfbTfffPOIYx/60IfshhtuMDP26o9eGctG7ctzzz1nkuyZZ56pz1m/fr1Jst/85jdvaI0n3MuwtVpNGzdu1Lx580YcnzdvntatWzdKqxp9xWJR0v9+wfyOHTvU09MzYp+y2azmzp1b36eNGzcqCIIRczo6OtTZ2XlC7uUnP/lJXX311Xrve9874jh7NdL3vvc9XXDBBfqrv/orTZo0Seeff76++c1v1m9nv/7XnDlz9OMf/1jPP/+8JOmXv/yl1q5dqw984AOS2KvX0qh9Wb9+vfL5vC666KL6nIsvvlj5fP4N790J90XqBw4cUBRFam9vH3G8vb1dPT09o7Sq0WVmWrp0qebMmaPOzk5Jqu/Fq+3Tzp0763MymYzGjRt32JwTbS9XrlypTZs2acOGDYfdxl6N9MILL+jBBx/U0qVL9fnPf17PPvusPvWpTymbzerGG29kv17m9ttvV7FY1JlnninP8xRFkb785S9rwYIFkvi39VoatS89PT2aNGnSYY8/adKkN7x3J1ws/8hxnBE/m9lhx04WixYt0q9+9SutXbv2sNvezD6daHu5e/du3XrrrfrRj36kpqam15zHXg2L41gXXHCBli1bJkk6//zztX37dj344IO68cYb6/PYL+mxxx7To48+qu985zs655xztGXLFi1ZskQdHR266aab6vPYq1fXiH15tflvZu9OuJdhJ06cKM/zDvuvht7e3sP+K+VksHjxYn3ve9/T008/rSlTptSPFwoFSXrdfSoUCqrVaurr63vNOSeCjRs3qre3V7NmzVIqlVIqldKaNWv01a9+ValUqv5c2athkydP1tlnnz3i2FlnnaVdu3ZJ4t/Wy912222644479JGPfEQzZ87UwoUL9elPf1rLly+XxF69lkbtS6FQ0L59+w57/P3797/hvTvhYpnJZDRr1ix1dXWNON7V1aXZs2eP0qrefmamRYsWadWqVfrJT36iadOmjbh92rRpKhQKI/apVqtpzZo19X2aNWuW0un0iDnd3d3atm3bCbWXV155pbZu3aotW7bUxwUXXKDrr79eW7Zs0fTp09mrl7n00ksP+xjS888/r9NPP10S/7Zerlwu1/+27h95nlf/6Ah79eoatS+XXHKJisWinn322fqcX/ziFyoWi298797Q5UDHiT9+dORf//Vf7bnnnrMlS5ZYS0uLvfjii6O9tLfNxz/+ccvn8/bTn/7Uuru766NcLtfnrFixwvL5vK1atcq2bt1qCxYseNVLs6dMmWJPPfWUbdq0ya644orj/pL1I/Hyq2HN2KuXe/bZZy2VStmXv/xl+93vfmff/va3rbm52R599NH6HPZr2E033WSnnnpq/aMjq1atsokTJ9rnPve5+pyTda8GBgZs8+bNtnnzZpNk999/v23evLn+Eb9G7cv73/9+O/fcc239+vW2fv16mzlzJh8debmvfe1rdvrpp1smk7F3vetd9Y9MnCwkvep45JFH6nPiOLa7777bCoWCZbNZu+yyy2zr1q0jHqdSqdiiRYts/PjxlsvlbP78+bZr1663+dm8/V4ZS/ZqpO9///vW2dlp2WzWzjzzTHv44YdH3M5+DSuVSnbrrbfaaaedZk1NTTZ9+nS76667zPf9+pyTda+efvrpV/3/qJtuusnMGrcvBw8etOuvv97a2tqsra3Nrr/+euvr63vD6+VPdAEAkOCEe88SAIBGI5YAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJCCWAAAkIJYAACQglgAAJPh/ddP77c3mnG0AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# loop over all seg masks\n", + "for o_id, color in zip(object_ids, object_segmentation_colors):\n", + " area = get_mask_area(im_seg, [color])\n", + " image_masked = blackout_image(image, area)\n", + " rgb_masked = image_masked[..., 0:3]\n", + "\n", + " fig = plt.figure(figsize=[5, 5])\n", + " ax = fig.add_subplot(111)\n", + " ax.imshow(rgb_masked)\n", + " ax.set_title(f\"{o_id}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## visualize the position estimates" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "STOP_T = 15\n", + "o_id = 3" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-0.29368106, 0.17293748, -0.03161981], dtype=float32)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "this_obj_gt_positions = []\n", + "# for i, positions in enumerate(position_arr):\n", + "for i, positions in enumerate(center_arr):\n", + " this_obj_gt_positions.append(positions[o_id-1])\n", + "this_obj_gt_positions = np.asanyarray(this_obj_gt_positions)\n", + "this_obj_gt_positions[STOP_T-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-1., 0., 0.], dtype=float32)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "initial_positions[o_id-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-1.00095296e+00, 6.84916833e-03, -1.11082615e-02],\n", + " [-9.65491712e-01, 2.18781307e-02, -1.57949366e-02],\n", + " [-9.13887560e-01, 1.12360306e-02, -2.80892272e-02],\n", + " [-8.75067651e-01, 1.57902893e-02, -2.17917413e-02],\n", + " [-8.15807581e-01, 3.37780900e-02, -2.71577053e-02],\n", + " [-7.67462552e-01, 3.26150544e-02, -7.26292655e-03],\n", + " [-7.20041573e-01, 1.58217177e-02, -6.05822355e-03],\n", + " [-6.64994538e-01, 1.70370657e-02, -8.62480886e-03],\n", + " [-6.03531778e-01, 2.55990606e-02, -7.44375773e-03],\n", + " [-5.58292270e-01, 1.38451327e-02, -6.56563789e-05],\n", + " [-5.15665472e-01, 2.07128786e-02, -1.79773290e-02],\n", + " [-4.58233416e-01, 2.18989663e-02, 1.12960916e-02],\n", + " [-4.29099858e-01, 1.90042593e-02, -2.60858703e-02],\n", + " [-4.01628464e-01, 2.81958915e-02, -4.12918404e-02],\n", + " [-3.51672649e-01, 2.41753664e-02, -1.09902546e-02]])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# all frames\n", + "position_samples = np.asanyarray([time_point[str(o_id)][1][0] for time_point in tracking_per_frame['pose']])\n", + "position_samples" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# position_samples = np.asanyarray([list(sample.values()) for sample in tracking_per_frame['position'][str(o_id)]])\n", + "# position_samples" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "762baa8e2f4b4300854bed7cad88adca", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib widget\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection=\"3d\")\n", + "\n", + "colors = 1.*np.array([i for i in range(len(this_obj_gt_positions))])/len(this_obj_gt_positions)\n", + "grayscale_map = plt.get_cmap('gray')\n", + "ax.scatter(this_obj_gt_positions[:, 0], this_obj_gt_positions[:, 2], this_obj_gt_positions[:, 1], s = 3, alpha=1, cmap = grayscale_map, c=colors)\n", + "ax.scatter(this_obj_gt_positions[STOP_T-1][0], this_obj_gt_positions[STOP_T-1][2], this_obj_gt_positions[STOP_T-1][1], s = 30, c='r')\n", + "ax.scatter(position_samples[:, 0], position_samples[:, 2], position_samples[:, 1], s = 10, alpha=1)\n", + "set_axes_equal(ax)\n", + "ax.set_xlabel(\"X\")\n", + "ax.set_ylabel(\"Z\")\n", + "ax.set_zlabel(\"Y\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 8.28535005e-04, 1.17899384e-02, -3.95691730e-02,\n", + " 9.99146819e-01],\n", + " [ 2.92200223e-02, 8.38121399e-02, -6.72146007e-02,\n", + " 9.93782699e-01],\n", + " [ 6.37040958e-02, 1.09020611e-02, -8.32073689e-02,\n", + " 9.94434297e-01],\n", + " [ 2.40141917e-02, 2.83113942e-02, -1.40159205e-01,\n", + " 9.89432812e-01],\n", + " [ 3.49509623e-03, 4.87751514e-02, -9.15819183e-02,\n", + " 9.94596183e-01],\n", + " [-5.04451543e-02, 5.42356260e-02, -1.15116902e-01,\n", + " 9.90586579e-01],\n", + " [-2.13937405e-02, 5.22940159e-02, -1.37855485e-01,\n", + " 9.88839567e-01],\n", + " [-4.81093712e-02, 7.85772726e-02, -1.00475125e-01,\n", + " 9.90664363e-01],\n", + " [ 1.26285281e-03, 1.77557081e-01, -8.93697590e-02,\n", + " 9.80043292e-01],\n", + " [-3.07309628e-02, 1.35542795e-01, -8.27388093e-02,\n", + " 9.86832380e-01],\n", + " [-2.67223325e-02, 1.06785044e-01, -7.15382248e-02,\n", + " 9.91345108e-01],\n", + " [-9.95765030e-02, 1.01405144e-01, -1.20643362e-01,\n", + " 9.82469738e-01],\n", + " [-2.56001428e-02, 8.43010098e-02, -1.28784254e-01,\n", + " 9.87751365e-01],\n", + " [-3.80418892e-03, 2.94221193e-02, -1.75869107e-01,\n", + " 9.83966410e-01],\n", + " [-4.87743132e-02, 8.06807429e-02, -1.62506506e-01,\n", + " 9.82193112e-01]])" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# all frames\n", + "rotation_samples = np.asanyarray([time_point[str(o_id)][1][1] for time_point in tracking_per_frame['pose']])\n", + "rotation_samples" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.98711214, 0.18130092, -0.0109818 ],\n", + " [-0.94125572, 0.19499806, -0.0076032 ],\n", + " [-0.884684 , 0.18239244, -0.00623439],\n", + " [-0.82629236, 0.18371284, -0.01486443],\n", + " [-0.78386746, 0.20583828, -0.02750445],\n", + " [-0.72850848, 0.20208624, -0.02693773],\n", + " [-0.67272221, 0.18401008, -0.01598562],\n", + " [-0.63147965, 0.18769365, -0.02806916],\n", + " [-0.57279811, 0.19780307, -0.01256446],\n", + " [-0.53117288, 0.18611859, -0.01460499],\n", + " [-0.49184254, 0.19367175, -0.02992292],\n", + " [-0.42028261, 0.18833436, -0.02722657],\n", + " [-0.38533282, 0.18796999, -0.03873599],\n", + " [-0.34110039, 0.19236534, -0.04441301],\n", + " [-0.29718548, 0.18909981, -0.03234618]])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "calculated_centers = []\n", + "for i in range(STOP_T):\n", + " calculated_center, q = compute_center_of_mass(object_meshes[o_id-1].bounding_box,\n", + " position_samples[i], rotation_samples[i])\n", + " calculated_centers.append(calculated_center)\n", + "calculated_centers = np.asanyarray(calculated_centers)\n", + "calculated_centers" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "601a608b927d4c1f8e98ec96417c4460", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib widget\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection=\"3d\")\n", + "\n", + "colors = 1.*np.array([i for i in range(len(this_obj_gt_positions))])/len(this_obj_gt_positions)\n", + "grayscale_map = plt.get_cmap('gray')\n", + "ax.scatter(this_obj_gt_positions[:, 0], this_obj_gt_positions[:, 2], this_obj_gt_positions[:, 1], s = 3, alpha=1, cmap = grayscale_map, c=colors)\n", + "ax.scatter(this_obj_gt_positions[STOP_T-1][0], this_obj_gt_positions[STOP_T-1][2], this_obj_gt_positions[STOP_T-1][1], s = 30, c='r')\n", + "ax.scatter(calculated_centers[:, 0], calculated_centers[:, 2], calculated_centers[:, 1], s = 10, alpha=1)\n", + "set_axes_equal(ax)\n", + "ax.set_xlabel(\"X\")\n", + "ax.set_ylabel(\"Z\")\n", + "ax.set_zlabel(\"Y\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# %matplotlib widget\n", + "\n", + "# for i in range(STOP_T):\n", + "# position_samples = np.asanyarray([sample[1] for sample in tracking_per_frame['pose'][i][str(o_id)][0]])\n", + "# fig = plt.figure()\n", + "# ax = fig.add_subplot(111, projection=\"3d\")\n", + "# ax.scatter(this_obj_gt_positions[i][0], this_obj_gt_positions[i][2], this_obj_gt_positions[i][1], s = 30, c='r')\n", + "# ax.scatter(position_samples[:, 0], position_samples[:, 2], position_samples[:, 1], s = 10, alpha=1)\n", + "# set_axes_equal(ax)\n", + "# ax.set_xlabel(\"X\")\n", + "# ax.set_ylabel(\"Z\")\n", + "# ax.set_zlabel(\"Y\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "t = -1" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.37646371, 0.03780932, -0.05047539],\n", + " [-0.36321011, 0.02077067, -0.0450751 ],\n", + " [-0.34622207, 0.01126229, -0.03866339],\n", + " [-0.36816496, 0.0299918 , -0.04072931],\n", + " [-0.35349569, 0.02234416, -0.05197039],\n", + " [-0.35056672, 0.01649456, -0.04602091],\n", + " [-0.38144296, 0.05037566, -0.07153348],\n", + " [-0.3667981 , 0.03801852, -0.03898222],\n", + " [-0.350225 , 0.03164615, -0.05090253],\n", + " [-0.36484545, 0.03277634, -0.05247685],\n", + " [-0.36767679, 0.04042766, -0.01859231],\n", + " [-0.35256818, 0.04276765, -0.05349589],\n", + " [-0.34143808, 0.01052285, -0.04502628],\n", + " [-0.37185058, 0.05637471, -0.0721925 ],\n", + " [-0.35752302, 0.03402748, -0.03428061],\n", + " [-0.33235827, 0.00969161, -0.01322252],\n", + " [-0.3616724 , 0.04181617, -0.0685801 ],\n", + " [-0.37355915, 0.04843339, -0.05813343],\n", + " [-0.35115251, 0.02681798, -0.04855325],\n", + " [-0.33826503, 0.01142368, -0.01759157],\n", + " [-0.37717155, 0.06316064, -0.03709365],\n", + " [-0.38188231, 0.06486024, -0.05813343],\n", + " [-0.34807709, 0.01570262, -0.02335189],\n", + " [-0.36594382, 0.04744281, -0.05544854],\n", + " [-0.34573391, 0.03549797, -0.03833541],\n", + " [-0.37938046, 0.06386681, -0.07404751],\n", + " [-0.3384603 , 0.02112871, -0.01136751],\n", + " [-0.36655402, 0.0432781 , -0.02877048],\n", + " [-0.37548739, 0.06750023, -0.04306143],\n", + " [-0.3616724 , 0.01706829, -0.01832382],\n", + " [-0.36142832, 0.01666203, -0.03420129],\n", + " [-0.33196774, 0.01524378, -0.00624181],\n", + " [-0.37231433, 0.05404275, -0.05718151],\n", + " [-0.36123306, 0.02767913, -0.04377994],\n", + " [-0.37689084, 0.04822827, -0.06714002],\n", + " [-0.33675173, 0.02281218, -0.04000813],\n", + " [-0.34578273, 0.0098485 , -0.03432333],\n", + " [-0.37801361, 0.04263039, -0.06307607],\n", + " [-0.34246323, 0.03248134, -0.05099406],\n", + " [-0.39022988, 0.05140185, -0.0480956 ],\n", + " [-0.38982713, 0.08993228, -0.05175681],\n", + " [-0.36753035, 0.05436692, -0.07382784],\n", + " [-0.3378745 , 0.02137993, -0.02268066],\n", + " [-0.38101584, 0.04152513, -0.02975291],\n", + " [-0.36457697, 0.06120138, -0.06721324],\n", + " [-0.34158453, 0.02344031, -0.04825425],\n", + " [-0.36301485, 0.06042998, -0.07316882],\n", + " [-0.37355915, 0.05717932, -0.03596477],\n", + " [-0.37314421, 0.07412001, -0.06482125],\n", + " [-0.37248519, 0.09459238, -0.07253421]])" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# last frame\n", + "position_samples_last = np.asanyarray([sample[1] for sample in tracking_per_frame['pose'][t][str(o_id)][0]])\n", + "position_samples_last" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([10., 6., 7., 9., 5., 5., 5., 1., 0., 2.]),\n", + " array([0.00969161, 0.01818169, 0.02667177, 0.03516184, 0.04365192,\n", + " 0.052142 , 0.06063207, 0.06912215, 0.07761222, 0.0861023 ,\n", + " 0.09459238]),\n", + " )" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "dc1e9969db344fcaa0e2f5cf2ce77ef4", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=[10, 10])\n", + "plt.hist(position_samples_last[:,1])" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# %matplotlib widget\n", + "\n", + "# fig = plt.figure()\n", + "# ax = fig.add_subplot(111, projection=\"3d\")\n", + "\n", + "# colors = 1.*np.array([i for i in range(len(this_obj_gt_positions))])/len(this_obj_gt_positions)\n", + "# grayscale_map = plt.get_cmap('gray')\n", + "# ax.scatter(this_obj_gt_positions[:, 0], this_obj_gt_positions[:, 2], this_obj_gt_positions[:, 1], s = 3, alpha=1, cmap = grayscale_map, c=colors)\n", + "# # ax.scatter(this_obj_gt_positions[-1][0], this_obj_gt_positions[-1][2], this_obj_gt_positions[-1][1], s = 30, c='r')\n", + "# ax.scatter(position_samples_last[:, 0], position_samples_last[:, 2], position_samples_last[:, 1], s = 10, alpha=1)\n", + "# set_axes_equal(ax)\n", + "# ax.set_xlabel(\"X\")\n", + "# ax.set_ylabel(\"Z\")\n", + "# ax.set_zlabel(\"Y\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.0104837 , 0.02271038, -0.22068948, 0.97502327],\n", + " [ 0.02599362, 0.03115438, -0.18855152, 0.98122478],\n", + " [ 0.00425251, 0.05315899, -0.16628592, 0.98463446],\n", + " [-0.00284613, 0.06054017, -0.1899211 , 0.97992688],\n", + " [ 0.04110445, 0.01205608, -0.1966265 , 0.97954232],\n", + " [-0.00171278, -0.02026681, -0.17418139, 0.98450357],\n", + " [ 0.05094071, 0.03872947, -0.22377168, 0.97253859],\n", + " [-0.00754608, 0.01831559, -0.21336816, 0.97677094],\n", + " [ 0.00403435, 0.02266371, -0.12360623, 0.99206436],\n", + " [ 0.00556966, -0.00897426, -0.17113996, 0.98519021],\n", + " [-0.06112522, 0.05004518, -0.20657851, 0.9752357 ],\n", + " [-0.0059771 , 0.05062294, -0.11628411, 0.99190718],\n", + " [ 0.06414255, 0.04928863, -0.16590142, 0.98281908],\n", + " [ 0.03801371, 0.03504976, -0.1849294 , 0.98139071],\n", + " [-0.01471392, -0.02434623, -0.18217891, 0.98285389],\n", + " [-0.04505524, 0.03794444, -0.15340319, 0.98640639],\n", + " [ 0.0630424 , 0.0168574 , -0.1541854 , 0.98588455],\n", + " [ 0.00773089, 0.03704947, -0.21203211, 0.97652954],\n", + " [ 0.029273 , 0.06318658, -0.13211422, 0.98878527],\n", + " [-0.0172925 , 0.04690454, -0.18010904, 0.98237562],\n", + " [-0.06457808, 0.02648569, -0.16878164, 0.98317897],\n", + " [-0.00633061, 0.013513 , -0.18577689, 0.98247868],\n", + " [ 0.01556312, 0.0691691 , -0.19141246, 0.97894585],\n", + " [ 0.01719947, 0.04493428, -0.14842312, 0.9877528 ],\n", + " [-0.04736631, 0.09668552, -0.12961833, 0.98570156],\n", + " [ 0.02535759, 0.00269253, -0.20740511, 0.97792274],\n", + " [-0.05378445, -0.00915703, -0.16234542, 0.98522443],\n", + " [-0.02580038, 0.08964881, -0.23648028, 0.96714765],\n", + " [-0.03470911, 0.07372941, -0.16059987, 0.98364979],\n", + " [-0.03755067, 0.04755177, -0.17887133, 0.982005 ],\n", + " [ 0.03054258, 0.03821587, -0.18396118, 0.98171532],\n", + " [-0.05872642, 0.0102215 , -0.17113967, 0.98344195],\n", + " [-0.02682884, 0.05328728, -0.17977977, 0.98189604],\n", + " [-0.01910005, 0.03743112, -0.21282631, 0.97618598],\n", + " [ 0.00721353, 0.01259369, -0.20333238, 0.97900224],\n", + " [-0.04676933, 0.03175107, -0.10233843, 0.99314219],\n", + " [-0.03113855, 0.00446345, -0.1341251 , 0.99046504],\n", + " [ 0.05709428, -0.01121927, -0.19595364, 0.97888541],\n", + " [ 0.015122 , -0.00873158, -0.1707546 , 0.98515886],\n", + " [-0.04493224, -0.01513889, -0.22123498, 0.97406733],\n", + " [-0.06019127, -0.02068037, -0.17913431, 0.98176378],\n", + " [ 0.00801905, -0.00833992, -0.16901912, 0.98554486],\n", + " [-0.03313876, -0.0071348 , -0.18171781, 0.98276633],\n", + " [-0.03606282, 0.02781941, -0.2007613 , 0.97858089],\n", + " [ 0.02879842, -0.00857821, -0.1881505 , 0.98168033],\n", + " [ 0.00690688, 0.01484077, -0.18283728, 0.98300695],\n", + " [-0.00871496, 0.02325567, -0.12201422, 0.9922176 ],\n", + " [-0.02863098, 0.03667955, -0.17296386, 0.98382849],\n", + " [-0.00211839, 0.08605037, -0.18508889, 0.9789449 ],\n", + " [-0.01372181, -0.00758913, -0.12557647, 0.99195999]])" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rotation_samples_last = np.asanyarray([sample[2] for sample in tracking_per_frame['pose'][t][str(o_id)][0]])\n", + "rotation_samples_last" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.30106829, 0.1957245 , -0.04865192],\n", + " [-0.29817268, 0.18309109, -0.03820411],\n", + " [-0.28883716, 0.1765781 , -0.04029174],\n", + " [-0.30308718, 0.19236445, -0.04572971],\n", + " [-0.28591085, 0.18322112, -0.03870783],\n", + " [-0.2905358 , 0.18087482, -0.04537556],\n", + " [-0.30458314, 0.20694161, -0.05722714],\n", + " [-0.29390233, 0.1970645 , -0.04292979],\n", + " [-0.30727414, 0.20129298, -0.0504822 ],\n", + " [-0.30585107, 0.19751437, -0.05001879],\n", + " [-0.29823551, 0.19918382, -0.04307471],\n", + " [-0.31230403, 0.21302244, -0.05763127],\n", + " [-0.2832637 , 0.17444971, -0.02582407],\n", + " [-0.30786346, 0.21889934, -0.0614039 ],\n", + " [-0.29472832, 0.1973355 , -0.0377898 ],\n", + " [-0.27999536, 0.17574473, -0.03081478],\n", + " [-0.3080973 , 0.20710455, -0.04773642],\n", + " [-0.30098943, 0.20767731, -0.05824061],\n", + " [-0.30478372, 0.1954091 , -0.04134435],\n", + " [-0.27662177, 0.17496528, -0.02649405],\n", + " [-0.31969029, 0.22673049, -0.06088039],\n", + " [-0.31802962, 0.22776664, -0.06118896],\n", + " [-0.28211649, 0.17779429, -0.02265342],\n", + " [-0.31436145, 0.21462897, -0.0518367 ],\n", + " [-0.30261904, 0.2038324 , -0.05906285],\n", + " [-0.30836741, 0.22358585, -0.06556375],\n", + " [-0.28230657, 0.18589162, -0.02939361],\n", + " [-0.2873146 , 0.19847209, -0.04492402],\n", + " [-0.32109215, 0.23305126, -0.05915532],\n", + " [-0.30081897, 0.18037654, -0.03420703],\n", + " [-0.29781067, 0.17949093, -0.02616743],\n", + " [-0.27327077, 0.17878562, -0.02706797],\n", + " [-0.31103094, 0.21747855, -0.0697546 ],\n", + " [-0.28876796, 0.18669818, -0.05309397],\n", + " [-0.30718705, 0.20873964, -0.06556455],\n", + " [-0.30169866, 0.19338099, -0.05740241],\n", + " [-0.2993352 , 0.17821279, -0.04532743],\n", + " [-0.31110216, 0.20305023, -0.04274555],\n", + " [-0.2836323 , 0.1971963 , -0.04525807],\n", + " [-0.3145676 , 0.20856452, -0.06224182],\n", + " [-0.3278378 , 0.25243304, -0.07114298],\n", + " [-0.30925218, 0.2193458 , -0.07056838],\n", + " [-0.2752866 , 0.18443809, -0.03362556],\n", + " [-0.31260557, 0.20196315, -0.04405931],\n", + " [-0.30001714, 0.22352089, -0.05675355],\n", + " [-0.27864305, 0.1867233 , -0.04682763],\n", + " [-0.32071315, 0.23019278, -0.07718845],\n", + " [-0.31436834, 0.22142163, -0.04804405],\n", + " [-0.30979088, 0.23712818, -0.07112151],\n", + " [-0.32885035, 0.26400717, -0.07696467]])" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "calculated_centers_last = []\n", + "for position_last, rotation_last in zip(position_samples_last, rotation_samples_last):\n", + " calculated_center, _ = compute_center_of_mass(object_meshes[o_id-1].bounding_box,\n", + " position_last, rotation_last)\n", + " calculated_centers_last.append(calculated_center)\n", + "calculated_centers_last = np.asanyarray(calculated_centers_last)\n", + "calculated_centers_last" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Y')" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "16b1de56e0274ec89c23fb7929e5b793", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib widget\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection=\"3d\")\n", + "\n", + "ax.scatter(calculated_centers_last[:, 0], calculated_centers_last[:, 2], calculated_centers_last[:, 1], s = 3, alpha=1)\n", + "ax.scatter(this_obj_gt_positions[STOP_T+t][0], this_obj_gt_positions[STOP_T+t][2], this_obj_gt_positions[STOP_T+t][1], s = 30, c='r')\n", + "set_axes_equal(ax)\n", + "ax.set_xlabel(\"X\")\n", + "ax.set_ylabel(\"Z\")\n", + "ax.set_zlabel(\"Y\")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Y')" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "10848014885c4df98bc09caebd172245", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib widget\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection=\"3d\")\n", + "\n", + "ax.scatter(position_samples_last[:, 0], position_samples_last[:, 2], position_samples_last[:, 1], s = 3, alpha=1)\n", + "ax.scatter(this_obj_gt_positions[STOP_T+t][0], this_obj_gt_positions[STOP_T+t][2], this_obj_gt_positions[STOP_T+t][1], s = 30, c='r')\n", + "set_axes_equal(ax)\n", + "ax.set_xlabel(\"X\")\n", + "ax.set_ylabel(\"Z\")\n", + "ax.set_zlabel(\"Y\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## visualize the rotation" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 2.05170968e-05, 1.14232273e-04, -1.51661529e-04],\n", + " [ 1.63768445e+00, 1.76597930e+01, 9.15390570e+00],\n", + " [ 6.48077637e+00, 3.47327994e+01, 1.90415868e+01],\n", + " [ 1.71676078e+01, 5.04548336e+01, 3.35473828e+01],\n", + " [ 3.99559476e+01, 6.26433342e+01, 5.82015715e+01],\n", + " [ 7.96853820e+01, 6.60564454e+01, 9.94786433e+01],\n", + " [ 1.12641813e+02, 5.78926991e+01, 1.34001854e+02],\n", + " [ 1.28182571e+02, 4.36620652e+01, 1.50229012e+02],\n", + " [ 1.36060194e+02, 2.76183729e+01, 1.57561071e+02],\n", + " [ 1.41286399e+02, 1.10636551e+01, 1.61345724e+02],\n", + " [ 1.45497459e+02, -5.67441001e+00, 1.63057094e+02],\n", + " [ 1.48921658e+02, -2.25364381e+01, 1.63046457e+02],\n", + " [ 1.52421986e+02, -3.94143317e+01, 1.61506010e+02],\n", + " [ 1.58448185e+02, -5.60361212e+01, 1.57026763e+02],\n", + " [ 1.76130428e+02, -7.12084419e+01, 1.39715798e+02],\n", + " [-1.21170117e+02, -7.80306050e+01, 7.66776882e+01],\n", + " [-7.41910019e+01, -6.72548234e+01, 2.86195733e+01],\n", + " [-6.13050829e+01, -5.16899783e+01, 1.37956001e+01],\n", + " [-5.64676790e+01, -3.52508955e+01, 6.78391687e+00],\n", + " [-5.46599239e+01, -1.86580715e+01, 1.67496252e+00],\n", + " [-5.47926585e+01, -2.28525587e+00, -3.32610116e+00],\n", + " [-5.71793437e+01, 1.32395614e+01, -1.08804238e+01],\n", + " [-6.17072167e+01, 2.83484826e+01, -1.97957688e+01],\n", + " [-7.02113330e+01, 4.24421228e+01, -3.20580764e+01],\n", + " [-8.59985489e+01, 5.41923272e+01, -5.12366779e+01],\n", + " [-1.12875456e+02, 6.05694949e+01, -8.13222735e+01],\n", + " [-1.43512170e+02, 5.80867029e+01, -1.15165110e+02],\n", + " [-1.62186817e+02, 4.83108880e+01, -1.40674232e+02],\n", + " [-1.71427741e+02, 3.52534430e+01, -1.57432438e+02],\n", + " [-1.75276639e+02, 2.09071693e+01, -1.69812355e+02],\n", + " [-1.75759928e+02, 6.17573996e+00, 1.79520156e+02],\n", + " [-1.73510609e+02, -8.39148740e+00, 1.68922919e+02],\n", + " [-1.68495917e+02, -2.16204694e+01, 1.57635025e+02],\n", + " [-1.60294806e+02, -3.34816083e+01, 1.43880389e+02],\n", + " [-1.47471141e+02, -4.27877291e+01, 1.25844747e+02],\n", + " [-1.29360019e+02, -4.80076446e+01, 1.02992358e+02],\n", + " [-1.09407073e+02, -4.67288495e+01, 7.85502442e+01],\n", + " [-9.29234123e+01, -4.02974249e+01, 5.74475177e+01],\n", + " [-8.23492605e+01, -3.08446309e+01, 4.19856913e+01],\n", + " [-7.52418414e+01, -1.99352817e+01, 2.97442445e+01],\n", + " [-7.09388704e+01, -7.99076582e+00, 1.95225398e+01],\n", + " [-6.87868518e+01, 4.21273994e+00, 1.03449502e+01],\n", + " [-6.85864730e+01, 1.65994695e+01, 1.31328008e+00],\n", + " [-7.06295825e+01, 2.86706985e+01, -8.82644071e+00],\n", + " [-7.50712873e+01, 3.71263837e+01, -1.61530562e+01],\n", + " [-8.12072116e+01, 4.47240329e+01, -2.31405258e+01],\n", + " [-8.97017997e+01, 5.15952440e+01, -3.24425369e+01],\n", + " [-1.01514983e+02, 5.72763908e+01, -4.50323820e+01],\n", + " [-1.17286723e+02, 6.10559495e+01, -6.15616098e+01],\n", + " [-1.32843543e+02, 6.14987505e+01, -7.73174064e+01],\n", + " [-1.47363627e+02, 6.00214712e+01, -9.24760245e+01],\n", + " [-1.59823442e+02, 5.68453644e+01, -1.05559007e+02],\n", + " [-1.69726129e+02, 5.24051754e+01, -1.16097587e+02],\n", + " [-1.77354752e+02, 4.70922678e+01, -1.24381030e+02],\n", + " [ 1.76788705e+02, 4.11917084e+01, -1.30918294e+02],\n", + " [ 1.72249798e+02, 3.48930129e+01, -1.36171805e+02],\n", + " [ 1.68738599e+02, 2.83669503e+01, -1.40316757e+02],\n", + " [ 1.65962213e+02, 2.16945537e+01, -1.43681234e+02],\n", + " [ 1.63700325e+02, 1.48951077e+01, -1.46580174e+02],\n", + " [ 1.61853650e+02, 8.01910628e+00, -1.49117370e+02],\n", + " [ 1.60801332e+02, 1.82610227e+00, -1.50616807e+02],\n", + " [ 1.59819684e+02, -4.21441685e+00, -1.51643939e+02],\n", + " [ 1.58942175e+02, -1.02790953e+01, -1.52600585e+02],\n", + " [ 1.58142432e+02, -1.63535895e+01, -1.53475296e+02],\n", + " [ 1.57418072e+02, -2.24421966e+01, -1.54301872e+02],\n", + " [ 1.56755864e+02, -2.85397921e+01, -1.55083968e+02],\n", + " [ 1.56149812e+02, -3.46448259e+01, -1.55833517e+02],\n", + " [ 1.55530887e+02, -4.07403326e+01, -1.56476291e+02],\n", + " [ 1.54122128e+02, -4.65369768e+01, -1.56005127e+02],\n", + " [ 1.51495496e+02, -5.18124784e+01, -1.53869310e+02],\n", + " [ 1.48168518e+02, -5.70149399e+01, -1.51022817e+02],\n", + " [ 1.43745253e+02, -6.20948669e+01, -1.47067406e+02],\n", + " [ 1.36385996e+02, -6.63853254e+01, -1.40728456e+02],\n", + " [ 1.26521229e+02, -6.79056059e+01, -1.33669522e+02],\n", + " [ 1.18648730e+02, -6.89594727e+01, -1.27658721e+02],\n", + " [ 1.10757809e+02, -6.95224593e+01, -1.21578951e+02],\n", + " [ 1.03163311e+02, -6.96503439e+01, -1.15765391e+02],\n", + " [ 9.58862642e+01, -6.94928295e+01, -1.10549421e+02],\n", + " [ 8.90226928e+01, -6.90557915e+01, -1.05686651e+02],\n", + " [ 8.27773726e+01, -6.84573570e+01, -1.01458796e+02],\n", + " [ 7.71476689e+01, -6.77000071e+01, -9.78457186e+01],\n", + " [ 7.21341633e+01, -6.68191321e+01, -9.48587149e+01],\n", + " [ 6.77075938e+01, -6.58463612e+01, -9.24790618e+01],\n", + " [ 6.41302947e+01, -6.47786253e+01, -9.08013585e+01],\n", + " [ 6.12901614e+01, -6.36591936e+01, -8.97613003e+01],\n", + " [ 5.89212528e+01, -6.25089628e+01, -8.91294881e+01],\n", + " [ 5.69979073e+01, -6.11908753e+01, -8.90005916e+01],\n", + " [ 5.53918432e+01, -5.98604959e+01, -8.91227823e+01],\n", + " [ 5.40257530e+01, -5.85497039e+01, -8.94351884e+01],\n", + " [ 5.28336265e+01, -5.72813674e+01, -8.98243546e+01],\n", + " [ 5.17993362e+01, -5.59869214e+01, -9.03578036e+01],\n", + " [ 5.09620589e+01, -5.47486867e+01, -9.10466401e+01],\n", + " [ 5.03479982e+01, -5.35963095e+01, -9.19651059e+01],\n", + " [ 5.00408027e+01, -5.24646555e+01, -9.31118208e+01],\n", + " [ 4.98008345e+01, -5.13570423e+01, -9.43137757e+01],\n", + " [ 4.96049096e+01, -5.02651822e+01, -9.55562254e+01],\n", + " [ 4.93852909e+01, -4.91954670e+01, -9.67936036e+01],\n", + " [ 4.91646201e+01, -4.81401051e+01, -9.80374139e+01],\n", + " [ 4.89297077e+01, -4.70822028e+01, -9.93049910e+01],\n", + " [ 4.86785632e+01, -4.60414158e+01, -1.00512781e+02],\n", + " [ 4.84111742e+01, -4.50040572e+01, -1.01656834e+02],\n", + " [ 4.81133792e+01, -4.39765130e+01, -1.02747386e+02],\n", + " [ 4.78010807e+01, -4.29511816e+01, -1.03805507e+02],\n", + " [ 4.74569234e+01, -4.19285473e+01, -1.04826750e+02],\n", + " [ 4.70863975e+01, -4.09013596e+01, -1.05822760e+02],\n", + " [ 4.66902032e+01, -3.98676762e+01, -1.06797557e+02],\n", + " [ 4.62761440e+01, -3.88207107e+01, -1.07762595e+02],\n", + " [ 4.58445785e+01, -3.77593986e+01, -1.08720728e+02],\n", + " [ 4.53915101e+01, -3.66759932e+01, -1.09679707e+02],\n", + " [ 4.49506589e+01, -3.56543158e+01, -1.10617139e+02],\n", + " [ 4.45113263e+01, -3.46765747e+01, -1.11542406e+02],\n", + " [ 4.40529208e+01, -3.37306376e+01, -1.12454392e+02],\n", + " [ 4.35866918e+01, -3.28186940e+01, -1.13352417e+02],\n", + " [ 4.31138564e+01, -3.19236787e+01, -1.14256335e+02],\n", + " [ 4.26357697e+01, -3.10542159e+01, -1.15156824e+02],\n", + " [ 4.21503936e+01, -3.01936458e+01, -1.16073118e+02],\n", + " [ 4.16604991e+01, -2.93512411e+01, -1.16996551e+02],\n", + " [ 4.11675958e+01, -2.85142180e+01, -1.17940124e+02],\n", + " [ 4.06686799e+01, -2.76807242e+01, -1.18906744e+02],\n", + " [ 4.01596358e+01, -2.68473447e+01, -1.19901020e+02],\n", + " [ 3.96334516e+01, -2.60176016e+01, -1.20836586e+02],\n", + " [ 3.90905976e+01, -2.51937130e+01, -1.21726280e+02],\n", + " [ 3.85277200e+01, -2.43687157e+01, -1.22590923e+02],\n", + " [ 3.79464543e+01, -2.35443211e+01, -1.23432212e+02],\n", + " [ 3.73437137e+01, -2.27150806e+01, -1.24256873e+02],\n", + " [ 3.67190981e+01, -2.18796395e+01, -1.25067170e+02],\n", + " [ 3.60683074e+01, -2.10337435e+01, -1.25868653e+02],\n", + " [ 3.53906954e+01, -2.01753118e+01, -1.26664263e+02],\n", + " [ 3.46811007e+01, -1.93011277e+01, -1.27458981e+02],\n", + " [ 3.39529354e+01, -1.83991844e+01, -1.28261167e+02],\n", + " [ 3.31997024e+01, -1.74852465e+01, -1.29084449e+02],\n", + " [ 3.24373550e+01, -1.65812707e+01, -1.29967874e+02],\n", + " [ 3.16893686e+01, -1.57685702e+01, -1.30885677e+02],\n", + " [ 3.09813436e+01, -1.50044488e+01, -1.31729342e+02],\n", + " [ 3.02763343e+01, -1.42884573e+01, -1.32523497e+02],\n", + " [ 2.95894392e+01, -1.35861111e+01, -1.33295536e+02],\n", + " [ 2.89167786e+01, -1.29123082e+01, -1.34035158e+02],\n", + " [ 2.82433805e+01, -1.22540220e+01, -1.34756031e+02],\n", + " [ 2.75796152e+01, -1.16173971e+01, -1.35450464e+02],\n", + " [ 2.69107566e+01, -1.09904671e+01, -1.36131267e+02],\n", + " [ 2.62477933e+01, -1.03637082e+01, -1.36803371e+02],\n", + " [ 2.55951034e+01, -9.74896800e+00, -1.37452811e+02],\n", + " [ 2.49304569e+01, -9.14318561e+00, -1.38092616e+02],\n", + " [ 2.42554175e+01, -8.54036412e+00, -1.38725572e+02],\n", + " [ 2.35688529e+01, -7.94103381e+00, -1.39350732e+02],\n", + " [ 2.28638607e+01, -7.34886444e+00, -1.39972284e+02],\n", + " [ 2.21394429e+01, -6.75842885e+00, -1.40593284e+02],\n", + " [ 2.13879302e+01, -6.16291266e+00, -1.41221177e+02],\n", + " [ 2.06092443e+01, -5.56795069e+00, -1.41853992e+02],\n", + " [ 1.98036652e+01, -4.96728197e+00, -1.42494985e+02],\n", + " [ 1.90250934e+01, -4.39092222e+00, -1.43170269e+02],\n", + " [ 1.82779035e+01, -3.84793008e+00, -1.43880877e+02],\n", + " [ 1.75519950e+01, -3.32377846e+00, -1.44622080e+02],\n", + " [ 1.68349068e+01, -2.81664244e+00, -1.45400184e+02],\n", + " [ 1.61083423e+01, -2.31247099e+00, -1.46139556e+02],\n", + " [ 1.53687528e+01, -1.80916087e+00, -1.46847819e+02],\n", + " [ 1.46106052e+01, -1.30764212e+00, -1.47533439e+02],\n", + " [ 1.38292134e+01, -8.14058985e-01, -1.48198239e+02],\n", + " [ 1.30237829e+01, -3.21929020e-01, -1.48845579e+02],\n", + " [ 1.22012596e+01, 1.83685118e-01, -1.49477988e+02],\n", + " [ 1.13501145e+01, 6.94971666e-01, -1.50099832e+02],\n", + " [ 1.05426769e+01, 1.17116662e+00, -1.50713445e+02],\n", + " [ 9.77117388e+00, 1.61759476e+00, -1.51321125e+02],\n", + " [ 9.01795990e+00, 2.03629562e+00, -1.51929338e+02],\n", + " [ 8.28272781e+00, 2.43398047e+00, -1.52539578e+02],\n", + " [ 7.57163302e+00, 2.81034936e+00, -1.53147185e+02],\n", + " [ 6.87110660e+00, 3.16818822e+00, -1.53761421e+02],\n", + " [ 6.18139684e+00, 3.51150059e+00, -1.54383769e+02],\n", + " [ 5.50760109e+00, 3.83873387e+00, -1.55009588e+02],\n", + " [ 4.83713422e+00, 4.15271743e+00, -1.55648779e+02],\n", + " [ 4.16975672e+00, 4.45637246e+00, -1.56302958e+02],\n", + " [ 3.51026434e+00, 4.74788007e+00, -1.56967438e+02],\n", + " [ 2.84637343e+00, 5.03001778e+00, -1.57653005e+02],\n", + " [ 2.17754851e+00, 5.30489060e+00, -1.58361536e+02],\n", + " [ 1.50751252e+00, 5.57108034e+00, -1.59088331e+02],\n", + " [ 8.26227566e-01, 5.82795548e+00, -1.59842662e+02],\n", + " [ 1.33500907e-01, 6.08060882e+00, -1.60627406e+02],\n", + " [-5.73293858e-01, 6.31201230e+00, -1.61440710e+02],\n", + " [-1.29291603e+00, 6.53735053e+00, -1.62284689e+02],\n", + " [-2.02779831e+00, 6.76534614e+00, -1.63163138e+02],\n", + " [-2.79411809e+00, 6.98184660e+00, -1.64093065e+02],\n", + " [-3.58263634e+00, 7.18663397e+00, -1.65063505e+02],\n", + " [-4.39495808e+00, 7.39539747e+00, -1.66078544e+02],\n", + " [-5.24886544e+00, 7.62329017e+00, -1.67020366e+02],\n", + " [-6.13716886e+00, 7.82539630e+00, -1.67888518e+02],\n", + " [-7.05386224e+00, 8.01639815e+00, -1.68709784e+02],\n", + " [-8.00117038e+00, 8.20264197e+00, -1.69493118e+02],\n", + " [-8.98380056e+00, 8.37534791e+00, -1.70242284e+02],\n", + " [-9.89400544e+00, 8.51306393e+00, -1.70988768e+02],\n", + " [-1.07300293e+01, 8.62897325e+00, -1.71732336e+02],\n", + " [-1.15130549e+01, 8.73398993e+00, -1.72478819e+02],\n", + " [-1.22478879e+01, 8.83062352e+00, -1.73230651e+02],\n", + " [-1.29333310e+01, 8.91005409e+00, -1.73982981e+02],\n", + " [-1.35797368e+01, 8.97530128e+00, -1.74747231e+02],\n", + " [-1.41863917e+01, 9.03469007e+00, -1.75525372e+02],\n", + " [-1.47502131e+01, 9.08560994e+00, -1.76312062e+02],\n", + " [-1.52821269e+01, 9.12319554e+00, -1.77119944e+02],\n", + " [-1.57806702e+01, 9.15725504e+00, -1.77951113e+02],\n", + " [-1.62470085e+01, 9.16042941e+00, -1.78798758e+02],\n", + " [-1.66833808e+01, 9.14866268e+00, -1.79672009e+02],\n", + " [-1.70913286e+01, 9.12586015e+00, 1.79425610e+02],\n", + " [-1.74724969e+01, 9.09369141e+00, 1.78489190e+02],\n", + " [-1.78293483e+01, 9.06845636e+00, 1.77514099e+02],\n", + " [-1.81437152e+01, 9.04354354e+00, 1.76539658e+02],\n", + " [-1.83614637e+01, 9.01842649e+00, 1.75611811e+02],\n", + " [-1.85211009e+01, 9.00346411e+00, 1.74704452e+02],\n", + " [-1.86278049e+01, 8.98738570e+00, 1.73814264e+02],\n", + " [-1.86832008e+01, 8.97557867e+00, 1.72940583e+02],\n", + " [-1.86890133e+01, 8.97547122e+00, 1.72074772e+02],\n", + " [-1.86900717e+01, 8.98852591e+00, 1.71277900e+02],\n", + " [-1.86850096e+01, 8.99473095e+00, 1.70542624e+02],\n", + " [-1.86758797e+01, 9.00530743e+00, 1.69859863e+02],\n", + " [-1.86622419e+01, 9.01611032e+00, 1.69221355e+02],\n", + " [-1.86436281e+01, 9.02336573e+00, 1.68625585e+02],\n", + " [-1.86200436e+01, 9.02823149e+00, 1.68070331e+02],\n", + " [-1.85915380e+01, 9.03221173e+00, 1.67553353e+02],\n", + " [-1.85596310e+01, 9.04624462e+00, 1.67076021e+02],\n", + " [-1.85228974e+01, 9.06218198e+00, 1.66632065e+02],\n", + " [-1.84807841e+01, 9.07668242e+00, 1.66220777e+02],\n", + " [-1.84331495e+01, 9.09036343e+00, 1.65840561e+02],\n", + " [-1.83799145e+01, 9.10433202e+00, 1.65489871e+02],\n", + " [-1.83209362e+01, 9.11941485e+00, 1.65167325e+02],\n", + " [-1.82560167e+01, 9.13617199e+00, 1.64871658e+02],\n", + " [-1.81865951e+01, 9.16226297e+00, 1.64602736e+02],\n", + " [-1.81107326e+01, 9.18967948e+00, 1.64358162e+02],\n", + " [-1.80279197e+01, 9.21721961e+00, 1.64137348e+02],\n", + " [-1.79378789e+01, 9.24554493e+00, 1.63939334e+02],\n", + " [-1.78403317e+01, 9.27546011e+00, 1.63763333e+02],\n", + " [-1.77349439e+01, 9.30755953e+00, 1.63608533e+02],\n", + " [-1.76213056e+01, 9.34222198e+00, 1.63474360e+02],\n", + " [-1.74989602e+01, 9.37974657e+00, 1.63360278e+02],\n", + " [-1.73673924e+01, 9.42028419e+00, 1.63265812e+02],\n", + " [-1.72260723e+01, 9.46401781e+00, 1.63190673e+02],\n", + " [-1.70744300e+01, 9.51111917e+00, 1.63134572e+02],\n", + " [-1.69118822e+01, 9.56178242e+00, 1.63097310e+02],\n", + " [-1.67377786e+01, 9.61612037e+00, 1.63078760e+02],\n", + " [-1.65528963e+01, 9.68124518e+00, 1.63077617e+02],\n", + " [-1.63547986e+01, 9.74799240e+00, 1.63095430e+02],\n", + " [-1.61426739e+01, 9.81659257e+00, 1.63132248e+02],\n", + " [-1.59157529e+01, 9.88787517e+00, 1.63188105e+02],\n", + " [-1.56732021e+01, 9.96254035e+00, 1.63263109e+02],\n", + " [-1.54140844e+01, 1.00410406e+01, 1.63357501e+02],\n", + " [-1.51373942e+01, 1.01235801e+01, 1.63471654e+02],\n", + " [-1.48420955e+01, 1.02102808e+01, 1.63605991e+02],\n", + " [-1.45271080e+01, 1.03011647e+01, 1.63761003e+02],\n", + " [-1.41912803e+01, 1.03961581e+01, 1.63937252e+02],\n", + " [-1.38272594e+01, 1.04849412e+01, 1.64140025e+02],\n", + " [-1.34401487e+01, 1.05819399e+01, 1.64365102e+02],\n", + " [-1.30286000e+01, 1.06892847e+01, 1.64613186e+02],\n", + " [-1.25909542e+01, 1.08063335e+01, 1.64885461e+02],\n", + " [-1.21254718e+01, 1.09323537e+01, 1.65183210e+02]])" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "this_obj_gt_rotations = []\n", + "this_obj_gt_rotations_q = []\n", + "for i, rotations in enumerate(rotation_arr):\n", + " this_obj_gt_rotations.append(quaternion_to_euler_angles(rotations[o_id-1]))\n", + " this_obj_gt_rotations_q.append(rotations[o_id-1])\n", + "this_obj_gt_rotations = np.asanyarray(this_obj_gt_rotations)\n", + "this_obj_gt_rotations_q = np.asanyarray(this_obj_gt_rotations_q)\n", + "this_obj_gt_rotations" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0., 0., 0.], dtype=float32)" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "initial_rotations[o_id-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "# rotation_samples = np.asanyarray([list(sample.values()) for sample in tracking_per_frame['rotation'][str(o_id)]])\n", + "# rotation_samples" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.04141465, 1.35375784, -4.5353055 ],\n", + " [ 2.72289375, 9.81747922, -7.50473033],\n", + " [ 7.17786437, 1.85006208, -9.44989727],\n", + " [ 2.27310894, 3.59802159, -16.05390118],\n", + " [ -0.11407269, 5.6046304 , -10.52744698],\n", + " [ -6.48524568, 5.49943849, -13.56912433],\n", + " [ -3.26761188, 5.59650996, -16.03281711],\n", + " [ -6.44874912, 8.39633875, -12.0563522 ],\n", + " [ -1.78879114, 20.38049808, -10.7423032 ],\n", + " [ -4.93926081, 15.21434183, -10.24532995],\n", + " [ -4.00165638, 11.9992175 , -8.67566944],\n", + " [-12.91991485, 10.09195369, -15.14690652],\n", + " [ -4.19948078, 9.20359107, -15.19494882],\n", + " [ -1.02357889, 3.24253324, -20.29646505],\n", + " [ -7.08227822, 8.20040065, -19.29760061]])" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# all frames\n", + "rotation_samples = np.asanyarray([quaternion_to_euler_angles(time_point[str(o_id)][1][1]) for time_point in tracking_per_frame['pose']])\n", + "rotation_samples" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "875fd2b3ee974091ae1bfa9138638cfd", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib widget\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection=\"3d\")\n", + "\n", + "colors = 1.*np.array([i for i in range(len(this_obj_gt_rotations))])/len(this_obj_gt_rotations)\n", + "grayscale_map = plt.get_cmap('gray')\n", + "ax.scatter(this_obj_gt_rotations[:, 0], this_obj_gt_rotations[:, 2], this_obj_gt_rotations[:, 1], s = 3, alpha=1, cmap = grayscale_map, c=colors)\n", + "ax.scatter(this_obj_gt_rotations[STOP_T-1][0], this_obj_gt_rotations[STOP_T-1][2], this_obj_gt_rotations[STOP_T-1][1], s = 30, c='r')\n", + "ax.scatter(rotation_samples[:, 0], rotation_samples[:, 2], rotation_samples[:, 1], s = 10, alpha=1)\n", + "set_axes_equal(ax)\n", + "ax.set_xlabel(\"X\")\n", + "ax.set_ylabel(\"Z\")\n", + "ax.set_zlabel(\"Y\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 5.97737629e-01, 2.80366069e+00, -2.54925538e+01],\n", + " [ 2.25585503e+00, 4.06804712e+00, -2.16745334e+01],\n", + " [-5.36162955e-01, 6.09046654e+00, -1.91999499e+01],\n", + " [-1.64881422e+00, 6.75181214e+00, -2.20344538e+01],\n", + " [ 4.34983632e+00, 2.28001820e+00, -2.26140208e+01],\n", + " [ 2.11465198e-01, -2.32123725e+00, -2.00705237e+01],\n", + " [ 4.71198494e+00, 5.63149654e+00, -2.56834712e+01],\n", + " [-1.29324538e+00, 1.86588512e+00, -2.46655914e+01],\n", + " [ 1.37765341e-01, 2.63453236e+00, -1.42011643e+01],\n", + " [ 8.04905893e-01, -9.03954009e-01, -1.97156683e+01],\n", + " [-8.06330576e+00, 4.14939762e+00, -2.42122768e+01],\n", + " [-1.36075840e+00, 5.68368479e+00, -1.34404065e+01],\n", + " [ 6.34420294e+00, 6.78628468e+00, -1.87860572e+01],\n", + " [ 3.54668692e+00, 4.75267355e+00, -2.11956849e+01],\n", + " [-1.15063243e+00, -3.05064747e+00, -2.09713563e+01],\n", + " [-5.78034118e+00, 3.49916813e+00, -1.78560547e+01],\n", + " [ 6.85010934e+00, 3.01970127e+00, -1.75965390e+01],\n", + " [-3.51923770e-02, 4.33789291e+00, -2.45020907e+01],\n", + " [ 2.38196990e+00, 7.62510453e+00, -1.50619763e+01],\n", + " [-2.92680461e+00, 4.92931359e+00, -2.09044933e+01],\n", + " [-7.81567302e+00, 1.73524826e+00, -1.96004979e+01],\n", + " [-1.00073928e+00, 1.38671036e+00, -2.14273831e+01],\n", + " [ 2.31002638e-01, 8.12791191e+00, -2.21104162e+01],\n", + " [ 1.18786272e+00, 5.38648758e+00, -1.70351726e+01],\n", + " [-6.91356735e+00, 1.02723292e+01, -1.56048270e+01],\n", + " [ 2.77905760e+00, 9.04437432e-01, -2.39266197e+01],\n", + " [-5.91605834e+00, -2.03481694e+00, -1.86090869e+01],\n", + " [-5.36667016e+00, 9.27682769e+00, -2.79156916e+01],\n", + " [-5.32475369e+00, 7.69497566e+00, -1.89040156e+01],\n", + " [-5.22417276e+00, 4.58619072e+00, -2.08557372e+01],\n", + " [ 2.64110001e+00, 4.94914586e+00, -2.11126981e+01],\n", + " [-6.83477653e+00, 2.10219393e-04, -1.97436476e+01],\n", + " [-4.13878528e+00, 5.45123798e+00, -2.09483570e+01],\n", + " [-3.05735966e+00, 3.72395309e+00, -2.46975494e+01],\n", + " [ 5.16020535e-01, 1.58110496e+00, -2.34591764e+01],\n", + " [-5.71259118e+00, 3.06644666e+00, -1.19195988e+01],\n", + " [-3.60517231e+00, 2.80093611e-02, -1.54246236e+01],\n", + " [ 6.67136825e+00, 2.35434469e-02, -2.26383652e+01],\n", + " [ 1.87846006e+00, -6.89839648e-01, -1.96777290e+01],\n", + " [-4.64226801e+00, -2.83005871e+00, -2.54776917e+01],\n", + " [-6.37255068e+00, -3.56444219e+00, -2.04825786e+01],\n", + " [ 1.06732348e+00, -7.86580247e-01, -1.94702289e+01],\n", + " [-3.58696912e+00, -1.49372595e+00, -2.09050682e+01],\n", + " [-4.69297162e+00, 2.29055266e+00, -2.32812300e+01],\n", + " [ 3.42665519e+00, -3.44077114e-01, -2.17099494e+01],\n", + " [ 4.67322984e-01, 1.81674285e+00, -2.10655791e+01],\n", + " [-1.31743832e+00, 2.52312830e+00, -1.40500863e+01],\n", + " [-3.96566294e+00, 3.57003281e+00, -2.00658347e+01],\n", + " [-2.09282837e+00, 9.65370828e+00, -2.15897814e+01],\n", + " [-1.45095682e+00, -1.06017547e+00, -1.44164533e+01]])" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# last frame\n", + "rotation_samples = np.asanyarray([quaternion_to_euler_angles(sample[2]) for sample in tracking_per_frame['pose'][-1][str(o_id)][0]])\n", + "rotation_samples" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Y')" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fd44637abc53451da48013773836b362", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib widget\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection=\"3d\")\n", + "ax.scatter(rotation_samples[:, 0], rotation_samples[:, 2], rotation_samples[:, 1], s = 3, alpha=1)\n", + "ax.scatter(this_obj_gt_rotations[STOP_T-1][0], this_obj_gt_rotations[STOP_T-1][2], this_obj_gt_rotations[STOP_T-1][1], s = 30, c='r')\n", + "set_axes_equal(ax)\n", + "ax.set_xlabel(\"X\")\n", + "ax.set_ylabel(\"Z\")\n", + "ax.set_zlabel(\"Y\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## visualize the velocity" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 4.4973025 , -0.00872831, -0.30156696], dtype=float32)" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "this_obj_gt_velocities = []\n", + "for i, velocities in enumerate(velocity_arr):\n", + " this_obj_gt_velocities.append(velocities[o_id-1])\n", + "this_obj_gt_velocities = np.asanyarray(this_obj_gt_velocities)\n", + "this_obj_gt_velocities[STOP_T+t]" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 4.3815154 , -0.39187421, -0.43550575],\n", + " [ 3.52383335, 0.67433774, -1.16717483],\n", + " [ 4.1851434 , 0.3000386 , -0.35210779],\n", + " [ 4.21267617, 0.29100467, -0.52344061],\n", + " [ 3.97381092, 0.24633827, -0.71417835],\n", + " [ 3.97381092, 0.24633827, -0.71417835],\n", + " [ 3.97381092, 0.24633827, -0.71417835],\n", + " [ 4.43226727, 0.33792425, -0.58991478],\n", + " [ 4.21267617, 0.29100467, -0.52344061],\n", + " [ 3.74730514, 1.01883314, -1.13924411],\n", + " [ 3.97381092, 0.24633827, -0.71417835],\n", + " [ 3.58923476, 0.45429339, -0.5610914 ],\n", + " [ 3.53070564, 0.87648719, -0.82033753],\n", + " [ 3.97381092, 0.24633827, -0.71417835],\n", + " [ 3.97381092, 0.24633827, -0.71417835],\n", + " [ 3.97381092, 0.24633827, -0.71417835],\n", + " [ 4.07033088, -0.17477594, -0.36591799],\n", + " [ 4.32489368, -0.24865135, -0.60496627],\n", + " [ 3.90651459, 0.13433714, -0.61677135],\n", + " [ 4.07033088, -0.17477594, -0.36591799]])" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "velocity_samples = np.asanyarray([list(sample.values()) for sample in tracking_final_frame['velocity'][str(o_id)]])\n", + "velocity_samples" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 4.4978499e-02, -6.6161156e-05, -3.0055456e-03], dtype=float32)" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "this_obj_gt_positions[STOP_T+t]-this_obj_gt_positions[STOP_T-1+t]" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.98711214, 0.18130092, -0.0109818 ],\n", + " [-0.94125572, 0.19499806, -0.0076032 ],\n", + " [-0.884684 , 0.18239244, -0.00623439],\n", + " [-0.82629236, 0.18371284, -0.01486443],\n", + " [-0.78386746, 0.20583828, -0.02750445],\n", + " [-0.72850848, 0.20208624, -0.02693773],\n", + " [-0.67272221, 0.18401008, -0.01598562],\n", + " [-0.63147965, 0.18769365, -0.02806916],\n", + " [-0.57279811, 0.19780307, -0.01256446],\n", + " [-0.53117288, 0.18611859, -0.01460499],\n", + " [-0.49184254, 0.19367175, -0.02992292],\n", + " [-0.42028261, 0.18833436, -0.02722657],\n", + " [-0.38533282, 0.18796999, -0.03873599],\n", + " [-0.34110039, 0.19236534, -0.04441301],\n", + " [-0.29718548, 0.18909981, -0.03234618]])" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "calculated_centers" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 4.39149037, -0.32655341, 1.20668295])" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "100*(calculated_centers[STOP_T+t]-calculated_centers[STOP_T-1+t])" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5d1aed15eaf8428792dd07cdca158796", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib widget\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection=\"3d\")\n", + "\n", + "colors = 1.*np.array([i for i in range(len(this_obj_gt_velocities))])/len(this_obj_gt_velocities)\n", + "grayscale_map = plt.get_cmap('gray')\n", + "ax.scatter(this_obj_gt_velocities[STOP_T-1][0], this_obj_gt_velocities[STOP_T-1][2], this_obj_gt_velocities[STOP_T-1][1], s = 30, c='r')\n", + "ax.scatter(velocity_samples[:, 0], velocity_samples[:, 2], velocity_samples[:, 1], s = 10, alpha=1)\n", + "set_axes_equal(ax)\n", + "ax.set_xlabel(\"X\")\n", + "ax.set_ylabel(\"Z\")\n", + "ax.set_zlabel(\"Y\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f1b8f2b8fdef44c392537287368b327d", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "%matplotlib widget\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection=\"3d\")\n", + "\n", + "colors = 1.*np.array([i for i in range(len(this_obj_gt_positions))])/len(this_obj_gt_positions)\n", + "grayscale_map = plt.get_cmap('gray')\n", + "# ax.scatter(this_obj_gt_positions[:, 0], this_obj_gt_positions[:, 2], this_obj_gt_positions[:, 1], s = 3, alpha=1, cmap = grayscale_map, c=colors)\n", + "ax.scatter(this_obj_gt_positions[STOP_T-1][0], this_obj_gt_positions[STOP_T-1][2], this_obj_gt_positions[STOP_T-1][1], s = 30, c='r')\n", + "ax.scatter(calculated_centers[:, 0], calculated_centers[:, 2], calculated_centers[:, 1], s = 10, alpha=1, c='blue')\n", + "ax.scatter(calculated_centers_last[:, 0], calculated_centers_last[:, 2], calculated_centers_last[:, 1], s = 3, alpha=1, c='blue')\n", + "\n", + "ax.quiver(calculated_centers_last[:, 0][:velocity_samples.shape[0]], calculated_centers_last[:, 2][:velocity_samples.shape[0]], calculated_centers_last[:, 1][:velocity_samples.shape[0]], calculated_centers_last[:, 0][:velocity_samples.shape[0]]+velocity_samples[:, 0], calculated_centers_last[:, 2][:velocity_samples.shape[0]]+velocity_samples[:, 2], calculated_centers_last[:, 1][:velocity_samples.shape[0]]+velocity_samples[:, 1], color='blue', arrow_length_ratio=0.1, length=0.1, alpha=0.2)\n", + "ax.quiver(this_obj_gt_positions[STOP_T-1][0], this_obj_gt_positions[STOP_T-1][2], this_obj_gt_positions[STOP_T-1][1], this_obj_gt_positions[STOP_T-1][0]+this_obj_gt_velocities[STOP_T-1][0], this_obj_gt_positions[STOP_T-1][2]+this_obj_gt_velocities[STOP_T-1][2], this_obj_gt_positions[STOP_T-1][1]+this_obj_gt_velocities[STOP_T-1][1], color='red', arrow_length_ratio=0.2, length=0.1, linewidths=3.0, alpha=1)\n", + "\n", + "set_axes_equal(ax)\n", + "ax.set_xlabel(\"X\")\n", + "ax.set_ylabel(\"Z\")\n", + "ax.set_zlabel(\"Y\")\n", + "\n", + "set_axes_equal(ax)\n", + "ax.set_xlabel(\"X\")\n", + "ax.set_ylabel(\"Z\")\n", + "ax.set_zlabel(\"Y\")\n", + "plt.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# verify if the biased velocity is due to the wrong rotations inferred by b3d" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## verify if the compute_center_of_mass function is correct or not" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "PLOTS_PER_ROW = 3\n", + "window_size = 3\n", + "fps = 100" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'this_obj_gt_rotations_q' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[18], line 4\u001b[0m\n\u001b[1;32m 1\u001b[0m calculated_centers \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(STOP_T):\n\u001b[1;32m 3\u001b[0m calculated_center, q \u001b[38;5;241m=\u001b[39m compute_center_of_mass(object_meshes[o_id\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m.\u001b[39mbounding_box,\n\u001b[0;32m----> 4\u001b[0m this_obj_gt_positions[i], \u001b[43mthis_obj_gt_rotations_q\u001b[49m[i])\n\u001b[1;32m 5\u001b[0m calculated_centers\u001b[38;5;241m.\u001b[39mappend(calculated_center)\n\u001b[1;32m 6\u001b[0m calculated_centers \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39masanyarray(calculated_centers)\n", + "\u001b[0;31mNameError\u001b[0m: name 'this_obj_gt_rotations_q' is not defined" + ] + } + ], + "source": [ + "calculated_centers = []\n", + "for i in range(STOP_T):\n", + " calculated_center, q = compute_center_of_mass(object_meshes[o_id-1].bounding_box,\n", + " this_obj_gt_positions[i], this_obj_gt_rotations_q[i])\n", + " calculated_centers.append(calculated_center)\n", + "calculated_centers = np.asanyarray(calculated_centers)\n", + "calculated_centers" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 4.99999702e-01, 2.50000060e-01, -6.51300525e-09],\n", + " [ 4.99999583e-01, 2.50000030e-01, 2.15007923e-08],\n", + " [ 4.99999523e-01, 2.50000030e-01, 4.60210856e-08],\n", + " [ 4.99999523e-01, 2.50000030e-01, 4.16450341e-08],\n", + " [ 4.99999493e-01, 2.50000030e-01, 2.93769524e-08],\n", + " [ 4.99999523e-01, 2.50000030e-01, 1.76765003e-08],\n", + " [ 4.99999493e-01, 2.50000030e-01, 3.14869801e-08],\n", + " [ 4.99999493e-01, 2.50000030e-01, 1.87425826e-08],\n", + " [ 4.99999493e-01, 2.50000030e-01, 3.68892366e-08],\n", + " [ 4.99999493e-01, 2.50000030e-01, 2.66920424e-08],\n", + " [ 4.99999493e-01, 2.50000030e-01, 1.57204134e-08],\n", + " [ 4.99999523e-01, 2.50000030e-01, 3.19319220e-08],\n", + " [ 4.99999493e-01, 2.50000030e-01, 2.37629436e-08],\n", + " [ 4.99999493e-01, 2.50000030e-01, 1.53472932e-08],\n", + " [ 5.39558232e-01, 2.58830875e-01, 4.78507672e-03],\n", + " [ 5.71949184e-01, 2.73565978e-01, 1.00300116e-02],\n", + " [ 6.06481314e-01, 2.81828940e-01, 1.57364942e-02],\n", + " [ 6.40092611e-01, 2.86917448e-01, 2.12908033e-02],\n", + " [ 6.72494769e-01, 2.88983047e-01, 2.66453251e-02],\n", + " [ 7.03423619e-01, 2.88215697e-01, 3.17563787e-02],\n", + " [ 7.32643306e-01, 2.84840167e-01, 3.65850106e-02],\n", + " [ 7.59951293e-01, 2.79111505e-01, 4.10977229e-02],\n", + " [ 7.85181761e-01, 2.71310151e-01, 4.52671237e-02],\n", + " [ 8.08208525e-01, 2.61736602e-01, 4.90723625e-02],\n", + " [ 8.28947663e-01, 2.50705540e-01, 5.24995588e-02],\n", + " [ 8.47358525e-01, 2.38539845e-01, 5.55419922e-02],\n", + " [ 8.63444567e-01, 2.25564629e-01, 5.82002811e-02],\n", + " [ 8.77253473e-01, 2.12100774e-01, 6.04822263e-02],\n", + " [ 8.88875246e-01, 1.98459297e-01, 6.24027625e-02],\n", + " [ 8.98441434e-01, 1.84935004e-01, 6.39835894e-02],\n", + " [ 9.06121314e-01, 1.71801597e-01, 6.52526915e-02],\n", + " [ 9.19502497e-01, 1.81429327e-01, 6.64882511e-02],\n", + " [ 9.27505195e-01, 1.87557250e-01, 6.78044334e-02],\n", + " [ 9.34966624e-01, 1.94052607e-01, 6.91206604e-02],\n", + " [ 9.42330837e-01, 1.99666291e-01, 7.04269782e-02],\n", + " [ 9.49753046e-01, 2.04669297e-01, 7.17459023e-02],\n", + " [ 9.57279682e-01, 2.09114969e-01, 7.30861127e-02],\n", + " [ 9.64942813e-01, 2.13029057e-01, 7.44539648e-02],\n", + " [ 9.72768486e-01, 2.16430336e-01, 7.58547485e-02],\n", + " [ 9.80779529e-01, 2.19337076e-01, 7.72933513e-02],\n", + " [ 9.88996089e-01, 2.21767396e-01, 7.87742138e-02],\n", + " [ 9.97435212e-01, 2.23739535e-01, 8.03013891e-02],\n", + " [ 1.00611043e+00, 2.25270271e-01, 8.18784088e-02],\n", + " [ 1.01503241e+00, 2.26374418e-01, 8.35083053e-02],\n", + " [ 1.02420807e+00, 2.27063775e-01, 8.51935670e-02],\n", + " [ 1.03364170e+00, 2.27345973e-01, 8.69360194e-02],\n", + " [ 1.04333508e+00, 2.27224976e-01, 8.87371004e-02],\n", + " [ 1.05328703e+00, 2.26699799e-01, 9.05975550e-02],\n", + " [ 1.06349409e+00, 2.25764662e-01, 9.25175399e-02],\n", + " [ 1.07395005e+00, 2.24409848e-01, 9.44963694e-02],\n", + " [ 1.08464527e+00, 2.22622037e-01, 9.65325832e-02],\n", + " [ 1.09556735e+00, 2.20385432e-01, 9.86237451e-02],\n", + " [ 1.10670042e+00, 2.17682660e-01, 1.00766540e-01],\n", + " [ 1.11802542e+00, 2.14495301e-01, 1.02956608e-01],\n", + " [ 1.12952101e+00, 2.10805118e-01, 1.05188876e-01],\n", + " [ 1.14116299e+00, 2.06595153e-01, 1.07457653e-01],\n", + " [ 1.15292561e+00, 2.01849282e-01, 1.09756716e-01],\n", + " [ 1.16478157e+00, 1.96553469e-01, 1.12079494e-01],\n", + " [ 1.17670298e+00, 1.90694720e-01, 1.14419237e-01],\n", + " [ 1.18866110e+00, 1.84262305e-01, 1.16769120e-01],\n", + " [ 1.20062733e+00, 1.77247196e-01, 1.19122326e-01],\n", + " [ 1.21257269e+00, 1.69641316e-01, 1.21472158e-01],\n", + " [ 1.22446907e+00, 1.61438495e-01, 1.23812012e-01],\n", + " [ 1.23628747e+00, 1.52633518e-01, 1.26135424e-01],\n", + " [ 1.24799955e+00, 1.43222213e-01, 1.28436089e-01],\n", + " [ 1.25957680e+00, 1.33201152e-01, 1.30707711e-01],\n", + " [ 1.27099001e+00, 1.22568071e-01, 1.32944137e-01],\n", + " [ 1.28221011e+00, 1.11320838e-01, 1.35139167e-01],\n", + " [ 1.29320633e+00, 9.94585156e-02, 1.37286559e-01],\n", + " [ 1.30394733e+00, 8.69803578e-02, 1.39379904e-01],\n", + " [ 1.31439948e+00, 7.38864243e-02, 1.41412601e-01],\n", + " [ 1.31617796e+00, 7.87930787e-02, 1.41716823e-01],\n", + " [ 1.31760049e+00, 8.41474384e-02, 1.42086267e-01],\n", + " [ 1.31902194e+00, 8.84912014e-02, 1.42392308e-01],\n", + " [ 1.32046819e+00, 9.21532065e-02, 1.42704904e-01],\n", + " [ 1.32196486e+00, 9.52052772e-02, 1.43030152e-01],\n", + " [ 1.32352710e+00, 9.76662487e-02, 1.43371701e-01],\n", + " [ 1.32515967e+00, 9.95159000e-02, 1.43730879e-01],\n", + " [ 1.32687724e+00, 1.00787938e-01, 1.44111454e-01],\n", + " [ 1.32867897e+00, 1.01457536e-01, 1.44513667e-01],\n", + " [ 1.33057117e+00, 1.01541281e-01, 1.44939438e-01],\n", + " [ 1.33255327e+00, 1.01035371e-01, 1.45389155e-01],\n", + " [ 1.33462298e+00, 9.99388546e-02, 1.45862803e-01],\n", + " [ 1.33677578e+00, 9.82509702e-02, 1.46359742e-01],\n", + " [ 1.33900464e+00, 9.59711075e-02, 1.46878809e-01],\n", + " [ 1.34130085e+00, 9.30983424e-02, 1.47418126e-01],\n", + " [ 1.34365296e+00, 8.96312147e-02, 1.47975281e-01],\n", + " [ 1.34604764e+00, 8.55685323e-02, 1.48547113e-01],\n", + " [ 1.34846997e+00, 8.09089541e-02, 1.49129838e-01],\n", + " [ 1.35090292e+00, 7.56509602e-02, 1.49719000e-01],\n", + " [ 1.35175860e+00, 7.17168897e-02, 1.50060892e-01],\n", + " [ 1.35168159e+00, 7.06907809e-02, 1.50350034e-01],\n", + " [ 1.35145843e+00, 7.05372244e-02, 1.50620371e-01],\n", + " [ 1.35139060e+00, 7.04834759e-02, 1.50964066e-01],\n", + " [ 1.35132551e+00, 7.04509318e-02, 1.51334718e-01],\n", + " [ 1.35125351e+00, 7.04181343e-02, 1.51744574e-01],\n", + " [ 1.35117567e+00, 7.03801215e-02, 1.52188778e-01],\n", + " [ 1.35109127e+00, 7.03360885e-02, 1.52669564e-01],\n", + " [ 1.35099924e+00, 7.02852905e-02, 1.53189898e-01],\n", + " [ 1.35090113e+00, 7.02271312e-02, 1.53742731e-01],\n", + " [ 1.35079956e+00, 7.01330453e-02, 1.54347971e-01],\n", + " [ 1.35070145e+00, 7.00731128e-02, 1.54917151e-01],\n", + " [ 1.35064459e+00, 7.01194704e-02, 1.55407727e-01],\n", + " [ 1.35060012e+00, 7.01752752e-02, 1.55840531e-01],\n", + " [ 1.35055971e+00, 7.02226311e-02, 1.56226009e-01],\n", + " [ 1.35052240e+00, 7.02624023e-02, 1.56574190e-01],\n", + " [ 1.35049105e+00, 7.02963322e-02, 1.56869784e-01],\n", + " [ 1.35046387e+00, 7.03257769e-02, 1.57122076e-01],\n", + " [ 1.35043991e+00, 7.03545213e-02, 1.57333091e-01],\n", + " [ 1.35042441e+00, 7.03600049e-02, 1.57505065e-01],\n", + " [ 1.35041046e+00, 7.03744888e-02, 1.57638133e-01],\n", + " [ 1.35040104e+00, 7.03791827e-02, 1.57733634e-01],\n", + " [ 1.35039544e+00, 7.03834593e-02, 1.57792047e-01],\n", + " [ 1.35039377e+00, 7.03851432e-02, 1.57812789e-01],\n", + " [ 1.35039544e+00, 7.03834891e-02, 1.57798007e-01],\n", + " [ 1.35040081e+00, 7.03786314e-02, 1.57746628e-01],\n", + " [ 1.35041022e+00, 7.03703612e-02, 1.57658309e-01],\n", + " [ 1.35042262e+00, 7.03587383e-02, 1.57533407e-01],\n", + " [ 1.35043991e+00, 7.03426152e-02, 1.57369301e-01],\n", + " [ 1.35046124e+00, 7.03224093e-02, 1.57165796e-01],\n", + " [ 1.35048676e+00, 7.02970624e-02, 1.56921491e-01],\n", + " [ 1.35051656e+00, 7.02662766e-02, 1.56634897e-01],\n", + " [ 1.35055113e+00, 7.02292621e-02, 1.56304151e-01],\n", + " [ 1.35059035e+00, 7.01851100e-02, 1.55927107e-01],\n", + " [ 1.35063434e+00, 7.01328069e-02, 1.55501291e-01],\n", + " [ 1.35067999e+00, 7.00800121e-02, 1.55064404e-01],\n", + " [ 1.35073948e+00, 7.00944215e-02, 1.54681206e-01],\n", + " [ 1.35079944e+00, 7.01159537e-02, 1.54368222e-01],\n", + " [ 1.35084236e+00, 7.01567829e-02, 1.54104680e-01],\n", + " [ 1.35087776e+00, 7.01859891e-02, 1.53891534e-01],\n", + " [ 1.35090649e+00, 7.02065676e-02, 1.53726056e-01],\n", + " [ 1.35092723e+00, 7.02208579e-02, 1.53607368e-01],\n", + " [ 1.35093987e+00, 7.02292323e-02, 1.53534681e-01],\n", + " [ 1.35094619e+00, 7.02321529e-02, 1.53499454e-01],\n", + " [ 1.35094190e+00, 7.02308118e-02, 1.53518707e-01],\n", + " [ 1.35093045e+00, 7.02236444e-02, 1.53582618e-01],\n", + " [ 1.35091114e+00, 7.02106059e-02, 1.53692544e-01],\n", + " [ 1.35088491e+00, 7.01907873e-02, 1.53848112e-01],\n", + " [ 1.35084939e+00, 7.01651573e-02, 1.54052228e-01],\n", + " [ 1.35080504e+00, 7.01330453e-02, 1.54305249e-01],\n", + " [ 1.35075164e+00, 7.00933933e-02, 1.54608727e-01],\n", + " [ 1.35069239e+00, 7.00774789e-02, 1.54919773e-01],\n", + " [ 1.35066724e+00, 7.00851232e-02, 1.55177087e-01],\n", + " [ 1.35064888e+00, 7.01135993e-02, 1.55361071e-01],\n", + " [ 1.35063553e+00, 7.01289773e-02, 1.55496284e-01],\n", + " [ 1.35062599e+00, 7.01424628e-02, 1.55579939e-01],\n", + " [ 1.35062325e+00, 7.01440126e-02, 1.55612797e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01],\n", + " [ 1.35062647e+00, 7.01405853e-02, 1.55593678e-01]], dtype=float32)" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "this_obj_gt_centers = []\n", + "for i, centers in enumerate(center_arr):\n", + " # if i >= STOP_T:\n", + " # continue\n", + " this_obj_gt_centers.append(centers[o_id-1])\n", + "this_obj_gt_centers = np.asanyarray(this_obj_gt_centers)\n", + "this_obj_gt_centers" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "254b0015fc414095990b4b0a9216bb30", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(PLOTS_PER_ROW)\n", + "for dim in range(PLOTS_PER_ROW):\n", + " axs[dim].plot(this_obj_gt_centers[:,dim], 'blue', label='gt')\n", + " axs[dim].plot(calculated_centers[:,dim], 'red', label='calclated')\n", + " axs[dim].legend()\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## test the influence of inferred positions by b3d on calculated center of mass" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.49610541, 0.23777992, 0.01076794],\n", + " [0.49610531, 0.23777993, 0.010768 ],\n", + " [0.49610524, 0.23777993, 0.01076804],\n", + " [0.49610523, 0.23777994, 0.01076804],\n", + " [0.49610523, 0.23777994, 0.01076804],\n", + " [0.49610523, 0.23777994, 0.01076803],\n", + " [0.49610523, 0.23777995, 0.01076805],\n", + " [0.49610523, 0.23777995, 0.01076804],\n", + " [0.49610523, 0.23777995, 0.01076806],\n", + " [0.49610523, 0.23777996, 0.01076806],\n", + " [0.49610523, 0.23777996, 0.01076805],\n", + " [0.49610523, 0.23777997, 0.01076808],\n", + " [0.49610523, 0.23777997, 0.01076808],\n", + " [0.49610523, 0.23777997, 0.01076807],\n", + " [0.54575337, 0.26702893, 0.00787629]])" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "calculated_centers = []\n", + "for i in range(STOP_T):\n", + " calculated_center, q = compute_center_of_mass(object_meshes[o_id-1].bounding_box,\n", + " tracking_per_frame['pose'][i][str(o_id)][1][0], this_obj_gt_rotations_q[i])\n", + " calculated_centers.append(calculated_center)\n", + "calculated_centers = np.asanyarray(calculated_centers)\n", + "calculated_centers" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "db34f5c9eb9c4793bc752ef75fb7e4ac", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(PLOTS_PER_ROW)\n", + "for dim in range(PLOTS_PER_ROW):\n", + " axs[dim].plot(this_obj_gt_centers[:,dim], 'blue', label='gt')\n", + " axs[dim].plot(calculated_centers[:,dim], 'red', label='calculated')\n", + " axs[dim].legend()\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## test the influence of inferred rotations by b3d on calculated center of mass" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.4944103 , 0.24989132, -0.00480797],\n", + " [ 0.49441027, 0.24989129, -0.004808 ],\n", + " [ 0.49441027, 0.24989129, -0.00480801],\n", + " [ 0.4944103 , 0.24989129, -0.00480801],\n", + " [ 0.49441027, 0.24989129, -0.00480801],\n", + " [ 0.4944103 , 0.24989129, -0.00480801],\n", + " [ 0.49441027, 0.24989129, -0.00480801],\n", + " [ 0.49441027, 0.24989129, -0.00480801],\n", + " [ 0.49441027, 0.24989129, -0.00480801],\n", + " [ 0.49441027, 0.24989129, -0.00480801],\n", + " [ 0.49441027, 0.24989129, -0.00480801],\n", + " [ 0.4944103 , 0.24989129, -0.00480801],\n", + " [ 0.49441027, 0.24989129, -0.00480801],\n", + " [ 0.49441027, 0.24989129, -0.00480801],\n", + " [ 0.50252478, 0.26044319, 0.01833472]])" + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "calculated_centers = []\n", + "for i in range(STOP_T):\n", + " calculated_center, q = compute_center_of_mass(object_meshes[o_id-1].bounding_box,\n", + " this_obj_gt_positions[i], tracking_per_frame['pose'][i][str(o_id)][1][1])\n", + " calculated_centers.append(calculated_center)\n", + "calculated_centers = np.asanyarray(calculated_centers)\n", + "calculated_centers" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "95588a5dfd4345eda3f0b0a892b1a10f", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(PLOTS_PER_ROW)\n", + "for dim in range(PLOTS_PER_ROW):\n", + " axs[dim].plot(this_obj_gt_centers[:,dim], 'blue', label='gt')\n", + " axs[dim].plot(calculated_centers[:,dim], 'red', label='calculated')\n", + " axs[dim].legend()\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## test the influence of both inferred positions and rotations by b3d on calculated center of mass" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.490516 , 0.23767119, 0.00595997],\n", + " [0.490516 , 0.23767119, 0.00595998],\n", + " [0.490516 , 0.2376712 , 0.00595998],\n", + " [0.490516 , 0.2376712 , 0.00595999],\n", + " [0.490516 , 0.2376712 , 0.00596 ],\n", + " [0.490516 , 0.23767121, 0.00596 ],\n", + " [0.490516 , 0.23767121, 0.00596001],\n", + " [0.490516 , 0.23767121, 0.00596001],\n", + " [0.490516 , 0.23767122, 0.00596002],\n", + " [0.490516 , 0.23767122, 0.00596002],\n", + " [0.490516 , 0.23767123, 0.00596003],\n", + " [0.490516 , 0.23767123, 0.00596003],\n", + " [0.490516 , 0.23767123, 0.00596004],\n", + " [0.490516 , 0.23767124, 0.00596005],\n", + " [0.5087199 , 0.26864123, 0.02142594]])" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "calculated_centers = []\n", + "for i in range(STOP_T):\n", + " calculated_center, q = compute_center_of_mass(object_meshes[o_id-1].bounding_box,\n", + " tracking_per_frame['pose'][i][str(o_id)][1][0], tracking_per_frame['pose'][i][str(o_id)][1][1])\n", + " calculated_centers.append(calculated_center)\n", + "calculated_centers = np.asanyarray(calculated_centers)\n", + "calculated_centers" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_2989465/843135896.py:1: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`). Consider using `matplotlib.pyplot.close()`.\n", + " fig, axs = plt.subplots(PLOTS_PER_ROW)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0462a2a8f4434566a72a6b9c0aa9a119", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(PLOTS_PER_ROW)\n", + "for dim in range(PLOTS_PER_ROW):\n", + " axs[dim].plot(this_obj_gt_centers[:,dim], 'blue', label='gt')\n", + " axs[dim].plot(calculated_centers[:,dim], 'red', label='calculated')\n", + " axs[dim].legend()\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## verify if the center of mass is used to calculate velocity by using gt positions and rotations" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-3.11354590e-06, -9.93409468e-07, 1.73199234e-07],\n", + " [-1.32543037e-06, 2.33146835e-13, -1.24201041e-07],\n", + " [ 7.60914422e-07, 4.71844785e-14, -5.63446836e-07],\n", + " [-9.00080271e-07, 2.31296463e-14, -1.17183148e-07],\n", + " [ 1.87981297e-08, 1.38777878e-14, -1.96456766e-07],\n", + " [-8.86694364e-07, -2.77555756e-14, 3.70707940e-07],\n", + " [-6.43011755e-08, 8.32667268e-15, -1.12041073e-07],\n", + " [ 1.59113870e-08, 5.55111512e-15, 2.13204800e-08],\n", + " [ 8.98679858e-07, 7.40148683e-15, -1.45817466e-07],\n", + " [-2.48557841e-09, 1.85037171e-15, -7.30326699e-08],\n", + " [-2.38268016e-08, 3.70074342e-15, 4.91138645e-08],\n", + " [ 7.66702689e-01, 3.31500712e-01, 1.00392003e-01]])" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "linear_vels = []\n", + "for i in range(STOP_T):\n", + " if i\n", + "
\n", + " Figure\n", + "
\n", + " \n", + " \n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(PLOTS_PER_ROW)\n", + "for dim in range(PLOTS_PER_ROW):\n", + " axs[dim].plot(this_obj_gt_velocities[:,dim][window_size:], 'blue', label='gt')\n", + " axs[dim].plot(linear_vels[:,dim], 'red', label='center of mass velocity')\n", + " axs[dim].legend()\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## check velocities computed using gt positions and rotations against positions and rotations inferred from b3d" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.00000000e+00, 3.72529030e-07, 5.58793545e-07],\n", + " [0.00000000e+00, 3.72529029e-07, 5.58793545e-07],\n", + " [0.00000000e+00, 3.72529029e-07, 5.58793545e-07],\n", + " [0.00000000e+00, 3.72529030e-07, 5.58793545e-07],\n", + " [0.00000000e+00, 3.72529030e-07, 5.58793545e-07],\n", + " [0.00000000e+00, 3.72529031e-07, 5.58793545e-07],\n", + " [0.00000000e+00, 3.72529030e-07, 5.58793545e-07],\n", + " [0.00000000e+00, 3.72529029e-07, 5.58793545e-07],\n", + " [0.00000000e+00, 3.72529029e-07, 5.58793545e-07],\n", + " [0.00000000e+00, 3.72529029e-07, 5.58793545e-07],\n", + " [0.00000000e+00, 3.72529030e-07, 5.58793545e-07],\n", + " [5.78946207e-01, 1.04078826e+00, 1.50459103e-01]])" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "linear_vels_inferred = []\n", + "for i in range(STOP_T):\n", + " if i\n", + "
\n", + " Figure\n", + "
\n", + " \n", + " \n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(PLOTS_PER_ROW)\n", + "for dim in range(PLOTS_PER_ROW):\n", + " axs[dim].plot(linear_vels_inferred[:,dim], 'blue', label='b3d')\n", + " axs[dim].plot(linear_vels[:,dim], 'red', label='gt')\n", + " axs[dim].legend()\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# visualize 20 room simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from tdw.controller import Controller\n", + "from tdw.librarian import SceneLibrarian\n", + "from tdw_physics.noisy_utils import combine_dicts\n", + "import operator\n", + "from matplotlib import cm\n", + "from matplotlib.animation import FuncAnimation" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "if \"scenes.json\" not in Controller.SCENE_LIBRARIANS:\n", + " Controller.SCENE_LIBRARIANS[\"scenes.json\"] = SceneLibrarian()\n", + "scene = \"mm_kitchen_1b_4x5\"\n", + "scene_record = Controller.SCENE_LIBRARIANS[\"scenes.json\"].get_record(scene)\n", + "\n", + "if scene == 'mm_kitchen_1b_4x5':\n", + " base_scene_record = Controller.SCENE_LIBRARIANS[\"scenes.json\"].get_record('mm_kitchen_1b')\n", + "elif scene == 'box_room_4x5':\n", + " base_scene_record = Controller.SCENE_LIBRARIANS[\"scenes.json\"].get_record('box_room_2018')\n", + "elif scene == 'tdw_room_4x5':\n", + " base_scene_record = Controller.SCENE_LIBRARIANS[\"scenes.json\"].get_record('tdw_room')\n", + "base_room_center = {'x':base_scene_record.rooms[0].main_region.center[0], 'y':base_scene_record.rooms[0].main_region.center[1], 'z':base_scene_record.rooms[0].main_region.center[2]}\n", + "\n", + "num_sim = 20" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b6ac5b19eb2042959e96fe580710391f", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib widget\n", + "\n", + "fig = plt.figure(figsize=[10, 10])\n", + "ax = fig.add_subplot(111, projection=\"3d\")\n", + "\n", + "ax.scatter(this_obj_gt_positions[:, 0], this_obj_gt_positions[:, 2], this_obj_gt_positions[:, 1], s = 3, alpha=1, c='black')\n", + "ax.scatter(this_obj_gt_positions[STOP_T-1][0], this_obj_gt_positions[STOP_T-1][2], this_obj_gt_positions[STOP_T-1][1], s = 30, c='r')\n", + "# ax.scatter(position_samples[:, 0], position_samples[:, 2], position_samples[:, 1], s = 10, alpha=1)\n", + "\n", + "trj_all = {x: [] for x in range(num_sim)}\n", + "h5_file = h5py.File(file_4x5, 'r') \n", + "with h5_file as f:\n", + " object_of_interest = o_id-1\n", + " object_of_interest *= num_sim\n", + " frames = list(f['frames'])\n", + " for frame in frames:\n", + " for i, room in enumerate(scene_record.rooms):\n", + " id = object_of_interest+i\n", + " pos = f[f'frames/{frame}/objects/positions'][:][id, :]\n", + " pos = {'x':pos[0], 'y':pos[1], 'z':pos[2]}\n", + " this_room_center = {'x':room.main_region.center[0], 'y':0, 'z':room.main_region.center[2]}\n", + " center = combine_dicts(this_room_center, base_room_center, operator.sub)\n", + " pos = combine_dicts(pos, center, operator.sub)\n", + " trj_all[i].append(list(pos.values()))\n", + "trj_all = {key: np.array(value) for key, value in trj_all.items()}\n", + "for key, trj in trj_all.items():\n", + " ax.scatter(trj[:, 0], trj[:, 2], trj[:, 1], label=str(key), s = 1, alpha=0.5)\n", + " \n", + "set_axes_equal(ax)\n", + "ax.set_xlabel(\"X\")\n", + "ax.set_ylabel(\"Z\")\n", + "ax.set_zlabel(\"Y\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Video\n", + "Video(f'/ccn2/u/rmvenkat/data/testing_physion/regenerate_from_old_commit/test_humans_consolidated/lf_0/collide_all_movies/{config}_{trial_index.zfill(4)}_img.mp4', width=512, height=512, embed=True) " + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "85fc0e1da9c748c2b982331c1b98c6b8", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib widget\n", + "file_4x5_old = f'/home/haw027/code/private-physics-bench/stimuli/stimuli/generation/placement/collide/{config}/{trial_index.zfill(4)}.hdf5'\n", + "\n", + "\n", + "fig = plt.figure(figsize=[10, 10])\n", + "ax = fig.add_subplot(111, projection=\"3d\")\n", + "ax.scatter(this_obj_gt_positions[:, 0], this_obj_gt_positions[:, 2], this_obj_gt_positions[:, 1], s = 3, alpha=1, c='black')\n", + "ax.scatter(this_obj_gt_positions[STOP_T-1][0], this_obj_gt_positions[STOP_T-1][2], this_obj_gt_positions[STOP_T-1][1], s = 100, c='blue')\n", + "\n", + "trj_all = {x: [] for x in range(num_sim)}\n", + "h5_file = h5py.File(file_4x5_old, 'r') \n", + "with h5_file as f:\n", + " object_of_interest = o_id-1\n", + " object_of_interest *= num_sim\n", + " frames = list(f['frames'])\n", + " for frame in frames:\n", + " for i, room in enumerate(scene_record.rooms):\n", + " id = object_of_interest+i\n", + " pos = f[f'frames/{frame}/objects/positions'][:][id, :]\n", + " pos = {'x':pos[0], 'y':pos[1], 'z':pos[2]}\n", + " this_room_center = {'x':room.main_region.center[0], 'y':0, 'z':room.main_region.center[2]}\n", + " # print(this_room_center)\n", + " center = combine_dicts(this_room_center, base_room_center, operator.sub)\n", + " pos = combine_dicts(pos, center, operator.sub)\n", + " trj_all[i].append(list(pos.values()))\n", + "trj_all = {key: np.array(value) for key, value in trj_all.items()}\n", + "for key, trj in trj_all.items():\n", + " ax.scatter(trj[:, 0], trj[:, 2], trj[:, 1], label=str(key), s = 1, alpha=0.5)\n", + " ax.scatter(trj[STOP_T-1][0], trj[STOP_T-1][2], trj[STOP_T-1][1], s = 30, c='r')\n", + "\n", + "set_axes_equal(ax)\n", + "ax.set_xlabel(\"X\")\n", + "ax.set_ylabel(\"Z\")\n", + "ax.set_zlabel(\"Y\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([2., 0., 1., 1., 2., 0., 1., 3., 1., 1., 0., 0., 3., 2., 1., 0., 0.,\n", + " 0., 1., 1.]),\n", + " array([0.4503665 , 0.45672898, 0.46309147, 0.46945395, 0.47581644,\n", + " 0.48217893, 0.48854141, 0.4949039 , 0.50126638, 0.50762887,\n", + " 0.51399136, 0.52035384, 0.52671633, 0.53307881, 0.5394413 ,\n", + " 0.54580379, 0.55216627, 0.55852876, 0.56489124, 0.57125373,\n", + " 0.57761621]),\n", + " )" + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "44cebcebbb4b48c4b9ce864b4b8f2b39", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "xs = []\n", + "zs = []\n", + "for key, trj in trj_all.items():\n", + " xs.append(trj[STOP_T-1][0])\n", + " zs.append(trj[STOP_T-1][2])\n", + "fig = plt.figure(figsize=[10, 10])\n", + "plt.hist(xs, bins=20)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## animation" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_2989465/3746523051.py:30: UserWarning: *c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n", + " scatters.append(ax.scatter([], [], s=small_size, c=value))\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7776eec71ea94ab98d75b90ba7f751d6", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib widget\n", + "\n", + "trj_all = {x: [] for x in range(num_sim)}\n", + "h5_file = h5py.File(file_4x5, 'r') \n", + "with h5_file as f:\n", + " object_of_interest = o_id-1\n", + " object_of_interest *= num_sim\n", + " frames = list(f['frames'])\n", + " for frame in frames:\n", + " for i, room in enumerate(scene_record.rooms):\n", + " id = object_of_interest+i\n", + " pos = f[f'frames/{frame}/objects/positions'][:][id, :]\n", + " pos = {'x':pos[0], 'y':pos[1], 'z':pos[2]}\n", + " this_room_center = {'x':room.main_region.center[0], 'y':0, 'z':room.main_region.center[2]}\n", + " # print(this_room_center)\n", + " center = combine_dicts(this_room_center, base_room_center, operator.sub)\n", + " pos = combine_dicts(pos, center, operator.sub)\n", + " trj_all[i].append(list(pos.values()))\n", + "trj_all = {key: np.array(value) for key, value in trj_all.items()}\n", + "\n", + "fig = plt.figure(figsize=(15,15))\n", + "ax = fig.add_subplot(111, projection=\"3d\")\n", + "colors = cm.rainbow(np.linspace(0, 1, len(trj_all)))\n", + "colors = dict([[k, colors[i]] for i, k in enumerate(trj_all.keys())])\n", + "large_size = 20\n", + "small_size = 3\n", + "\n", + "scatters = [ax.scatter([], [], s=large_size, c='black'), ax.scatter([], [], s=large_size, c='blue')]\n", + "for key, value in colors.items():\n", + " scatters.append(ax.scatter([], [], s=small_size, c=value))\n", + "\n", + "def animate(i):\n", + " scatter_gt = scatters[0]\n", + " accu_trj = (this_obj_gt_positions[:i][:,0], this_obj_gt_positions[:i][:,2], this_obj_gt_positions[:i][:,1])\n", + " scatter_gt._offsets3d = (accu_trj)\n", + " if i < STOP_T:\n", + " scatter_track = scatters[1]\n", + " accu_trj = (position_samples[:i][:,0], position_samples[:i][:,2], position_samples[:i][:,1])\n", + " scatter_track._offsets3d = (accu_trj)\n", + " else:\n", + " for j, trj in trj_all.items():\n", + " scatter = scatters[j+2]\n", + " accu_trj = (trj[:i-STOP_T+1][:,0], trj[:i-STOP_T+1][:,2], trj[:i-STOP_T+1][:,1])\n", + " scatter._offsets3d = (accu_trj)\n", + "\n", + "ax.set_xlabel(\"X\")\n", + "ax.set_ylabel(\"Z\")\n", + "ax.set_zlabel(\"Y\")\n", + "xyz = np.vstack(list(trj_all.values())+[this_obj_gt_positions, position_samples])\n", + "xs = xyz[:,0]\n", + "ys = xyz[:,1]\n", + "zs = xyz[:,2]\n", + "xmax = np.max(xs)\n", + "xmin = np.min(xs)\n", + "ymax = np.max(ys)\n", + "ymin = np.min(ys)\n", + "zmax = np.max(zs)\n", + "zmin = np.min(zs)\n", + "ax.set_xlim(xmin-0.1,xmax+0.1)\n", + "ax.set_ylim(zmin-0.1,zmax+0.1)\n", + "ax.set_zlim(ymin-0.1,ymax+0.1)\n", + "# ax.set_title(title)\n", + "\n", + "# First remove fill\n", + "ax.xaxis.pane.fill = False\n", + "ax.yaxis.pane.fill = False\n", + "ax.zaxis.pane.fill = False\n", + "\n", + "# Now set color to white (or whatever is \"invisible\")\n", + "ax.xaxis.pane.set_edgecolor('w')\n", + "ax.yaxis.pane.set_edgecolor('w')\n", + "ax.zaxis.pane.set_edgecolor('w')\n", + "\n", + "anim = FuncAnimation(fig, animate, frames=len(trj_all[0]), interval=100, repeat=False)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "# anim.save(\"/home/haw027/code/private-physics-bench/stimuli/stimuli/generation/test_20rooms/test.gif\", writer=\"pillow\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## visualize the angular velocity" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1.8530127 , 1.4549693 , 0.31354338], dtype=float32)" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "this_obj_gt_angular_velocities = []\n", + "for i, angular_velocities in enumerate(angular_velocity_arr):\n", + " this_obj_gt_angular_velocities.append(angular_velocities[o_id-1])\n", + "this_obj_gt_angular_velocities = np.asanyarray(this_obj_gt_angular_velocities)\n", + "this_obj_gt_angular_velocities[STOP_T-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0. , 0. , 0. ],\n", + " [ 0.76591574, 2.41785242, 2.95367732],\n", + " [ -2.10243122, 31.61021493, 1.61063349],\n", + " [ 0.49346817, 2.06764263, -2.06071173],\n", + " [ 1.91822905, -10.97790929, -0.40058042],\n", + " [ 1.91822905, -10.97790929, -0.40058042],\n", + " [ 1.91822905, -10.97790929, -0.40058042],\n", + " [ -3.23789188, 8.63060153, 0.29012477],\n", + " [ 0.49346817, 2.06764263, -2.06071173],\n", + " [ -0.14967201, 15.77576553, 1.7693866 ],\n", + " [ 1.91822905, -10.97790929, -0.40058042],\n", + " [ 0.44233427, -0.65833162, -2.40091632],\n", + " [ -1.0505197 , 1.69127911, -5.30798868],\n", + " [ 1.91822905, -10.97790929, -0.40058042],\n", + " [ 1.91822905, -10.97790929, -0.40058042],\n", + " [ 1.91822905, -10.97790929, -0.40058042],\n", + " [ -0.61456601, 17.62507626, -2.17361473],\n", + " [ 0.15070757, 8.13798817, 0.27803488],\n", + " [ 2.57414277, -8.12980363, 0.21739676],\n", + " [ -0.61456601, 17.62507626, -2.17361473]])" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "angular_velocity_samples = np.asanyarray([list(sample.values()) for sample in tracking_final_frame['angular_velocity'][str(o_id)]])\n", + "angular_velocity_samples" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "01b6a492694047e29a40851f3d219d4b", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib widget\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection=\"3d\")\n", + "\n", + "colors = 1.*np.array([i for i in range(len(this_obj_gt_angular_velocities))])/len(this_obj_gt_angular_velocities)\n", + "grayscale_map = plt.get_cmap('gray')\n", + "ax.scatter(this_obj_gt_angular_velocities[STOP_T-1][0], this_obj_gt_angular_velocities[STOP_T-1][2], this_obj_gt_angular_velocities[STOP_T-1][1], s = 30, c='r')\n", + "ax.scatter(angular_velocity_samples[:, 0], angular_velocity_samples[:, 2], angular_velocity_samples[:, 1], s = 10, alpha=1)\n", + "set_axes_equal(ax)\n", + "ax.set_xlabel(\"X\")\n", + "ax.set_ylabel(\"Z\")\n", + "ax.set_zlabel(\"Y\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ground truth debugging" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## making all information ground truth and with no collision noise" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['pilot_it2_collision_non-sphere_tdw_1_dis_1_occ.json',\n", + " 'pilot_it2_collision_simple_box.json',\n", + " 'pilot_it2_collision_assorted_targets_tdw_1_dis_1_occ.json',\n", + " 'pilot_it2_collision_tiny_ball_tdw_1_dis_1_occ.json',\n", + " 'pilot_it2_collision_non-sphere_box.json',\n", + " 'pilot_it2_collision_simple_box_1_dis_1_occ.json',\n", + " 'pilot_it2_collision_tiny_ball_box.json',\n", + " 'pilot_it2_collision_yeet_tdw_1_dis_1_occ.json',\n", + " 'pilot_it2_collision_assorted_targets_box.json',\n", + " 'pilot_it2_collision_yeet_box.json']" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "num_sim = 20\n", + "XYZ = ['x', 'y', 'z']\n", + "XYZW = ['x', 'y', 'z', 'w']\n", + "STOP_T = 15\n", + "\n", + "path = '/ccn2/u/haw027/b3d_ipe/b3d_tdw_joint/b3d_tracking_results/first_scale/gt_all_info_0.01_std/'\n", + "onlyjson = [\n", + " f\n", + " for f in listdir(path)\n", + " if isfile(join(path, f)) and join(path, f).endswith(\".json\")\n", + "]\n", + "onlyjson" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ.json\n", + "pilot_it2_collision_simple_box.json\n", + "pilot_it2_collision_assorted_targets_tdw_1_dis_1_occ.json\n", + "pilot_it2_collision_tiny_ball_tdw_1_dis_1_occ.json\n", + "pilot_it2_collision_non-sphere_box.json\n", + "pilot_it2_collision_simple_box_1_dis_1_occ.json\n", + "pilot_it2_collision_tiny_ball_box.json\n", + "pilot_it2_collision_yeet_tdw_1_dis_1_occ.json\n", + "pilot_it2_collision_assorted_targets_box.json\n", + "pilot_it2_collision_yeet_box.json\n" + ] + } + ], + "source": [ + "for config in onlyjson:\n", + " print(config)\n", + " with open(join(path, config)) as f:\n", + " config_json = json.load(f)\n", + " config_json_new = {}\n", + " for trial_index in config_json.keys():\n", + " trial_name = f'{config[:-5]}_{trial_index.zfill(4)}'\n", + " # print(trial_name)\n", + "\n", + " try:\n", + " config_json_new[trial_index] = {}\n", + " position_arr = []\n", + " rotation_arr = []\n", + " velocity_arr = []\n", + " angular_velocity_arr = []\n", + " with h5py.File(f'/ccn2/u/rmvenkat/data/testing_physion/regenerate_from_old_commit/test_humans_consolidated/lf_0/collide_all_movies/{trial_name}.hdf5', \"r\") as f:\n", + " distractors = (\n", + " np.array(f[\"static\"][\"distractors\"])\n", + " if np.array(f[\"static\"][\"distractors\"]).size != 0\n", + " else []\n", + " )\n", + " occluders = (\n", + " np.array(f[\"static\"][\"occluders\"])\n", + " if np.array(f[\"static\"][\"occluders\"]).size != 0\n", + " else []\n", + " )\n", + " distractors_occluders = np.concatenate([distractors, occluders])\n", + " scales = np.array(\n", + " f[\"static\"][\"scale\"]\n", + " )\n", + " if len(distractors_occluders):\n", + " scales = scales[\n", + " : -len(distractors_occluders)\n", + " ]\n", + " for frame in f[\"frames\"].keys():\n", + " positions = np.array(f[\"frames\"][frame][\"objects\"][\"positions_cam0\"])\n", + " rotations = np.array(f[\"frames\"][frame][\"objects\"][\"rotations_cam0\"][:])\n", + " velocities = np.array(f[\"frames\"][frame][\"objects\"][\"velocities\"][:])\n", + " angular_velocities = np.array(f[\"frames\"][frame][\"objects\"][\"angular_velocities\"][:])\n", + " if len(distractors_occluders):\n", + " positions = positions[\n", + " : -len(distractors_occluders)\n", + " ]\n", + " rotations = rotations[\n", + " : -len(distractors_occluders)\n", + " ]\n", + " velocities = velocities[\n", + " : -len(distractors_occluders)\n", + " ]\n", + " angular_velocities = angular_velocities[\n", + " : -len(distractors_occluders)\n", + " ]\n", + "\n", + " position_arr.append(positions)\n", + " rotation_arr.append(rotations)\n", + " velocity_arr.append(velocities)\n", + " angular_velocity_arr.append(angular_velocities)\n", + " \n", + " for key, value in config_json[trial_index].items():\n", + " if key == 'model':\n", + " config_json_new[trial_index][key] = value\n", + " elif key == 'scale':\n", + " config_json_new[trial_index][key] = {}\n", + " for obj_id in config_json[trial_index][key].keys():\n", + " config_json_new[trial_index][key][obj_id] = [dict([(k, v.astype(float)) for k, v in zip(XYZ, scales[int(obj_id)-1])]) for _ in range(num_sim)]\n", + " elif key == 'position':\n", + " config_json_new[trial_index][key] = {}\n", + " for obj_id in config_json[trial_index][key].keys():\n", + " config_json_new[trial_index][key][obj_id] = [dict([(k, v.astype(float)) for k, v in zip(XYZ, position_arr[STOP_T-1][int(obj_id)-1])]) for _ in range(num_sim)]\n", + " elif key == 'rotation':\n", + " config_json_new[trial_index][key] = {}\n", + " for obj_id in config_json[trial_index][key].keys():\n", + " config_json_new[trial_index][key][obj_id] = [dict([(k, v.astype(float)) for k, v in zip(XYZW, rotation_arr[STOP_T-1][int(obj_id)-1])]) for _ in range(num_sim)]\n", + " elif key == 'velocity':\n", + " config_json_new[trial_index][key] = {}\n", + " for obj_id in config_json[trial_index][key].keys():\n", + " config_json_new[trial_index][key][obj_id] = [dict([(k, v.astype(float)) for k, v in zip(XYZ, velocity_arr[STOP_T-1][int(obj_id)-1])]) for _ in range(num_sim)]\n", + " elif key == 'angular_velocity':\n", + " config_json_new[trial_index][key] = {}\n", + " for obj_id in config_json[trial_index][key].keys():\n", + " config_json_new[trial_index][key][obj_id] = [dict([(k, v.astype(float)) for k, v in zip(XYZ, angular_velocity_arr[STOP_T-1][int(obj_id)-1])]) for _ in range(num_sim)]\n", + "\n", + " # for key in config_json[trial_index]['model'].keys():\n", + " # print(key)\n", + " # config_json[trial_index]['position'][key] = [dict([(k, v.astype(float)) for k, v in zip(XYZ, position_arr[STOP_T-1][int(key)-1])]) for _ in range(num_sim)]\n", + " # config_json[trial_index]['rotation'][key] = [dict([(k, v.astype(float)) for k, v in zip(XYZW, rotation_arr[STOP_T-1][int(key)-1])]) for _ in range(num_sim)]\n", + " # config_json[trial_index]['velocity'][key] = [dict([(k, v.astype(float)) for k, v in zip(XYZ, velocity_arr[STOP_T-1][int(key)-1])]) for _ in range(num_sim)]\n", + " # config_json[trial_index]['angular_velocity'][key] = [dict([(k, v.astype(float)) for k, v in zip(XYZ, angular_velocity_arr[STOP_T-1][int(key)-1])]) for _ in range(num_sim)]\n", + " except:\n", + " continue\n", + " with open(f\"/ccn2/u/haw027/b3d_ipe/b3d_tdw_joint/b3d_tracking_results/gt_all_info_0.01_std_all_gt/gt/{config}\", \"w\") as f:\n", + " json.dump(config_json_new, f)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## test if the first 15 or 45 frames already contact" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def get_frames(d):\n", + " frames = list(d['frames'].keys())\n", + " frames.sort()\n", + " return frames\n", + "\n", + "def get_labels(d, thr, label_key='trial_end'):\n", + " try:\n", + " return list([np.array(d['frames'][fr]['labels'][label_key]) for fr in get_frames(d) if int(fr)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create generators for the video frames\n", + "frames1 = img_arr\n", + "\n", + "scenario_path = '/home/haw027/code/private-physics-bench/stimuli/stimuli/generation/placement/b3d_track_imgs'\n", + "frames2 = [\n", + " np.array(Image.open(join(scenario_path, f'{config}_{trial_index.zfill(4)}_{i}.png')))\n", + " for i in range(STOP_T)\n", + " ]\n", + "\n", + "height, width, _ = frames1[0].shape\n", + "\n", + "# Adjust the figure size to match the aspect ratio of the combined videos\n", + "fig, axes = plt.subplots(1, 2, figsize=(2 * width / 100, height / 100), gridspec_kw={'wspace': 0, 'hspace': 0})\n", + "\n", + "# # Initialize the figure\n", + "# fig, axes = plt.subplots(1, 2, gridspec_kw={'wspace': 0, 'hspace': 0})\n", + "ax1, ax2 = axes\n", + "ax1.axis('off')\n", + "ax2.axis('off')\n", + "\n", + "# Initialize the images\n", + "im1 = ax1.imshow(frames1[0])\n", + "im2 = ax2.imshow(frames2[0])\n", + "\n", + "# Update function for the animation\n", + "def update(frame):\n", + " try:\n", + " frame1 = frames1[frame]\n", + " frame2 = frames2[frame]\n", + " im1.set_data(frame1)\n", + " im2.set_data(frame2)\n", + " except StopIteration:\n", + " anim.event_source.stop() # Stop the animation when frames are exhausted\n", + "\n", + "# Create the animation\n", + "anim = FuncAnimation(fig, update, frames=len(frames2), interval=100, repeat=False)\n", + "\n", + "# Display the animation\n", + "plt.tight_layout()\n", + "plt.show()\n", + "anim.save(\"/home/haw027/code/private-physics-bench/stimuli/stimuli/generation/placement/videos/track.gif\", writer=\"pillow\")" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "10\n", + "11\n", + "12\n", + "13\n", + "14\n", + "15\n", + "16\n", + "17\n", + "18\n", + "19\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqIAAAFUCAYAAAD/Il5qAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9Wa9k2ZWtiX2r3Y3Zadwjgkxm5r11qwD9H+lFEiAVJBQgoAToXfWzJOhX6OXeUunmbfImk0ySwWg83E9ntpvV6mEus2OncQ8PklFZUNokGO5utptl28zOGXvMOcZQtdbKuc51rnOd61znOte5zvU/c+l/7gWc61znOte5znWuc53rX2adgei5znWuc53rXOc617n+WeoMRM91rnOd61znOte5zvXPUmcgeq5znetc5zrXuc51rn+WOgPRc53rXOc617nOda5z/bPUGYie61znOte5znWuc53rn6XOQPRc5zrXuc51rnOd61z/LHUGouc617nOda5znetc5/pnqTMQPde5znWuc53rXOc61z9L2c/d8Ob99wAodXhE/vIkmEkdHn26zV++6sl/T8/2sfPV4xafe+wX26pXTvinHOfV7T5nm+eLeP73x20Pb4lq/6mnh+Bkl8N2bUN5L+uzjZ6d/8nBf7yO567l9GTtyfp0u9MdlDxfT7a7u7/n//H//H8RQsAY0w5RCTFBrThvscZCVfjOUius64oxFmM0tVactSilUFoR1ojzFmMMCkWtsrxaK6VWaq1orSi14q3DOctuP1EKXF9tmecFpRTGGDrv2U0TORecs+SUcc5irKwzp9yOp4/rLqVgrcU7y7wE7nc7+q5jMw54L+cDiDGRUibFJPtR2GxGtDLsp4n3N7dcX1wwjn17jY7b+wdqLVhjAEXfe2JMdF3XjiufEwUsayAlOXbOhVorxmjGsccaS0yJ3W7Ce4dWGmM11hhKrYQY5e1SCqUUy7rSdf7w9hFCZJoW5mXhyy+u8c7hvKMCOWe8s9zf7zBWrtk0z4xDT9d1lFJxzvLh9o7Oe/rec3/3wLyuXF9dYozl7u4erRVffvkWozXzvHBxcUGMgW+/f0+the1mxFlLLoU3V5fEnPnjN98T1sAw9HzxxRvmeSblQt93hHVlmha++vINISTefnHN//p/87/9vA/8K6XUz/Vz8FznOte5/pddnxPe+dlA9Gk9/mB9DkzbqX/i8X4KUHy59afO1qDMjxz5x89/uJjqY9u9WMxP+eXzEowe111PVqfqs31eO87LM6sXdwgvgfzrH5bDuk52Vj9+1V9eTUF4Tx4/gMyTMzweUT15/rCKUgo5Z5SCXDJKKTrncc4eQaS1llortVRSzvjOCxirAnyUURhlCCEKIKoVpRTOWUqR/bx3R/CVcsJZR04ZYzdcbjfc3j1wc3vPZhzQWgAYCi62G9YQyCmjtSblDIA2GqUVKWZqBa3VEyBdgMvLbVtDQSnYTzNaKawzWOvksiswxlBTZd+AoTWav/rqC0JMlFJY1oAeNFcXW+Z1wRhDCImUCs451mWlloK1hlJOrrhWeOfbe6GYl4WH3cTQ90BFaQ1KkUvGKUPKcv29c+Scj+/RNC2Mw4Czso3W8inwXt6XkBJ3Dzuury5ZlhWjNb7z3N/v6PuOzThSaiGmSEqFUjLbzcBuP9N38l6XWvnh/S2dd/R9x/39jt/+9mu+/PIN1Mq7d++w1vJXv/iCDzd3TPPKZtT0vef9h1u225H/5t/8K95/uGVeFobOY7Thw+0d0zQz9j320lKVYtz0lPY+nutc5zrXuf7y9ZOA6Ot39s8f+2mg8i9RrzOh9RlU+tz1vNzu+ZH+svUagFdP//nqPp+A4+r5tqd1YBnbs+ozqN4Xpzg91wlL+vxMH7sT+sjDCqgfwbkHoJNzJoQoQKpWjDY4Z0kpUSrUkIT9pGKMwWh9/HxobVhDZDNYnHNMy8LQe0ouKKcoWVjLaZowxjCOPTEl5mkVMLSb2IwDFxcb5mVtV1KjlKbWAlWhtaaaijEKa01bc6EqcNZQAasNWmtKrcQYmZeVzWbEO0eMEaUUQ9+Tc4YKKSaUUk9YVKUUsYFPqIzjiPeWNUR++HDLl19cNZBYMFqhVGWeZ7Qx5FxQSqGNQqHRtZJzYl2EzTyATIXcPORUoFZiiFhnSFnYbWu1sMlKkXNmGHq888zrIjcDVHl87DHaEFNkXQMoxf3Dns5bQgh0Xcf11aVsnzJOW1LOdN6Sc0VV8NZSgXEz0nWZzWZkt5/ZTzNvri9ZY2INkaHzbDcDtw97Hh72gLDi8zRzdSms8cP9Hucs1hrGriPlglKVzdiz30/sdntSLqR8z5vrbQPj5zrXuc51rp+jPhuIPmLQvxQoe86Hfe5eP3b+l8+rkz3ll+uBOVQnW3ysLf3aIycM5umun8LpL5b1+PqPbOsp8Xiy7+ss7DMAe9o9f7KFLOxVZlg9ruOxPf+ptb9y7U8e+jEKXr3kPV8epr5ka0+300ajlABoqzUppScHSSWhlLTEY8yUUo6t9847nLLUIq1nawzrGmTdCowWcKu1wRhLzonOe2qphBAJIeHdY5t/nhf6rsMYTc7yPh7a0qUICDswtSlllFY454gh4pSm8w5FxVpLjFHGC6wll9za6E5a+VXYXeekNR5TJOeMMRqthaUMITDNM945+t4zTQs55yPw1FphtGaaJpx1bDY9KQvDaowhZYN3Gq3l/6VUUBmoWGsIMUgrvTGbRmsZF0iJw2c4hIRzBpdtG0MwaKWlna8VSSmctXSNpX542OO9jAzEmBiGTpjUVCBnKgqtQWmN9+7YSu+HHq3kg546Ty0FZzW73cTYe9aY6L2nVBkzGIee7XaDs5Y1BFLJPOwm1jaS0I89OcmYgNqOrGukA0II3N/vSenMiJ7rXOc6189Vf2Jr/sfqT2VDP8amfgzgPEVKx/FF9fTZUyD2fKb19LGnhO8pYPoEa1g/tuanh3k8x+cOm/6UedYf2epkrvP0Gp3i53pKk744/Y8NP9TPXMrjOoT6fAY6n4HQp8BW5jZzysQGPp1zhBgpteCsw1oLDVxZY4ghUYq03mupApoUbU7RYq2mVk3OiRATQ2fae61kNrQIwLLWUJSG2uZI0ceZyNRmQWuVmcvY5jiN0cQoLWvvnjKY1hhSTsQkM5CqCKgNIdB33XGO9MCOHv7vrEVphVKwhkCpFWcNBoNWipwLy7qy2QzULOA15jb7mSqutwzDwLKszPPCZrMhhID3HqM1tVSRL1awxuCsoQBGazbjSGjnNKqyhoA2so8wtZW7+x3X1xeNhYaSyxFIx5TQSmG8k3XF2BjgJCxrSsxzpe87lAJjdLu2jmHoZaQA2O0nnDVYZ3Ht/zLXWqgb0Ma0j5dCK8NmM5JzZl0DCtiOI0ppeS2lMk0LcEPfdXjvQLUbhyjnFqAcP+fDfa5znetc5/oT6icA0Z/Slj955KCIOO5xykJ+fL8fW4d6wWC+tt3Hn1dPF/UIGE/+ccqAPseb6snOx82e1VOA/Poan4LTw38/Lrx6etwDeD7uXdWzrX70ME/fCiVzqc8O9eq6+SQAVUfhz8vzPue1nx/n2b8fkSk5F1ITJ9V2ARTSGlYIOxiRGUzr7PFczltCSJRcCAh41Vra6sbIvOQaAgolDGcS8FdKoe86AcFezlFrFUbOGMIaUQp854WtRcmfFfq+o5RCKSJSOjCfMk7gmKb5yNh659p8qGJdA77Nr5ZSj2MIlIyuCmMNGzceBUZaKVIuOGspoTzOXnpPrztiSkz7mWla6HuZs0w5U2vBd56wxnZuQaGHOdbSrjfGoLViGDpiypTWutdKoZwh54xzmq73LMsqLLE2lJLIOdN1Hq0EWBqr6a0VoZcGjRIGsvMy+5uLvNb6CMRDCFhruH+QOdIDQ621xmiZRd2OI8M4CCgtmTUknLMCfo0hxZn7hz3OObrO0XmHtQaopJTJpaCNbiDcklJmP0188eYKY/7nGzM617nOda5/afWTGdGXbd/Hf31yp09s8pzJfFmvwb5nbOiP7Hd8RL18/CDmOarGP4a5PxsvP93wMFtbG3h6bQ1P9jqwk8dN2slP2+8/gYF8nO1VVHVyvdTjKQ4MqTxXT3d/5fxPQfNHz/4xEvn5v56D0PbnK5yptOW1wliLApZ1bS1txxwXqBXVKaZ5FjGNd005DkMDhsaY1jaX2chaEVDmHNZJ635tyvxSCzrnk09bJZeCdVZazsZAA4NriBitjwBUG41zlrBKK/0gbJK/a3zX1taA11rysZ1fSsFozbIGBuXJpUB5BN6uAakQIsqY1qYXUVRtIDvlRAnS+h+GnnmeocoIQs6ZeV4FrCOjA1qLiEkbEVZpreQ6aE3fdaRS0EqTa27Mr7TwbWOEtVJsx5E1CNtZq8yFxhhx9sBeZiqVcRxY10CIAWu0zK1qBch5KxWl9LEFL8BVE0LCWt1AqGZZVwH4OaGKYrsZRdRW9szzQtd5+X/fkUtht5/o+w6tNLXSrsvSRgvi8Rpqrem8J8YsTOm5znWuc53rZ6mfBERP2a0DW/Y6//aIPD9tXfIKg9r+q45Q95SdfHasZy3ep088f+QUuNYf2fYje38WMfICZr1AZELkPV/D4/Tq57i9HJnQ01b78Vo8PcAjfn12nZ5jwOeX8hR4njwueP3kOqrDu/M4AvFRgHrCbj5d2wkAPm5Sn7z/Ak5Ua9smATfWkUultwZtBJwccHxM8dha11pjjbTIcykycxgi1mrmZSWGNqfYd1hr0cZgnSFnxbqsGGuOivxSCrVotFNH1X0FOu8JIbAs63E7rWWeVGmFQWGtbUyciJaWNTD0HcZW0pRIMTOOvcx1tnnYh92ey8sLUkyNOVTM80JK+gharTVNIS+zo957UJV5Wo/zpsMwUBtD65zDO0uMma5zbQ6ysiwr49iLVZPWHD5Lxhj289Tmaw1KC/B21lJypSoZL/De0XU9to0jlJob0IeSc2OfZXbz8nLLw25PWAPWmSa8Uu09rHgvny3vHfO8YI1hMw4s6ypssDVNdCRMs7T/5X0QFlYY7dAEbBfbDZUqILpUrBUG+GK7ESYVmX1V6hGI7vYzm9c/yec617nOda6/QP1E1XzDDy+66h9hER83eAp6TgDPQXjyZNvPnTE9OaD65Bpe3+355i/XcYB1Hweur8+XHp771Nleq9OG/PNW/fMjvVzrq8dTz7Hfj9LPvEr/Ppun/fhNxMm/TknUH2GUT1nYevAcfXZspTTGGtSqjjOHfdcRYiSlSIiJi+0G7xxKKabp8YQpZRHg1Ip1YodkrCi+N+PAogPUysNuwjvHdjvirANkHnWaFi62Bm8tMURiTNL+tpYQE8u8sq6rKLHHgRgL034WBlNB33UCjhowjSnJp7ZU9o2lu76+ZL+fiSnhnWNZhY2s1srMZ8x4L+DcWQsoXCcgTECctNTneUU3FtN7d5xbtdaQksyv6qLEC7RI+38YelISv9IDkD4IsWJMj9ZYRRj9ruuPDLBSihSTuBKskZvbHV99eY1z7sg0phixzmFyaYxywUbDOPQyT1rEBzaXIoDW+daGL8Qk/qf39w9ybu8F9Ed5H+Z5oZTKsgZqrlxcyHfZWoO1HfcPe+ZlQSHzwcPQsa6i4F/XiB3FV/XwlTDGMDYG9VIr8ak917nOda5z/Sz1E1vz6hPq+cf286HlexCxfBqCPR1QfN6N/tSs5CfZ0hcA8MdZ09efO6jtn531s9v07YgvKNXXGeSX5ziFoo/rOwI3BTShzNFs8jl7+dpiXxNZPd/22SV6AkJfBbInzf3np3ze7X92ipM9n/x5wK8iuElM0yIiFWuYlpUQE32bQTTaiI/lKHdMm7EXw3UU3otPaIiRMM/EGPDOYYw9sowpJrTRlFzYTzOhtZRzEfB0e/fA1dUF2+1IPBFNhRjofUd3ecHt7T1dJ+KZfuhwzrVrVwgH8Nm+F6EBSO9FaGWNQW0VH27uRNhUC6UUNsMIqrKElZji0RaqH8RWKIR4VOz3fX8UTVlr8d4fxU+inpeZSmetAENriTG1uVRLyQWUouTCNC0YK7Od3jveXF+xrsL4hhhbS71ijaLrPfv9zLys5Jx4//6WN2+uAJkzjaWQm4I9tfeRy8a2ak1IKzG219B5QLEuQUCz0fS9Y7P5BXf3D8dZWgVsxoEQrfh/Dj0hBH73h3vevnnDdtMxzQtQ2YwDa4iUCjlXrq8v5TVYCwoRUK0RbfLx+vR9zzLPP/Wrfq5znetc5/oJ9ROA6MuWL3zqoeeMmnr6+I/1uj/60/9zGcaPU3Avwe3Hj/l829eSpA6tx+MpH0cy5QiHLvZhtvK1ZT1rfz9F5E8fFyDzGrg8/OfH2dfnQPfUDvTV8KMnh1RPTlNrfXm1T1wCDkDyybmfHLwen3/esD+057WxKGNJpbC/23N5uWUcZM5wPy3HFvOyhgbqNOsajrOEuVnwdI1pzLkQaqRWUUQ7Z6jNlkm7k6+FEqAnHpOzWA69vWrm+oXOO6oTyyVvHFfXF9zd7xhaMtA8Lw0Qim1TrU1UVMsR+FIhrIGohfH96su3rCESQ8B3jhRlJnMcemmz9x0hBHa7iYuLDV0vgqOH3Z5lCThnRMTTmFDBvZXSbKG894QYxPxeaa6utghgzBgrwiS/ccSYxVu090zzwtrsk66vL1nXlWUJoBKpZHpnubzcst2OLMvKze0Du/2Et67ZQRW89zjn2ojD/jgzXasIwtYgFlEpi29p5x2qzbPudhPX11dcXW7JubbWvWcN4cjeppS5vNjQ9x3LspBiQGmZG1VKUWVagVIK7z/cYq2hlsoXX7yh1n1ryT/+lIoxcnG5bcr6c53rXOc6189Rf4Z902tArz4BMYLDXjTAX+zz+uOfPt3nJSa99uznzKx+fJsDYDsyda+tr/L65eEl0HqkCl/Qj8cTPmENj6iXV67ts7b5cZD0xcV7/hdejhw8e76+eJIDUDxprJ8cRz0hZ1/jdStiAs/pvOwToC/HzvOeuz/+hu//v/9v/nX8jm/dpXhxOhHsDKMwYbVWrDFM88xm7CWmMyUqAkCVUqScGXoBLbUWlFFM84TPHu891imWZT2q3EWo46kFtpuRZV25ub1HaxEiHVrna2vX933H0HXU9r8YRKhUSsF5x7pmUsrHeVWFIuWENUYY33mm7z191xGDvHfOuRZVaug6T47C2ClUO5bMSiotx9vt9vR9h28iIhEw1TaaIFd+6EWksyxLs3A6xImGNndajwS73PeIgCvGyMPDA8MwsN2OzNPCNM+sVYRP8xy4utoyjgOlVkoWVjemxPsPN/zyqy9QSh2fT63tXStHK6a+88LyAvv9XhwQrOHdux+4vLyglEJKCWNkVACUgG9ruLy4YBh6pnk5vo/zshJjZDMOWGvZTzP3DzuuLi9wznHfWNaD08J+L1Gt4zigjWXcDJzrXOc617l+nlL1c4JAgdsP7z5jq0fG7/PzlT8F/j7nOT6xzefWpxrGr82vHlim9oj61Eof93+80q9s/ZJSfDz44emPAsiTbV/d5tl2r+DPI8h9fTEny3q6ro9Gg9an8PT5eZ+wukdmVf5TcyTNe+Z3f+DuN/+eu9/8B9Ld91Ay1Rruo+ZdvWK3/StW01OVxjp3PP5+mum9E0V7E6xorQX8NG/LUstRlR1TOrbIvfekmMiloFB0naOimgG+CKFCiNLmb+rw7XYEaouh7ChVQE0tIrpz3rKugXlecN7hnQOqzB7WSj/05JgJUXw6AVlLm7GMUYRExhjxUY1JfFCdhUOUqXMsIdD3HdZopmlF60PkqQQBWGPEviqm5qFaZdYyiVDr8H6EEFH6AMhFCR9TltelxbM0xMjV1QXWyms7zKimlgZ1cbE5+pq6JvRa2nYKmZm1znJzc0eIkVwKX7y5xhjDGlaosvaYEsu68uXba/a7mdJGEEIIx8+MsSLOWuaVmATU931HyomcRBi1xijrMLb5o1be/fCBcRy53IocSa6LEZ/WJbBvAqkvv3zD/+5//398/fvwGXXOmj/Xuc71L7V+nqz5T4pOfkSR8uomnwJjn9r3T/zhfhwJeGSHPn28V/vooA7s3vMJ1ddfwNNH2z4n7fDX1/jKwx89A09fz4sO/TMQqh4ff7mGz7g3+cQQaH327+N5nh+jvc5aCiUF0vzA+uEbdn/4B3Z/+HvWH/5AnPagwDpDtYaUMhc68cZ+YEozt+ot77kg6AuU99QqghTV1PO1tYRjjMzTQte5o3AqxkhKiXEcyFk1+x5D1wmIOaQp5VJwzqC8b5GZBkURoU2bLfXNmzKm2ARJDfDmTC76kc3McqzDOqd5gQqbzUCX/XHeE1oak4JS8nHO03ce2/LWjdZUVVGlMK/iHRpDJGuN91Z8QWsll8x+P4l4xwiLK0KichxdsL2wyjFGhkFM9bXSxCjMpPOWFEV9rhCgvN/PbDaDzOg25nEJgdzETX0vYqeD5+g4iMCp5Mzt/QPXVxdcXV1we78jzQvzPOOcP65NbLFEnHR3t6PrHE6bduyeUgvTNJNDBhTD2NPXSlzT0Yop5UxtIQIHh4F5FY/Rt2+u2e9nsYBqrPLh5sK3G5mUMx8+3P749+Fc5zrXuc71J9VPB6LPWLtHXPPYkn21G3/acVWPgo0X9Smw+RpmrB/ZpZ4c7Hnb/HOA1ovFPDvpR4BrrQeQ+XjCj4PNk+55e+w5Fj8dAXgKXNWzrZ6e6/XVtROcnOHpudRrcPFxy2fjAy9Sqo7Y/mlD/unf2hpyJoeFON2x3nzH8u53zN//hvXmW/K0o+SEKgU/iJCIBsSME/9QrRSuJt76O/7NULi18D5v2WVLVBBzZug6YoysIbTll+Prcy2v3RhDzZXOOdZaCet6ZNs674FKylUy0qsoqg8JTWGJzfsShtodRUJGK0IQIU3Xd20Ws+XQIwBT8uKlvX+I7DxcT2MMzhlyEvYyNwGROXxvFEcmtHPiRZpKaaCzNBP42CyrpK0tc5PSqqZwtJdKCIgrVXw8D3GoWmnGsSdGezTYt42hVUoxeHc0/F/WcExEGvuebDOlVkIIwjpbDUpuOLQCZcRr9eAO0HuHkjaKsMIlN0GaxSoRUyWVCTEz9sKsQmUYBvq+Z11XShFxlW4JVCUVSi10nW8eqY8JVX3n2e33lAJXl1v20yxAtdlgQWU/zeRSuNhujnZb5zrXuc51rr98/RkzovXZv15LA2qK81Pw9FrL9keA60dPrT6y7fP29Gst79NZxlfP+ZGW8yuPvQSaT1/Qa4r5A7h8CexP1vPs1E+Yxo+u6Wnr/OnBToDhK234483ByRzA06v1cZj64pqfVpuFrKWQlh3h7gfWm29Y3/+B5f0fCHfvKOuemjNoUUlrbcGLeKRmafuWUikZtLX4ocP2Hr/Z0G8HfqUUD7sH7ubK75bCD3mg6o6sm1m64tiSpoJqAhqjBaiJ+EWENSJmyo0dHI7+rJL6U4TN9MKa7fYTAOsaBLhW8INn3s/knNmMAxWISdKIagOQpVY2Q0+nPGVdW5pPM1RXipxKm6XsWRYZH5imCWttm4+UVKhDRjpKiQF7Fo/MNRfuH/ZsN+PRF9QYfVzrPC/tGEWU/VXAvXb2ONf5CBgz87I28A5ziMc1eO8xVvxOD0yw8+74Sa6ltfqVeKCCIrZWfNfcAiR+VfxPDwKmnAuQxXxea1gD2il850HBNC/s9nsutpsG8sXXdJ4XsnNY6+i8JaR8TGiyjZU2xjD0A/tpRmvN0HdHu6daZS3eCbstYq3uY5/6c53rXOc6159Zf3bW/CmLdvzlA7RB0SOAenVM6pQBfA0ffiZxWZ9ivB9d8SefenX/Z6D1R072seSkzytBgq911Z+eryHGZ9fttXm0j3p/npjSP2W2X0Zw1sNJ6qOdVX2Nfn1CsRpQkNeF5f3XzN/9E8u73xPuviXtbyjrRDkkCaWEAkynsV48MlG0+MpMCQnjHOObLf31FX7sjq3vEgJhXii7HWOM/BsNX+mB27jjtmy41yNZW7xSx3lBo01T0kfGsT+yZRVhS60x5FJIWdKOfOfQpZByOQIWpcW2SJTYVRg/I6DWOQsV1hAlHUiBaRGah/a7aXOrNqfmx+lEJAQSWaoVaX2cWzQtgSjExGh6NDSPzxZLWjJGawqV7XZEa30USmn12CKX+cl8jB8VllM/ttG1PgqbZHbWoqjElCXbXjV3geaJarRcD2PM8bEDmDyIpGIKR7B3WMc8ixWXNroBRLHOWkI4Ku0ldEBmTEvJpOYpeohIPTw/jsORCUZBShGlxB/VO3N8H8QSS+ZMc8nNhkpYbqUknlUbzeAsffXcP+yPDPm5znWuc53rL18/EYi+RkU+gyzPab6P4bHTVu6fWs962K/jyBOG8MdO9uT5l+jqALNfELjHQzdjfZ6PLLzSoj5d1gljfPj3Ezuo4w7PmM1aXxzvJbivJ6v/2KjBs5f9EZL1hMd9WYeHW357SZHl5lv23/6G9Ztfs37/W9LuAyUFKJkClCIATlNxncX0nXhbGtVAUMU4xzB2aN/jhgHnLSpncoqsux1hJ0xqrYWSEylndC5s0kpfb3hbHbdqywf3hr29IKGktW5BaXl/QhRj9gMbKRnoImha1xWAFBtQrQUQMJVShiopRUrpI5hRSli2aV6OyvNlkXbywWR+XVbmeTmyefvGrBqtUW0dhzcjZxE/GWOojsaqpqOaPOWELEUAcErCNh4SmnLOoDke03uHimJblUttYDVhrTuq52sDbKXIKEHfd9icJVlJa7Qxx9GGnDMli51V33dM03w07y+qoKuwkfOysNmMzbuz+YtGScgSEFpRWh+P6b3n7v6Boe/wnRdz/BgbYy7gtRQx6qeCc47Liy0xpfaaZKTCtGStnAWoL8va3BM8OcnNQ98cBlLMzUVAGGSjxdD/XOc617nO9fPUn8iInoKiE3hUnz7yEtOc7Pc5rfefVB+bb1RP//qxY/+J5/zxQ32sHX547BOHf9G7fzS6/6gQ9wDuT2dBX2UuTx/7nNiAkzGHU/Dc9tfWUHJmvf2Bm9/+PXe/+Tum739D2t/iVMY5DaW02b2KNhLJ2Q0drnfYzot/ZxHLpVKyCHs2W4Y3X+I3IzUEwrRn/nBDSQ1IhURYgkQ+loIGapY2eGcUXY1s1D2/0Ct36Yavw5b3bJmiYeiczCw2pi5lYeCcFbW995ZliVAF+FnrpD1fQgOlAspCTGitcFbASym1sbnC8HWdZ2gzkarNKlpj0NaQSqbEcmy5p5wZnJjoHxTgvpM4Uq0UwzCIQr1KhOnxBkPBsgZiSi3Scis+qkaM/mnrzUWiQw8uATnE1h4vzMtCKY7Oe6yxZF1a7ruMNQx9d5wtPaQ+GSsAzxoLtbIuAtwPTKWC47lsMSzzyjD04mkaBLh777DKMMcVqy1955imhXleuLzYCgANAWsMu2mWqNPeo1DEmNhPEwp1VOJrpVDWtPeqsO4jXSeRpjll7nd7Aawxy/ww8l7JvG9t4LwcBUs5v0z6Ote5znWuc/1l6s9szb/eqn7hJfq5ffY/tZsNn0R0p+3qT0w5fqLUyX+fPnbKhb6+12tVP7rVC0b5c3atLzc49cc/ru1VE/yXrfhHLu6kpf9818b8QSXubnj/D3/Hza//Pbs//D3h/oZaMloL66idxdBiNZ3Fdw439PjtIG3rWikxk9dEjom4RnJKwqilG0pNjJdbwv1OmK5YSDES10haAjmKZZC2CtVZXNf8JWuFUskpU3cPuP0P/DJULvwVd+MXhO6X7JJiWlY6LwAspUTOwjR2xrPdDMzzemyLH0BkrZWqwNrHmMx1leNY50Qo493xPTJGk7LMiNZSKEBtIpqUM0bXY2b6GgLOO0iShpSSWCvlKulSzlp2+6m1/2vLq++BfPTiTC2C9JBEdbBTKo3FtdaSS0U3AVTXd7gWBxpzRuVMRa6ddZaU8pFltEa8VQ/BAEYLWDvky+c1YFqO+7GPUCud7/BO0p1iS42ap0UCB3Jht58wxnC5Hek6x8Nuz36fGYce7xy6zcE+RooKK9oPHeuaKNSjdZfWmtpCB3LJLGuh8x7fe8Ym6KpVEpcOjgQyTgB9/8i+DmPPMJx9RM91rnOd6+eqnxzx+chqPoUuH2cjP9HOfV5/Vp/+tQM1ic3HvC5PtpFH6skjr6K8V/Z/tnd9/sjz47x23I8D0yMkfHbwWp8f5/lrfrb9x85+cOdv51AnV+HIhdZHsK20KKDzsmf/3W/48Pf/lg9///9h+v47ak5Y73BWo63DeoszWhTL2mDHnu5yi+sspHyMW4xzIM4rtQE9bTTWD7hNj3UaSmX6/oNEbcbMultYlwClYqz4exqj0c6gGtsXV1Hdz/vAuiZSLjIz6A1Xfs9/PRSSW/nGf8k/Plhu7wKbUQQ40mLv2O3nJmQRf0ylFEYr8ROtMjNZyuM12u9npnnmzfUVw9Czn+ajYltr86RzMA49JRduW+s55oQ1IpiqRYzed/sJrRRXZisRlDGxLoGLiw2990fGdOjbjGuF3EQ/MWURKZWWeV+h672MARxiUp1lM47HRCPnLBVhMJ01hBDJyDG7BnA776mIZdShJS4io8zDbs/VxfZ4HPm8gLGwLAsPD3ucswxDT9d5Ab0p8f7DLdvNyC++fMu0rKzN/uny4oJ5Xog5YTD0XYdr7C3QRhYKRjVrKSuftYOA7DAnK5Gl4sV6f7+n5HIUJKVUubwcj8fT7Saj85ZlCcSY8e6smj/Xuc51rp+r/gRD+9cbzx9v7v7ITOJn1dNRgMdHP8ZGnp7zU+c/ea4xXI9b/hgQbc8+wZrP11lfOf3nK6uevjMnrfHD9Tg5b+VEJPVM8f76wR+3qK+u8/G4KLHzKWllef9Hbn79P3Lzn/8tu29/z7qfUVpjO4fVGmeF8URrrDMYZ3GbAb8Z0E4si/IaiEs4ttVLzmgU2ltc73Fe5kQPqU3rw575YSHMAgwM4itq2vbWarS1lApxPxGmhZAqOdVHoG0UbvB0m05axrVAzqQ1cB8939YrvtXXJL9lDYGry634dDZRkm4CHaXUMT9ePDU1IcZmsh5ZloVlXek6SWpyVjLuh0EiPw/zhral+Exz277NmWqtHhObKrx7f4t3BtXU3YfqOy/JRQ2UWStt5/08c3W55YcfbhnHXmyb1pVlFuumy4sNuTxGqgoAdUcB1uHDUevhfVfNkko3k/uAcxJZGlpqlIDawzURwC0Z7wJq+77HtMjVQ068VoqYc2OgRbC23Yx470gpsa6RlCLjMGBsm0Ot4KxBKc1+P+E7GZW4urrAaMM8zyilxeN0mlHtusQYj+Kn3ARQtcp7si6BWsVrtu8lQlXeZ45s6tD3/B/+2//zp75Nn6yzof25znWuf6n1ORDzzwainz2D+Vl1AqDq4Qf4x7i8lyysqk+3gNMxgY+B1ZNxyVd+XxwJw9MzHwDfkal8ftaT8330mrx+oT5+vMPzJ6zts3SjQ7vx9Towd49/fxQ1nexzFMm046bAevsND7/7j9z/9u+4//rXrPf3GGswTnLQqWK03vVeQGnv8eOA7dxRhYxSkh60X4lroIQoyUNao62h3474sYNSyC3ZqObC+jCRVjFBr0hCkOscxhqUVpSURfSUEsu0kGPB9SJ+qYgCvNt0uL6jAClE0ryQYySua2vhI4DSbXg//JLvuGCuHtdJG3g/zeJ32XlyKdJKLqWJbERxrVuSkm6G72t7fd4LQMtF8tSde5w5NNbQec/9/Z55WfBtbMEa22YUBcQeUp5iSm0W0pNixjjdmMXMNEmsqdKKeQnH1vRBpZ6ajVEpAqzHocdYQ4q5CXrkJmJdo1hcIXOzIigSlwHfScs7piRzml2HQj5zqUg603YzSJoRInICUdMPXY+xYnqfUmazEZX7fj8xTTPrGukHz9D3zezfijl+LlxdbljXeJxPvbiQ+df3N7c4Z+mco+86rt9c8f79B0JIvH1zdQTOuYhvq9aadV1RKOZ5JZcsrX0vYwYoAfgp5SaEKry/ucUaw3//f/2/feR79eN1BqLnOte5/qXWz5Cs9KkWMq9jp6cS7tf3O939KcXI8SHqC6D4ZKv6/PQHUHvgS0+P9Qx0vjJCefr8iyb88x78y9U8/vk8Q/7VI35GPT/nyQIfidFmxfPKsl5b89Pr3a5PKZQYiPsb9n/4T9z++n9k/81vKOss11JZvvjbv2a8vsAYw3R7T14WlLHYQQRHxlpUqdSQiBWq0qQQSNNKieIV6jcd2ij6zYDxDkohThNxCVQEOOUQIbeYzL7DOo3tZA4xBWnR59YyV0rjOs+wtRhvQQsItS1JKa+RdVqIy9LyzRUlgXYO4x3aGQZruNbv+ddqz3tzzddhJOgRYzT39zvM9QVam6PlUc4ZoIHFeDRF18bSeXdUhdeDsXpOR2P1Ugr7/UItlc2mb7OiBYXmkFO/n2bGQeZoT/1DQ0uE6kxHTpl5mglBmL3NZgAqMUb6rjvenNSm7j/8UBA7JBEjjWMv4DIJ2D+wr6l5nx7mYw9sZi1yC7jfT3Tey5xlFgZ36AdKqeymPb5zwkKmwm6ajsC7awp4qC3PXdN1SYRVVgD9sgbGoWdeFx52E0PXYa1lXlZu7x4Y+47ee0KMLEVeL0r8WvvO88P7G7bbTZtllpnSvhfbpxgT24uReV4aq1vYjAN39w9iS9WspS4vt/ztX/8V79/f/vTv67nOda5zneuz6s/2Ef2cejp7+Qkm8rO6+K+JgtQJ4Do5qPyuezar+fTcz1f6/BwHUra+2OZ0u5fPqhePfKROpwNO9j1yw690zdVhlODHD/nybuRE7n58V0omh5m4u2H6/vc8/P4/M33za5bbH1Cq4seBzeUX+KFn2GzwQ48yAjy67UjYT1QKShvyGkkhk0Oi5ErNiZqFhbOdw11t8dsB4w01FUpMxL203cN+puQiYNMorLeiZi5gOoMyhpoLMSRKFOCimtDEWo0yGtt3mGaoXmImzis5rMR5PUZmWiutbj3I3KruPNDy2LXhqvf89aD4b8LMb24XvokG4xXrsqKsZeikRZ4OaUjNezOXIubyyGdOTN4V1nRYK63p1Nrv1lo6L3nuIJ8zowU0liw3EzLDmASAzUtrnzfmG0XOmaw1w9jhvCXGTIxZLKGsPR5XZj4dxmqWdT2yms7IdU4poZXC95773cS6BBEHGd1a+gJGOQLiLAb0WhNTZFnFmimXzL1SXF1f0nddG/kwKC/bpZTEpkpxFAnlnCR2tDeEEISN9AfmNbPZjKxLYDdNvH1zjXMSxZmLGOePY49tanhrDFpprLPYZFnXVXxKtSHmxN3dPeM4NBGTCJVijHy4uacWsZ46CLmWZeXDzR3OWsax//R3+FznOte5zvUn108XK70GGj/299PtXmzwytGVMJjPz/l6y/wAOHmCKp/YhR5P9zFW8jVh0Ok5Trd9rV55/LXDvgKwn7fITy/Y6XOnZziZ4HttkcejHGY+6+MDJxu024GcJeXo/j3L+z+y/+Ov2f3xNyy376AmfOe5/PINw8WGfuyx3qObOCWnRFoXai3ieemssJ9LZH2YGwjNrX1vsYOVdnrvME7iF8PtnnVZSauY1VMrGGnrW6fbMiu1VHJOpFk8LGvKoAQ0KiNG786JUh4UOReW3UReV2ot5JBQiF1U19qzSmvs6LHeC4j0Hm0szhu0seSYWKZAmife3N1T3u+59FfM17/iXm3IxWCMbcBME4MAOWMPbffagBsSm2m1WCRVHpnJInGitBlM8c08qL2lxX8wq1cNANZaJYoTGuOaRXGPpvMeYwqlSGTnQQmuUDI/uax4HCGklvjUY1ob+mBsfwDS6xqE7ey75gcqa7TWoLU6ph0ty4pSuvl2FrGZipGpibRyTjjvjvn2Gdm31MIaIpuxpxR1HB2wLXY1BPEKXUNEG4XRGu8c6xqaz26htOuca6HGSOc7Ukr0nWcNUURVVQBnqfL4fYjMy8rQd+ynheLkNV9cbMS+al7wzuGc5NYv8yqvUZ9b6+c617nO9XPVTwOir4DQJ/qY11ATz6M/n7GNHznFx+v5ST49InDMtecjDOHHzvLR7T4Opo/7VPU5L+RxP9n5+K+P8qsfWdPrbO1JHcBnSaT9A+vNt+y//Semd79jfvc14f49NQVc57l8e0m3Hek3A90wNM/J1ooulZIjOYi9Uo6ZuCbKmqglk6IYm7vO0W17nLfSdgdKSKQ5st7PhP1CXGIzWZd2u3FWvES1ouZMTpllv5BWUcdro6hVREq2d2jvxaicSsm5iZ8CYY0CUrSIiYyzMh9oBZhpa9DO48YBN3YY5zDOUyuEeWJ398Du/T3rNJHWlVoK28Hzy2vD8IvCbCvvp8A3+8RDtGB7+qEnrIFaq0RD5nSc55ToyXAUOtXK0QbKd17+3t7ilDLe65NxA7kJOxjll1JFNFYksUhr1cQ+8g3LRYCqs/YIdlNKKCMCqHVZZbuUWJYVa40Ikayl711jOlMDxIppmum7js1mkMz7lFs6lID/w5pzynRtBGJNiXUN0AAwVbXXo4/fj7F5ocZmwSQfUdWYWytpWaW02FTXZlWzeKC21w+gtMzexpBgKwB+HD37eW5jA06EUVWDVzK2UKEc3wu57TXGUJRCcVj7IcLVktKfPfh+rnOd61zn+kT9NCD6Cu77CBQ8qb8km/A01/3wi/3ILH5siPS1B18jd1/Mmb6+hs9aZ4Pfj5MChxnVV6nix/1effhjAPS1MYH2d0X75Z/J8z3L+6/Zf/OP7L/7LdMPf2S5+QAl48eO7eWG/uIXdJsR50QIRGvphjk0oCzgJ6yBdVpIs8x8pgZkus1Af9FJ/vh2wHpLXgNpTYRpJs1B/DZTpiqFbUb2ql0b01rJYZoJ00oMkRwSUMQSqvfY3mOco2EXSoqEZSUsa0toErbMWFF4a21Ba9Aa4z2273B9L8cbB3QnyTrz/QP7mzum2zvW/UyKWRjhX3zJcH1FN/TYrsN2nqsUuEj3jPd7fgiOD3HLTm+o1lNLbUywPQItazSlzZN675tnZovd1ML8riG03jzHSFEUWGPbXGazjwK0FlaylNLGOeQzk5sinCrvW85J5lmplJBbi1py46mVUmsTMCXWECmdP8ZtxhgletRKu/zwvSpUkpK52Fwyxhj8KOr51Ez9D0ypMKmOWgsofQwOqKUICDaaeV7pOsmbP3Q+lFZ47ym14L3M15ai6fqO2JjSUuXaaa1ajj3M80Lfd4QQ6DqPtYZ1CXReBGb75lHaeYfSWlKnkszI5pKPj83LerSz6vuOvu/Zz/PHv+rnOte5znWuP6t+uljpeav7CN5e6T//GJnwE8iGJxZDz07zHHEe8GjlAAlP13l6zKfnf9ry5pHpfXbcj72A58D4NEnp8eEDa3pykufnfvG66gmrqz5yyQ6IVzeLpB3LD79n9/V/Yf/tb1jef8t6d0PJEdc5rr64ZLzY0l1ssL4TJrIWaslkxNoox0zOldzAZ1kS025Pad6Y1lu2by5wQ4cfPNo58hogZqbdzLqbSasouJXRGG/pLke0t5CLtNkp1FSY9wtpCaQobV6twPcOP3b4oZM2ei2kNRJTAtMU81nGA4xWqFrRbf4TZE5SW4ffjnSbAdd3GOdBK1KI3PzuW+6+/0CcJqCgVaXfbBi/eCsAdBywzkLJhCWw++ED8WHHup9wy8ovKoxRcRMcu4u/Jl9+xRRFmW9adGcu5ajMzynJNWp2RdaIP6Xks5fGVoo3qVwb+fw5bdGN3TxEWh7iSLWTP0tjWXNO3D/MbDcjSmWsk3GKsEZqGxmo1hDmVayX7GOKE0pa/iUX9vsZ60Q4tK7haB0lpvMa5wQk11gpWYChbd6jXefJOTO1tv849jgr/qGH137Iey/tBsdaQy6PwipjxIRfZmYzYRXbqKWxpP4wVqE0pWSWNbIsbf41iNeqMQbrDDmUowgpxNi+RTKDO44D9w87GXlos6sH+yitNdSKOavez3Wuc53rZ6s/I+ITXleEH7aozU7pEz/Ef0LH61GQ9Ah7K8/B4YnM5wD0nlgaPQXQjyuF56yjOlEPqQO1+eKEz17A6XBqffbEi9f6Iw31Uy/Q03nY10pJ9naJkfXuj+z/8J+4/6e/4+G735P2D1AT2jqGi5Ht9RXDxUba4EZTD8lGh3NYg6qVGDLT7QPL/UxeAikIM2qdY3x7Qb8dMM6iUCgrv7Dn2x3zzY6SM6pIEpB2opDvtgO6iW3SbqJCi0+sLNNKbn6ihUq37RkvRlznwRhUycQ1EueFnKTNi1Foq7At6lGhJBq0FlAiQhquLvDjBjf0KGPIIbL/cMvduw/s39+KQr9WfO/YfnHN5u01w/U1duhQxlFSYt1PhPsHwm5PDoE0r8SQCCES14BOlV84y5f7hWn+hofxKx42v0R1Q7MKkkopE6JYEHnvUNoIK2oMzhkq5pgW5LxtGfHlOBcp7XLPugbWtbGrRtr3B2N727LnjbWEmMQ+qrbZ2dLa46XS9wc1fQEjSVG5CZAkOcm01rs6zmKC2E1tNiPzPFMrR89NZ93Rliql3Gyq5LOxmybyYf7Se0rJAlqdzMPup+kYB6qVzPiWKjGvlSqxoi1GtZQqwDk/OhYYLXnwSul2QyJ0+f3DnmUJ1LqR0QCtwDvGfqDUyv5hz7ffveNv/+avjsCayjHy82B7VWoltXOd61znOte5/vL1F1TNn+rEX0qOntZHqc2T5z6KuvgYgj2yis+pzsOe6jnefJ2FPMWar7XvD0+8fqyT9b3qFfX09b1kQg9m4yfbtSFCdbqnUihtKTkSbr7l4ff/ibvf/nvmH35PmXftF7Vm2I5cXF/SX2wx/gDaRM0eY0Z3nbSvqyx3fViYbu5Y7vfERdKObO8Yv7ym2wx4r7Heo4yAhjgH0v1MWiNpWgX7O0c3dvjRCetXKzU3f9BcyDHKMbS0n7ttz5QTaV1JuVAUGG/Q1pKmhWW/J2ewRqONRVndAJy0Z1FQlaFYg/Oe4fICN/TYvkM5R1gD919/x/2337Pc3JFWyak3VkDy1d/+iuu//musl1nRkhLL/S3L/S15XqhFWtEpRKZ5JsyJ0rwylRG7qM1lx7WtaH3D4iPv6ltuu2tu1yLrrpUQIlQxtO+8gJxSi6jDxwGj9TFK02hDruUY2XkAec6JjVOMgVKMgPmUj/ZExpqjelwSiORGzDSgR4UQglgyFSSPvvmKxpSkXW0FRDprccYwTQtrCJis6fu+xZqW40c7poiMjio2mxGUEmN7pRj6nnlZGqNaj6b2m80G5x7N7/veS1JVLi2LXljMZQn0fXc0u5/nRT6na1PzWwGQMSa6zrVUp8o49nz4cMd+P4saHrFkSkGu08XFFutFXHUw7O+6roFaJcA3F7YXG6Zza/5c5zrXuX62+olipedMH6/iwucq8Nfq0JR+NGM/3edxi6fWTz9y9Cf/UIcTPD79xKP09LGnxz0VKj222x9PUp8wnvXxxbxcBI/s6HPIWR//PDCtT050Ml9wYIKVPm4X97c8/OE/c/v3/5b5239k3d9Kq9JarPVc/vIrNpeXdM2nUSxrRFhyMJhXRtqwYTcz3z4w39wT5wjNL7LfdIxvL+i2I1qB63tySswfbkVwFIsIibRCOUt/vRUAaBXKGhEdrYkUIiVFyYRHEpRyysR5YdnPxLAK4axqU0lLXvlaZKbQeo83BqWNpC95i66VkpKs1Vq67QY/jNi+RztH1Zr5fsft179h9+4DYb9gvUEr6DZiVm+cgLP08MDDt9/Qv3kLtbDc3hJ3U3trKmGNrPuVdVoQEY7F9mA6S78d8JsO1zlKktfbTXdc3XyNXRV++yvuL/4a1W0xxrIuS8tozxhjxZS/FO7vd2w347E1vYSVse8JzeszhCAJTtWLgh6oLSXIOkkPCiEwmL61urW8P+3G5pASpbXGKnO0Xxovt0eWWStDNRxnNVNK1EoTrBVSzCSTGrNZWlJUPH5P9tOCawlNpv0pDLBvn34xt/f+MBussM7RdRWjDcN2IOXEvAj49078WJdlJeXMpvRtNlQfZ5iVku/5MHSsa2QcNSrB0HVcXmzEpso6GTnJBbRiP8+oZeHyQqJTnbPcfLjHO7HxyinTeyd2VPcP/OqXv+Bc5zrXuc7189RPFyt99LHnMOtpO/oUZ53OcL4kPk+R7Wf07j9KoL7WDj9lTZ+14p9g4NMW/2vw8VXk/eKYh9fyFMd+BJjXwlPweQK1lQYqaXpg98d/4Oa//DvufvMfWG5/QKuKdg4/DIyXWzbXb+gvRmz7ZZ9TYpknckyYThgztCKumeVhZvf9B+K0oKpCa3CdYbi8Yrja4DqL1pbwsCMrERJNN3tySGhrsJ3DWCv+oIMXkU5K5HkBrcgFwrySFhG8aK0oFKabO+K6SspRktm8rvN0g8f3vbCeLQHIDE7a86gmQmpKJWPww4DvO2znQBsqmrBGpu/ecff9DfsPdxgrQNl5g+sdzhq0d2J4X0FZi+mcAND3PxzBp9KK6XbPsheQHENEUfF9hx87ussRN3bNMF+TYyTMM9PtdJy/vBodV/WP7G7fce/ecj/+CtVvCTGKsIhMDplaC8MwsDZhkHeOznvmZZU2OpCVwkMz45eP0SEOtNbK0HXElGQcQGlyOnx6FDFFGl6UfHhaSz/GR4P9lFAV4pq4XxcuLzdtXrKwrIHNZsAYzTSvjM0rVc4tYrOu6+i6jmVZCTFyc3PHxWYEKoIb1VFgRIV372/427/5JX1nxHEAuVGyxjD0A9M0sYYgiV2doy6Fh90erQ3X15csy0qtVdjUzjOOAzFmfnh/wziIP2iIkbv7HX3X0XedqPBbWlbOmWVZ2O0Xrq62XF9fHr/G3jv6oTua3X/z7SFV7lznOte5zvWXrj+rNf+SX/z8OoWbTznOp88+IzWB+pGwop8wcFqOE6YvSdhn6/m4bfzLtZ4+dCpaerHU09f25InSnleoWsQHcdmxfP817//+33H/2//A/OEbKBnjHOPlhmG7ob+8YLzc4pryvGpYHx5Iazgm4tRcUGuk5sJ898CyWykxybG8tMfH643MfmpJzwHNOi+EKbA8TNSmLvZDjxkcrrMoJTOlpMSyX6hUaq7kJDOKqf0yLzmRYyKElbAGVHsbrHNsNj3DZhSP0VyoKHTnME5jrYICNcvsgLYGv93ih7H5mlZKTsy7hft3H5jefyDOs+SSO4cbnNg4WYtGWDgaGHKdQ/cerQ05JmoRP8t1N7HOKzlmvHWgwfaOzRfXXHx5DaqSliAWUdqgnWO+2xP2AaMV/bYDXWXMIGa6MvN290+M+2/YXf0rHja/4nbKhJLYbEQcE4O0llPOLMvKdjNijGKeZoaxByqd9+BhWlYR3oTEsgQ240Chsqwr1hiUKpLZnkV8plAoLQBL3qp8nJtMWfxZrbFopbjYjmy2A7Wp6kFhneXu/oEv3l5hmz+qtYZlFjN+bQy3d/dYLWbyzhqyc0zzTMpFBFAtgME3a6khRP7h17/j7ZvLZtwv86lEcQG4vLwQkVKI7Pczw9A1hrUwL2Lub62hUpnnlWVdubq8IJdEiMISX11IElaMkRgjQxsr2E17EYSVynYjIxHTumCU+NIuYUUbzTTNOCc2Tuc617nOda6fp/7kiM+T5vXJn4cMozaHeDou+dpRniDRU1j7EsD92OTox+tUrHSKNF8/0muv8NVZz2Ob/+SYJ56lT45RXwe0L6dDoaZAXh4It98x/eEfeP/r/4n7P/wTYT/jR89wsaUbD+znJabrJJYzJWKLfqylkEM4mreXEFnud4RpheYJ6juHvdjSXW3pxx4j3kfkXAipEKeFdbdQU0ZVMNZhh6Ep5LuWU56I80JJkjcv5uLlaGOUcyaFQGyt6EOr1lonPo19j3dGFPWdqNkPvp/GCciU1rvBXQy4iw22H9DeU7IY6E+3d9x/9475wx05BLpBhFHGGlHJGxHoyP8L2jnc0KOVotRCWTNxnYkps86SCqUqWG/oL3vc0DO8vWS8vjwmMNWUyL34lWojRvbdvx7YXd5z9833pNhuANrMY60Kd3HFl798y9Uv3pBU5t1D5T98E7l5SHTbDSVX1phwVpT087JimlVRjBFjLNO84L3FNNuig9p+XhaM0UebJaUU6xpE0GQtoTGfRmtyqS1zPdB1Dq00awriAVsLve/EQqn3R7GhbXOT9/d7aq3My8LV5RZjjPil1oKz5jgXqk2zR8qlGcJrBieJTKGIsdnldtOEUCKCUkW35Cjx+FTITYpqzgOqMbdaK1KMhCCJU9ZqxqETH9gYccYfAf1+CfS9iLrEVUDmghWKceiY5pWbmzvevLmklsyaEr6lea0htkjU0uylznWuc53rXD9H/QV+wr4yd8mjZdKTzX7sSE9mM5+3xRtDeUJi1lcR7Stzlq8uQHEKGz8ahalOgfbzY9WXoBqOzOYLVvVECS+goSmXcyKve+Ld98zf/gPzt79m/fAdNa2oUugvN1x+cc3m7RXDdiNMnlbU2gzNY6Q0RTZGBBzGb7FdhzaG5W7Hcj+D1nSbju5ixHpDN/YoFCkGUqikNbLul/aytTCJg8cOvZzTih9kiZk4zeTYwGUR1X0phbiuxDWQQqSmLAwpbU2ttW6MwVqH9cJ6KmswzkvspjECOqgoY3FDjx83R+/MXCvz7R3TDx/Yvb8hPOxkpMBpfDfIOo3BGRlBKG0+UvUe7UybL9SUmAhLZLl7oFR9BI7WebqxZ7ja0F9f4EZR3ButSc20XmuDdR7VyfHjujI97FgedqS4kmPCdZ5+O6B9z+arr9h8cS357iGg7h+4mu/4X623/P6msJZfkTbXzNkSaqWUSkqrJA0BSWuskb/PyypG8YjRvXUWapUUIn2wJfLEmtjvZ7x3krZUafs143hnqQWWZcV7YY3nOTCvMgcrAqMe1djxzThKiEEppJQILU3qoC4XY3qJNU0xCzAWFy1yA6Axip2UUmCKwXtLiIF5nsm5cHV5QcwJow0JMMia+04Y067rKEXM/g8jCYdwgFIKxojvqTgEiD2W2DZpuUlqn9Hr60sO4wnvP9yw28+MQ0/nZUC26zTG6hYJa35Ss+Vc5zrXuc710+qzgejTdKL24I/Qk8e50FPi8JRUPPx5guaOm3/MGurJ6OenfkPIyY9LPaQLHU9Yn53/Jcf79CyPCVEfVcvX57xnffrXBj6plRJX0vRAvH9Huv+W5YevWT98Td7folTF9R2ue4Pre4zzx/m6Y5u7tb9zMzpX9sAkWlw/oJ1DGUVNGa2AmskxtfQiLQxqSJQGGoWOrQIKrZG87kFmIMUaKhFDpKyBkoSBPbzeGCJhXliaKtk0Y/MKKG1wzmG9FeW21dLOPsR5dg6qEvsdZ2WOtRfzeGOd+JmuK+s8s+wn9rd3LPc7cmvvO+dwvQBzpTUKAUDKGLSTKE5tJYkJjbzeNRKXwHS3I60J2/X0mw7bd/SXW4aLDW7sjx/W0phcZYRNo3l6rsvCdPPA7v0HppsHtAU/dHTbCy6+ekO3GemurjDDQF4WHt59YP/DDfff/cDuwz01R94qhVtX1OVfM2++4v1a2SXDEoWV6zsvYDTn44dfG4U1/mgrpI3BmspuP1MddF7GOnwT+tRSG9Bc6DphPLXSDJ1nN82UUrDO0vf+mCykW468c9JWzzFKaz+KWKnWSkH8QJWStKhx6MV4v81gOucwWhK0qGKNZExHzAWtm5gJjpZNuRS5PSyFmIuY03uPd56UFkDiUQ8pU7UevFObwb3RoB/HbrQRJJxyOprgx2YDNQ49V1eXwugqYV0lYhSmZWEchNF1zvLpnzPnOte5znWuP6c+nxEVVYL8/ekfT9vODdTVk22PiUUfBa6PYO4RLj5nOU96/K8KnB6P8xRYPh7nc+I9j/Ohr6z15f712XP1+PofD6geAU1ciA8fCDffsH74I/H2W9LDD5Qg85faWvrLS9xmwHpRR6MgR2lx5xilxd1mNSUfvcP2PcYLwDzY3deSySGRQ6CEgDEKYztKRVrla2jsEmhrBexaAylBLRJIVDJxF8V2KeZHoUwppJAkMjQlwrQwz6uIjrzDdx7rHDTGzHZybH2wECoFbQ3Gy3mVEzN828tr0dZScyLsJvbvP7De3xPmhTgvbQ2q5cs7rLOtRS2gV3nJNTfdAXwaSkykZSWHKNZNpVCpdGNPv93gx5HhcsQNw9EQv9baZokVSlWq0ihtSSGwPuzZ394y3d6z7idKLvihY/vlW7ZfvaW/2uL7HqU1MURuf/e1gM/3t80SK2M0jF98weaLN2wuBvqxp5rEzRT4+ibxrnTcFEdMovYeR1GL6+ZnW1UlF2n9W2MYhp6LC82yBmJKR4ZysxFAJWMRYpUk1k1iKzX0ncxnZlHnd51vKnsjllU5450jhECM7cZHawyHqFIaEDQsywpK/GGXJWGMZhyH9pmtXF1tgcd0KGstMcVmyyRpWv3QHdnpWmoTdtXjdy825r8ibKm1kk4VYiIVcSLw7TMhkalifh9DxHvPPM9HEVLnPb/8xVc87HbHWFVrDS6X5vkKtfmKnutc5zrXuX6e+gmt+VMfyxMI+io7yAlgPOFSK0ehURupfKXtdQruDv8+HOE1JPschL5s07+I/nx+hNN1PJsDfcK+Pu/6H0D302W358UiqcRAenjP8v5r1nf/RPjwR9L0gRpmAWTO0Y09xkt6kO06lNGkEFl2ewGgIYnYSBWUNtIqHwZc12GsRRkBYiUKWK1Cm8n6a6VQj/6dNWZKiqB1A7CS2lNKpoRADvH4Ykrz/mwSbUpLNlonUbyjJA2o5Eo/DvSj+DC6XkYCShZRlWkm60qLCAtnMZ3HdBK5aXwn3pVGk0IQ8Hl3x3L3QGiMXUVYum7o0Vo8RY11VKVBG4wXZlQZSQPSRrxR07wSHsQ1oLabKecttvf47QbjO4yz6Ab6qbT2fRubqPLywzwzPzyw3N2z7HaEaUEpzXh9xeaXXzFeX4uC3zswivVhz8O7Dzx8/4Hl4YG8rqQoowrOCVi6uBrZvr2k24zknJkfHii3d1zeT+ioGbngwV5wp7dMi8IbS8oJ5ypD3wMwp4V5XdBGWE5rDTFESSEK4sHprRPgZjT7aWltbiceom2GNqcipvJt1rTUgneONQRijA00JnkNNZGtZhh6bJsTlXHezBoTm6FvllMJY8Qgv5qKa6MSAjAF1OZcsIMIj3b7GaXU0Qs1te+V0ooUEt45nLWElCRato0oaHNIdQrkqhg6T4WjLdbRMkop+r7n/mHXggECxmpJeMqZdRVP0XHsOXyzFbA239lznetc5zrXX74+G4gKmHvGAB7nKF9s3TZ6/uQJNape2Z6nmx6fOj3Oi00/zXK+omn/6HaPx3veZq8n/21/ezITenIUrcUs/uEHpm9/y/L9P5JvvyHND9S4UHMSEHS5xXqPdh3a6CZMgbisxGWV9ntKEqdpFK7r8S0RSVr1jWVNibQcwFoBhCEqIUpcZBD2U7wiwfgOtxnQzkAp5DUSl7W1+RMlC1AQMCYCHxTCSDY2L8eM1tANHtd3YOwxD75muXEQm6Vm19Pat0pp3GbEbTbtNYC2Tvwwdzv2N7fMt/fEaRHVvVIYDdaLqEZxYChBO4vuPNp5SXhqDGCJiTAFUnz0Qy2pCAAde7qLDd04YPoO1YBMBZSzMp/aBFK15cEv88x8c8dyd8+82xPniO082y9/wcUvv2LzxRtsS26qYWW+f+Dmj99z+833hP2ErtIWt0bjrG557AbrLXmNPHz3jntlWNfA/mGHrmJ3NFSFywvX+Ya/6i75EK/ZqbeEonnYTSzLytB3DH3HbsridRriUWwj7J4lhkQtAsr6zjP0wg7mlMXrs0gyUoyRnNUx6tM3oZDvHDnJ/GWtMOcVozUhyPk243DSvlYMXUehttZ+Pn63tFFHE/zU2uEXFyP7SWyY+sbMLuvKoAQIagW5VDqjxbtUUg0Yh4FVi2JfzP7TcX05Z3b7SeZJawUlsaRjEcV813k677i72zEMHe9++MBmHBib3+66Luwe8nGExBjN5cX2M36CnOtc5zrXuf6U+oliJfXyny9Q3mMy0eud8NM5y9eGTR/V98dHnjGar4vYn57ssaF/AMwfmfx8tkYZIzhp6x8nAj4GZ5UwkqWQ9ndM3/+W6Q//ieX731Lmex6FS5VaMrUq+mFkvL5CKS0RgiGwTpO0OkEiMhX4ccD2Pc47jHWYvj+yrHGeSSFQYpKZP2epOZPSIgxqSM2CScCxv9jiBwG9aVkI9/fkUKR1XcRaCWTeEFOpNYvYJxfitIoCPCaU1nSbXpKTvJNZVCtm86VmYRe1QhXJIKcWlLO47Ybu8lLAt9JUbUjTnuX2lunDDfPdPWGWJCdRoovlkhitK6gth5yKHjv67Uaue8pQs/iXLpFlNwvwbO+4sgZ/MTJcXeIvtwI2SxKUY5wwsUpYN3Iip0CcZpZpz3z/wHy/EwuqIOzu23/9FRe/+iXD5QWmk/Z7KZU4r8wffuD2D9/w/uvvWJdm5TR09EOHMUauhVagDTklptsHCpVaYJ2D+KZ2Dt97nFJ4d5h7nLjKe0K84dZc866/Zpc1MReshb6TRKiNt+we9jhrmSaZ+8wHZXqbjzRWt1lIsWFa1oDKCeccOWdiFPuj1CVyyTjjjhGjomoXOzCtBTzf3NzTectmM+I6x2YcmOdFPhMKYswUrdBVVPUpyYwmFJYlcHWxYT/NpJwZN/3xy6sQ43nfkrGGviMmifLUWjGOA+saCWEFZCa57zypRZWGNaDaY8ZoUkysq3zGjTWUKuD6IHr67vsf0Frz9u31UeS0rsIGnxnRc53rXOf6+eonANHn85CtXmEoa2MwTz3ZZdvWnj9lFD/SNT+EOP2IHuoTqz2ZKf3IeV4Dys9Z0Jd/byMCTYxT1pnpm1+z+93fsb77J9L9e2qRxB9jDcrZJqwQAQ0V5ptbas7YfiQtEzUleU6Bdo5+c4EfBox36LbwgrCSeV0o60rJWZgvIxY+y90DcV5aC1/LHJ53dNtNy0635GUm7Pcyg4cSBjULM6Y7J5ZLNTcRCDIjmTOqtfi1NfSbnqEpyUuWtB2NwnqDQlNDoGpFtQ4zbuguNvixRzvfVOyw7Hbs3/3AdHdLWiSPvZaCpqKcwXcWrY0AdUQQk3MhtRlZUwVAe2fI0yym+CgUGq00ZhCBVXexobu+xA+DMJZUqBmsRH/qNjesaqWGzLK7Z7q7Zd3PpGUlTgspFUw/8Oa/+iVXf/s3uK7FpDpHSYX59pZwd0tu78m4HdC/+pKHuwe8E6GWMpqDl1nOiWVem6VVRWlYQwat6ceebmjtfcRkvpSCVpp+0Gx7+KXd8a/Kwu/2Pe/LNSlbjLHs9xNd5/nFL77g7m4n+fG5kLLMeTpr6bwXb9ea0UZSjg7Z7LnI2IDWSjLfUyaoSFKpMaY7us5L+147YhSrI9QgYrVmIJ9SZuz7x8x2Y47K/K4J5XLOoGCaZrTWzSZJRG8o0KayHcejPVRKifuHiDYG74RBN81D1lpLalZhtGx4rZsfRi2kBGGNlArj0FNypvcdzsu4wnY7klLGOsfDbs9uN9F3jr4Xg36ArnOf/4PnXOc617nO9ZNK1c9R8AC3H74//v3Te5zAx1PG9NU2/ukGr0HO+vKfT9jWlws5xHgq6ssh1BczqfXVZb1yVAGfQp1RU2S5+Zb91/+R/e//I/HmW0pYOPiIliTMpu0ctm+xgWsUYGqNgJLml6itxXQW1/e4vsc2kYsGsUUqheXunrQsAoCsafnqmlKz5LMvofkkCmzVfUc39tjOSVu2teZLrTIDWgpaCegjF8K8kGIQJbxSGKehVuK0EtaEsR7feZnds0aurRGrG7Hp0eJyUKUF3l1f0V1fYYehPQclBMLDPffv3vPw/oY8iem8Vkqy2LXCWo32DqOkZV6KiN6q15RcSXOk1IoquSn7W8u++VyWlDFWM1xf0F1eYsaxvekS7SiqeiAXOHis5sx894Flv2Pd70kNUFINbrzg8m/+mvHtG+wwUnNCIW4F6929sMrLIq18BTWXFmUaUfWgdaoY7whLYHrYk9ZILaLAL6UQlowfOsaL4ShwyinJKIUB6ztsL/npNQgrHddADoG5aH5Qb/ne/QI21yzLysWmRzXhkFI0u6UsM7VG2D/vhRG9vXvgzfUFpY1iCNMpNzEpJlIWx4VCbYKoAZBEpRAiIUSxUmpgsBTxPO277tiWN0YzTQtdA3fDMBytuB4e9jhvCSHReQcV8XMN61E89Ob6Cqq0172TOVWx/xJBUtf5tm4lDGkUpb81unmSijArpsR2lKSnnDO73UQtlcurC+ZlgQrWyaiCd473N3eEEPnlV2/JOfPf/V/++1d+Pn1e/diM+rnOda5z/f9rfQ7E/ElipXbY1596BvAO4qSPg8nXW+XwtPX+wkv0cMzTYz/7QX9Ujrd9T3RFCPisj+r45xzoCxq2gc+SiPc3TN/8Fx7+6e8I739PWWdptSqFbgxUyQXjhGmyvYNaKQXxnVSgiqxduQ47OLqLLX47YrSDImxkiZFlWcihWSsVMF6iCYuq5FLJ64IqGXJFa4v2VjLZBy+zdWEl3O3INEAXo2xrFcaK5c18uyfsF2pKR/9OqMQpUwt0Y8/11TWqCqBBG6oWcchh1lEuj8b2A24zYofNUXhUlSLOK3G/J017Soo4a9leXjC3eVjXebyzqFLASGRkSDL3pzQYb1EZ3GYQO6pYMLpHK2HytNZNeOXpL7f4fkBpI6xsmxFVDSyrIkxv9Y4UAvP7H5g+vGfZ78kpoZSInsYvvmD7xVuGy2t0N1Bzoq6LgP5pJ8lNzcWglkrVmhICNchogWoepkZDDIn9D7ess0SFrkuUWVkLzjv6t1vG7YAfJY89xUKtmm4r+fWgSCES5ySjGLU0oAw+BX4R/oBbfs9u+CX+zd9y/1C5uNjQ9yLYySmTW7u6Frn5WZbM5cUFXef5/vv3/OpXv2hMpWTXe6/pe0+MmZQTnTXMy0Kp0LV5UO+Fdd7tp+MNCoinqPMO5x3TfsE7h700zPPCugasMXSdKONr+zlgrRFQHoUBvtxuqMCHm3t2uz1vrq8aGyvjGjEKSyo+opm+8zgnLhMu2KOd07pGKpmSM9O8kFNmHAb63nN1pfnu+w/80+/+yNXVBmcNYc3UCp3zXF9dsK4yLrEdzzOi5zrXuc71c9VPYETf8bG5yqd47jnD+QxIPqlnIqBPLeVkdvPTDMNLQHv4x3PJ0eOK2txqA7j1sH0OxN0t+z/+muWb/8L6/vcy94mSGcPyCIS1NVAqurPCKJYDe5raGeQcpu/prq/pr66OGdy1VkpYCfuJNM/indmy1m3XUTSUKHOfKMBoKJkSkvh0bkaMlTnVmkTpXnImx0COGdPU4jlX4rqwzjNxCdRcsd6ijUJVua65ynmH7YgfOgGxWeYNTedBaZSSuVvtO9xmxHe9WCUpABlZSOvK+rCjrPPxOtXGyKZlpZSMVsJSVgU1ZVIRIVRpAikxwbcN7Jr20s3xvdPa4Lcb+jfXuHEQ8Nt8VpVcXJmFFBULtWTCPLG/uWW6uWG5l7EIqsIMAxd/+1dc/uIrunGQj7Sou8hhYfnhPTmsoqRXmhrFGis38FRixDTv0loKMSTm3UxYVmgemSGI9dHF1Ybt5QXGW1H8O1Ho5yjtZdt1GGcEQB58T9dIjYmqKyVVeS5G1mUVo/2YSdqzu/hrdm/+Fn3xBeI82jLljYwtHMDmZtPTec/Dw0zKiYvtSKUB+2YUn3I+As5KZZkD0FT/vjH9zerINucGo7WIl45jOFK55KOaXyuFb9nvKWfGoW+q99gSoRx911GBH97f0Hux/1K10jdGVSlJihIAK1ZLvhMhFjQmtLG0xhictcyrMK1933F9dcn9/Y79fmKaF95cX+KsZbefmquB4/bugZQyv/jFF/y3/6f/7hM/cz5dZ0b0XOc617/U+gszoif1vKP+6nlee/BjrXReMJHHFvvJY+qF2v71U7yY8zwBl0/wsTrdqlJzooSFNN0yv/sD87f/yPzud8Tdjaipq+So11rFVNw7UWxbLa3f3MBuhFoL2lTQGuM8frPFbTe4cUA7Ty2ZkjJ5vyfsRSme1oi2WiycrBE7nKYg11pL67CC1hZlrcw+tkjFnAo5iEq+UKXNXoQdjjmRliAzpiE0S1iFdgIatZWkI201SouoRLdYQ+ub/2cDdlppdOdb3OeAcU4U5g38pnUlTnvyPMt7qK08HqSdXJP4paoKqTHAVSmKErU/RjdLIQGfWhtqKqhaJZnJaFzXYYee7uICO45oYwWEFwHc2jmBw1XM6HNKhId75ttbprtbwrSQ10wtRWIkraO/uKAbtxjnZOwhZ3JYSOGOOM/UFFFaUZKMGcR5EQYbsa+iNpZ5Wph2E7T5T9MCApTRXPUdw0ZmH6vWyBsksZW1GHTnOYjrwl58U2UuOGGtgzb2EWMSgBoTpWZQMuM7esMv3wbGX+xYNh3v1o6btec2wroG+q7DaBmn2O1m6qailDgaxNa+PwBwY+QznVImxIWL7SjRmSkTUyaEPdvtpnl2ttSrBl67zkvSVq3HhCNn5UYihIjzjmVdmeeV7Wbk8NXUWtTxSqkWwVq5vNiyrAHfwgRySjwsK513OOek5W96AZT7ic7746hGCOE4nx2CRJ6Ow0Apmf00N0unkZQzt/cPbMaB7XY8vo7NZiDExLKuP/JD51znOte5zvWn1k8SKz2BkU8Iz1fmPF+0uF854hGEvtz/BYvwgkx9PMEjU3rCsZ4s9lEcJYBB5NRNBJQjaZmI+w+ED9+yfP9PLO9+R9rftjlTERmVUiAK8FDWYDoxY5fZwAotk11bK0DIueb32eP6AWOtAK6cWe7uifsdaT9TY6TmIgDMt2ztlClxER9O30k6kDNoZzGuxXuWTE1JWq65yExhFaW6tG8TteW8pyDnUCDAsQIt/Ugbi/cOtKIqyfc21jT1vMJ0HmWcGOL3Pc536PbLvsREnGbSsoiFVAjiUZpry5Yv5DhLFj0yD4qxFMTCJ9dy9PfU7ZxKSRqS8c38XilwWtq/40B3cSH2U8aBFhFQSbHNAx7Sryq5tf6X+3vCwz1x2lHae+Scl/e2ShKS0pq6Bna/+z3x/oLhzbXcdJRmP1Tlo5PniRwzMcrspLaGuEbiEglLJISAKkUEVdbieicJWX3XPEZtE3hFjHb0wyAss7bkmIjTRFgkIjRFYY5rBT94ShIf2BBzY0ETuQrQHS4HLr96w5tfvmF4c3X8XH/pV97VO36nKnemp2hPRnxDaxXgmIt8drJNKGUlEtVIq72mJIx5A6SitlcQE3MI7HZ7NuMgkaqnqvtVQHtMCWvFAumQUiTjHBVrWqb7GqhVPpMSNVqY55WZla6xrt7b4+iARoCtgMxyjDnte2FYQwj0Q7N/MpqUZV5Xa9OM7DPWGtY1Mgwd1lp++YsvuLvftZZ/bsc9iPZ0Gzs417nOda5z/Rz1+RGfr7Xj5ZnPAp2Px3gFtH60dfXKgZ8c40nvXY5fn/37dMdjxGYhzQ+E2+9Yb78lfPgj4eYbwsMHEZ/UIqxKS9g5qHSN9dLitKaxbQJCtdKYzuM6j/UdppOEINvJL9ISE8vtrbRyl4XYMsuV0s36SFqztSRKbGCqVrRz+E0vc45tnk6iNsMxX75kUZsLMyeg4uBDSikcvDeNa4CgImDPOWEcDWgUykiikLHSwsVI5KYbN7ihF9ulo1djIs0zaZooy0JJYrgPLcGHJtpJIhIy3h/b0zm3tvvoqUuA3NZUNdY4WVcTm2lncWOPH0fc0KE7jzIWlHl8o9vdh0bM53POrPs9080dYb8jhVXYPWrzDTU4q9BKGNSSCtopjLfYXkQueZ4EiCtFiZEcooDdIi3xmjJZIa3xaWWdg8wHH5T/xtBfjAxjj3HCLuuW2a60ZthucJ1HW5kBzTGRp4l1txMLq1LQVuM633wyMzGG47xnreA3Pd1mw/btJRdfXNJvN2hrKFUJoN3tCfsJN838bci8peehvOXBvqEoexTFOffIZiol4xKlJRnJDGZisxlZl1XsuFTFWsPV5ba15RNxWhrIVM0EP1JyuylqWfBKKXKS76B1ovK/aIxqykXez1pF+ORktGIJq3y3tD6a0s/TgvOWje3JRT5v87SgtJIWvlYcMuhds6+yRqykljWJkFBrnDOsjTEVRwHHOPSsQdT5XVPsl5IJ4WzfdK5znetcP1f9aa35Q9WnzOOTUs+B54udP/ckpx12nvbUX5v6fGQ/G0+KUppaM2XZE+7fNeD5R9bbb0i7O2oOlJAEABgtYhMag6cVhioAqdLAY2tbt7a77QfsKK1qRZtHTIm425FD8/ycFzSIqKgTC5qSxT7p8IqUElZSaYlzxGqohVoVuSIxlWuUVneMGC1xiso7ckrs73fyOtoYgbEa23LetZVjFtSx7W2cxegqXqK5NGtNJ4lLnWSvm65DIYboYT8dmc8cgvidtvnBnJPMWypoaBdlxWMzhXhMeFJaN5ZVYVLBug6lbTO9l/lU4z2+AVA7ji3jvcpsbJsrVbUp35FUoLSsxGXPfHfPutsTm4+kah6kSssYRc0y86q1Au9kxGKQhCrdbgqokq2eQ6BEaeEfxhhiSPIetLZ8XAJKQb/xlCzvhx87YVoPgFqDcRbbSeKUbr6zJQVSSKwPe2m1pyRzxsYcbyxqkVnfFJO0ub1l8+UbLn/xJePlBuv98ZqkEFju7lnvH+Sz0hg+cmYoK37dsTHv2daeO3fFvrsmaSfjCYhDQ661xWPK5yg1C6nOS7tdoTBatRAGYRZ1u2YxZGwDjDlnqjXkLEKpAxhdl5Urf4FScP+wa9ZJFtcU8ZthEDYWmOaANRZjNLFGrB3w3glAbIKplNIRfD7s9nz15duW9CT+rFSIqc3AVkhZHAmWZUVrRYxJgGgnLL815onfajmY/J/rXOc617l+lvp8IPpce/SqHdNzcPkSbMqv5k+D0KPavaU5PZn5PAG3x3z3g7XS6VqViBtymAm337P88Dvizdek6QN52UNcyClSUhF1dTOFP8zsqdbkLTLGJ+3ZImDIDhv8xVbsg4zB+A5lLTVH4u6Bsq7kZRFVdc6SU+5EdFO1EvyeCpoMaImpbL/klW8pQVUAXHiYiFF+kZMzqoE556X1bzuPdgabC1jL/P4WXUsDmQbbiRhJrolkhNcGFLUqjf206M7SDT1u6CRy01jQmkwlTzNxFtU7KcnV1wa/2WI6T5x2pCTWSjWVJujhmGFeC0c2WqGw1aAK2G4QAArozgmjPPTYNnuqj7OUjc08pDTVAloiTdf9juVeRh3yukrCVBWhk3bS/iVDTQK0tDMNmBtM12F8mwlNhZyiKN/busXWSEBezpm4RpZppoSIaoDSeIs2VjLvlTrO0taYsOOAH3pM38ucaJW15RhZdzt5j2Mkhiwm70rSrMK6UovMGZecKSVjjJa4VOcYrrb0Fxv8uKEqJSB8nQi7iThNzWe2kLM4LBTBoigyfb7H5Tve1HvKNnDXveWH1bEUK9vn1ARFAvqdc8QUKaUKe9nEP77NJRvdRkqAmLOwlA18bjcjqW0HNCcExbqubDYj87zIrOiysBkHYkws88LQi6reWbGbur19oPMO38ZGrLXcP+yOoilhPFUz4w/NqF7YezHCT8SY6DsPeGFgF2nxl/Zd2O9nfEpYY+UYud30oI5eq+c617nOda6/fH1+xCcfZzifPvxK6x3kh/rnkqCtJBLwyGu+ImZ61qJXkrySw8J68z3rD//E8u63xPt3lDhDjpQcZfNmZK61Qh2slVRjUZC11lqgiMm8HWWez28vjkBJ1SwpR7t70jyTQxRhkVIoXQU4YaFkVM3CzKZmv0NtivkChyhEZyWyc40iqEmptZsLzlt832F6h2ltat0EPiUmVC4MY48rF8JMGvEixTRfgHZtUJBroqJRQ0d/cdEiKkWsJFGJSnwkpwcZASil2RJZlPW4YdOEShalDd3VG0x/w93vf0dYxe9UdEPqyC6jFEYbtHVotIwNWAFyfrvBjf1xXICDvZZpqnlqi+vUVDIprA2A3rI+TG0GVuyJjLNoNEpZdG3jFSW31CIrYrEmvtJO2u9hmolzEJumlOWzpsXwP8SMypDiyv5hT5gCtnNs3lzTbTbkZaaukQPMrrXSbbZHW65Di7+WTJr2rPuZMC1N2S9t8JJrm9eFTCUlTUiBg9es8x3auuNrqyGx++EHlv0kKUDrSsqJEtpnz1nCulIKaGU4fIu0FfP4q4uB/qJH6cxf61vm3vHHyfL73HOT61G4ZK2Ma3TeSbu+3QimlMQ/ts3wOmtZ1xXvLLkUWYM6MIn1aOfr23EOAQXDMNB3He9v7tBG05uOmkWMVZrTgmnWTg/7iVIKFxcbuq7He8+yrmKGj4wRXF9dUqrMdx5Y2sN3fQ3h6E2qlESX1lLpOrnh2Qy9WDwhdlA5V2KKDH0nNxfnOte5znWun6V+4ozoR5DkaYv+dHb0yTanrfXTx+QX1dP2++GYj6xrhWfxm+0JfbBJiqw337D/4z8wf/tr8v495BVVhcHLIcn8J+rYHtctpUU1kFxzglyoWVLbTdczfPmG7vIC572AOS2rzPNEuL+VecwkOe9KyzxbVVBKU5KnjKagagNnRqGPq2+vpkrMZ3zYEUIipXLMZ7dG47ylvxxx44Dt/DFSNM8TaV1QReYStQJDIVnV7IuEoTv88q20DPLNBf5iixsOfpwy8JpTZt4tlByAcpSCoRXGDvjNBtv3R/sclCYuK7t371hufyDlSM2VsASUE09Oqw2+axZA5eA4AP7yiu7iAtN1otCvMqYAGuVEZQ40n1ZLNZDjSppnlt0968N9S5IS4UtBGG1hKEV1X2ISdtTLrKnxHqVVE3XJ7F9JrQWfi7z3BWEZY0QZAYrrw8S0m1vE599w/Te/YvziS0w/ENeV3bffs75/Tzf2DG8ucMN49KqtJRP2M8vDPXld5XqaSgmVvCbcpsfaQp4WchLgfvnVG1LOLPsZisI0Sl5ZEftoKwxgXWZyE94dhHVxbTcOpcrnq4J1mn7bM2xH+u2ItlZmXnPC5oBfH/ireeGiOr5TI3/MF+TuSly3UmYfI33f46yl6MKyBlG/OwuIuK7rOpZlFRFallz72CytSqmklMlFsxlHYow87HY4Y0ErLi+3GK0IIRFakpdqMa8gEaaHzPv7+x3er3Rdh3fiJGCtZbeb2O1mrq62zWFChGFGG0lbajdEyyLZ9sMogqZpWri42KCNYbsZCSlRaiXGKCEOxkpq07nOda5znetnqZ+mmv8sy9GP+Tk9Miovj6tO/i5/vuz4l5NdFRhDzZlw847p6//C9If/RLj9mppDY6Forc/U2sPlyISYzotHZKmoqtBVAFt1mlQi7mJk+OoLuu2lWClVUdLWdWHdTQIAl5VSpGWsrEEbT8mBZb+TeE+jZaa0CKhV+gCq9FFElFJm2S+kNaAO1yBndCmYFs/ZXY4tv12LcXoK1KWIdVBOmGYnVUo8tv1N57BdD8qiVGtJW4/te3yb/5S40UytlfVhR9rtWhKQFhDgHLrrsN2IcR4DDfQL67c87Nh//x3L7R1xvz+6C6AU3dihbYfyDts5iIkSE9pZ/GbEDT399VtMP1BzpASZZ9TDButsYwJ1Y9IKcdkT15U8T9D8R7vtJShLnoU5NMpIUpSRWU4M9OOFzKNqqEWAbgmRFFMzUxdPTkwTcoVETquY22tNLYplt2eeVr7813/Nm3/9XzG8/QLtxGUArfHOc/W3hnTZoZWRG4Jmpr/uJ/Y/vCfc7eSz3eyRjLOYscMrhfOWHAJm6EW45hy5yOdg7PsmxsoUJBBKWSNBCUVuHsRSKjE/zKy7cNTjlSoiHeMs45tL+uZbWnOW8QNVSRTCfpFRAK3Y6Mh/bT7wV9zxXdzxvfmSXRHBz/7DLWE7Mg6DzF1G6SxYayhaoYoAyrv7HUbX1s2gMZui0leIpdLDbsJoTTd2POz2ErvZ9zhnsUYTYsJaKzOapR7b+ONmYKOGY6oTCMtaa+HycssaAnd3D8SU6DrPl2/fMAw9pUpu/Dj2jGPP/f0eozVzWBnHgWVZWZbA5eWW68sLcs7c5Ay1Ms8z03y2bzrXuc51rp+rPtvQ/sMP377+xEc68c2s8sh6PnkcOPbrOJUfPZsePVo0Pe5TK8TpjuW737D/7b9n/vYfqWEvzJ+1AmEPHp1tN62VzAU6gzIW610TsbTjNz9Jt73AbrbYfhTxRlgAyGEh7GbSfne0NKo5t9m7Qk2JHCOUJFYxRzZPN6GUeJQelPJpjay7PWEOKG0xVjVxV8F6R391IW1d65pJfZTs73mhxIC3FmXa3GpG2u9GS9u76zCDqPVrEhZNVOdDU43LS87LIn6fOVHWcFR0m85j+gG7ucT1PcT42EZGsdzesXv3PcvtDcQox1SKFATw9xcjtu9kDCALS4fR2M7ht/JcrVVSnoxlubtn9+GOWir99RWbL9/gh/Eo5hHGcqHUlguP5NuneaWuono2RkzkU0y4zYB1GmWcsKDWkFMi7ffCoLb41VLa504r0LT0ooUUJWUKDX7o8eOW8c01m1/+EuU6AbQosJa6zuRpBzkdraTQEsN6+8fvuPnd79GlYn2HMrq5AAwYb8nTgqKgjaGkJFGcuQiDXnWbY5UbLnSFEFHWC6vdXB2q1s2iaiItsc39yhpc3zG8uWC42gpwbt/HGlfCtGfZT3LtnLDRcQ5yTYrMiapayXbkXdnwu3TFTbLM88r15Qbn7DFLvu878Z01ukVowjSvR8uj0m4ASxUj/JwSIaQmfIKuOQMopXBtrlk1IJ9SZhwHQozs9zMhBq6uLo6CovuHvcTDGo13EiFakRnolBIozeXlBmsM87KSc6HrPCkmfOeByn6/MAwdtdQ2Syos7sWFpDvtdnt++OGW//v/8D+8/vPvM+psaH+uc53rX2r9fIb2p/Xaz9gDwHxtAYcfyrU+lyE9Y0sfRUiSyLMwv/uGm1//O+7+8X+CcM/QS6xfMaL6LrMARw4pPICyGjv0Ym/jLDVmaaMrRU2Zai3D9VvcOGK6XoBjTqT9A+H+QRjIWlr7nSZkEY/PcmjpIsyMck6EQADGohprW3MilypikiWQDyryCkZLUk+3Gegvtg3EqdZ6l/PUmlE5YWpCa0PJUeyOug7lNMpq9NBhlKVqhTYWoy32aoN2Hu3kl26Nq1gOPTyQ11nAIlBzRhmHv77Gby7Qzh5nZuk7ws3C/O471vsb4jRJe98ZCpaSqsxmaod3CmucAFAy2jvcdsAOQxO0KPK6kkNkvX9gvX2Q9rPW9JuRvH9gKpF8fS1gsaY2UiA3C2mNLPd78rSKu0Fj0KutdNue/norgrOD1CwXwjwT54XSMt5RipITKQuYw2p5PxZJDVJG4S9GNm/f0G+39NsLucGplRoDKCMAeXpA3O2TzKAqhfIepS01r/TXV2xrpTzsKGvEbjr8ZsC0tC3tDUo5ikL8YBeJk3TOHucvq9Ho3mOUohovs8BUqtKEJRL3i6jSY6YitkjdpmO4uKC/2mC8a3ZaMqO67mfW3Y6chVXWVrfPdmpuAaBqwflORhhC4Bdl4jq/485+wW/9wC4GdLNTKkXEStYadvsZkDECZy3LGug6Ry7lqLqvpaK1QanEZuib3VqlthvMUiopBqw1DEOPNpI7n6Kww85ZSU5y4J3ji7fXTPMiIykNDGul2S1iv6VRzNPCMPQoYF1XYpt5TiUdze0fdjuoCmcNfe/Z7SfybUYbUdH/1S+/+Ek/Es91rnOd61yfXz8NiH6E/Xye3f6y+/56q/6jp6nNtmadmd9/x/3v/zO3//gfWX74PZRVlOrWsdpCJYvFTi4UwDqL7UTk4vtOGJ92vtK8EHOSOcza7IdMv8VuL8jrQpon0jSx7h4gZ9lfa0quYl/U7GKc0+2XamM82jVRh7EArSkpE+aZZbcQD/6Q4q6NMRrvLcN2aAIai0KRGlCD2gQ4zaaoNmV/ZzD9Bt2sgGrOYnjvPco6rO/Q2mKcASupR2ldxLR/2ssv/lJAy+uy1mHffIUdeoxW1Jgo+4WcC3Fd2L2/YXr3A6om8cRUGqzYRaU1oxFTfGNV04VUNAq/HbCbEeO92ADtJL40pyy2QksAFMPFBtt5GScYB2GrSxJT/pRE+FQq8V7YW4XCttlBtJjg++2A671c2yJG9CEE0hKPIMs6SV8qtZBohvpzPIrBlIKLL6/pLi8ZLq/w40Zmj6GNjhjxZo17ShJ/y6q1uDM4i/Yiaqm1op1n9J5+M7D/cEN82Imyu7khoKBYLwbsux06C8taMihd0b1trgW0G6NKSeK+UEoh7PakRaye0OB6jx86hi8uGa6v8H0nYGteKSmTYiIuEzEsMi9rvYC+JULNoNyRdS2loGKEWinN9J6S+KJ+y1ejZ+q/4Fu+4LZ03O4T07JwYbeMQyeioCg3Wc4JC3lIa0pNAKW1ZhwGQhTv1UMSUoqJdQqEKN8vVMVZh7OOmDKFQt93gKQzifixCgPcvvcxSALZZhy4ubvn6nJLKZVpmo8/tEqR1CQVFdnn5m2bGfr+aGA/9ANAs4fKP+ryca5znetc5/rT6ycyoi+R6Cnr+fgDu56Ik57i1vrsUYV0NKmS7Z7mHdMP33D/9T+y//ofmN/9njTtpIXtDBgxrbZWY7LEQxpnsGMvKuyuo9uM0vlvaUgpJipisC3KdlGwS6SlYv3wDpUDqmRhx0qFQstmnwXkxizJLlodgaa2pl3CKrOgqRxVuyUkScYpBY2m7ySFSRmZUz14V8qoYm255ZG8CssqCmlEba40OIvr22ynlYhPbQ1m3Eg2eVNWK+uoKEpYSQ8PpGlPmvYNkBlp3fcDZthihxHXzOZrCKQQCNOe+eaW/bsPrLtdSxCyaOMoFVLI5EkAoSjaxWxfWY3vO/x2aDOUGgoNNAkLzMH782CLNIhPqRs6rHdtPKGKUX9K5KVluacCpQir6hxqkHhVbQVMa91ARgwybrDGltuujyb8MSbCshKXlVwSGHOcSTT9wHB9xebNFdb6pnIvAjRbwlBdd1Dy8RNcNSjr0NajDuC+FiqVvEbCwx3rbo9WGmf10b4qNVeEtKzUnNClUJUwu+Lh6kE7MEYu4UFlHhNxDseZAuME2Pqxw19eMLy5wnauJTfJDUzOEm2aUwAn/qaAeM0mGROpRfxyK0nW0a6l+OeKKMpYhRs7VAWf79iqiQd9wfvthvdJE9ZVfGmtIbb5za4JfQ6z2kpBKgVVMqBaO5xmSl+42I6UUtjtp2Mr3trIdjNiTfMjjTLCoJTcSKgWRVor7TstIrplXek6Twjp8QaxyhgAgG83zusa2Iw9Dw8T67JinCXEJOxtLZTmzLGuZ0P7c53rXOf6uerzgegrs50f3/bHDtZU3LVS0kqc7llvv2f6/nfsv/kNu6//ifXh9tgC9uMgUXtei5m2EhCktOSeu6HD9l7YkTb7l9ZESaJazzE1sZJGobG+Kbp7SUpStVKm6Zgok9dICpEcEilnXEslMp0R1bsxqOY9WZuiNodAXiMxtpQa5Jek9V5a1L3HeCeiJTH6ocRECpGSZdYxJ5lPtJ1vBuvNhD6VZuouc6faOmzfNeP5XmZJa0uyWfekZSbe35CnWWY/rcH2o8y/jhv0uMF2vbDO80xaF9b7e5abG5b7e/KykkKQ69/30uauGl1qM93Pzfhc4b2l63uZae0cgBju7xdKTEcLKpTMsSotgQHGO4x36L4HWmJRY9NyiKRVUqMOIifXORFZ9R3WNkGQUjKrm5KMPyyBuKzi0ao0RUmkagyRsCwskyimjbM4axmvrxmvr8TCquukbZ/EqB6tqSVRp0XiVJuVEtqhnJcY1zZselhDToH1YUd42FGSJPTgnLx2VSihUFYJAjAamXtVutlWCYuv2kytsko+T/NKXmT+FqfEMguN7TxuHI7WV4oqNzHtc5SnibiKl602qt0oRWqVNri2DmM0JYoQL6dml3RwHZDZCFSpVKOOBvG1VmzNvDX3vO1W/vbiivcYvrsPhNrjvOd+98A0Lbx9e9USt+RnRmhG8Vpp1kXhrGNdV7TWrDHIOI0xjNaQUmaeF0IIjUXt0UazhnBMWhLj/SYkrJL4ZJtYTCnN/f1OLJp68Q41prbYUUtICdsM+a8utzzsJ8mYT8LiOmtbslLBu3PE57nOda5z/Vz1Ewztn/bjP9FYf/L8k72aQXRJK2F3w/L+j8zv/sD++9+x//4bwsMtZGmvOWuxzmCsxGDKDFiLqrQO5cVX0bWowpKE5UlrINcqv2CjsJvKaAGezrZkG5mjVBryshLmILY3WbLPxddToa3BeYPtHKbN1CljoRQBqWFthuNQ2y/0ij6Ko/zQYzqH8V4YLIWYpkdRbpeU2/+F3bHGoTuP8b6xraByRjuNHUds12E3G0zzNlRoSi3ERZKbclhlrnSZoRaUtdjNgBk3uPECN45oL44Bcf/AcnfHcvOB9e6OOM3UnNH2Mc9eWslino9SAioUOD+grMF5ATNaC0sbJ3EVoMj11+29Uy1lSTk5tunEdkehyCHLexZWapBWeUntxsFY7NjhhgE/is1TbVZhqqnkYwykaY+q0pY3xlCaICzFldqM6HOMOGsZ3lwyfvGW8foavxlFWFYOPg0aNDL3eeLjWY1YZmnr200Iwo7WNuYxzcT9jrS2EYxcjqAbBNyWnNGIL6YySjxSc5YkJX2w0MriX5qrMM+zpGgdvDm1tbje0223+M2IdY6qoK4LKYrYKCwrcXp8/7VRR9usij4mOx1mr2sVJ4FaC6b3x7nRWuQ1YGTWNseMPlwjJSxy/+aKL7Yjf4Pm7qrw/X7hw+pQybEPlWleMFo3ZbvcuKSYjrn0WqlGmFZCiMcoTmsMfdfhnG3JTpWUC7mE4w3sugb6XrZRCta1zV0XYTKdVfS9Zz/Ncq5DWlUVMVbfeaw1TNNCbN6/07JgtCHF3G5KpY1/EGad61znOte5/vL1k8VKh1b8Y/pRe/xV1ZJ4MioUNa3Ehw/M73/P/rvfMr/7mvXme9K8l3ZpkhlIY/X/j73/XJIsy7I0se/QS5SYmbOIyMzqnpmWeQE8FgSCx8Gb4EUwA4j0DIpmZkQ4MaLskkPxYx9Vz0Z3Y6KqMn9Bj0hIV2eEu5nSu+/aa30LZx1GN9XzOkT2XhTGzjYVUPrGS67EaSG1NpoSRIWrpUpSe9PfLr7qOkxW5MIdE2leJEDUQjdaKxkenb0pmNpolDZywZwabglB5yhtZG1sLcZeO+cbz1LL0FprIU9r6ysv1Aa2r0qhrMUYg7Ht5znX/l7d1p1tjT/00kRkNOTc/KyLVG6meBu8FQrtOxlcd3tsP6JbCKvElfn5mfnljfX1mbRcyM0+gHXieW1Bd+skNFVyQRklA7hX2N6150UwVCUl4rxS8kycZlJIuN5hegGFay+Dp6z3jSiNQA4r8bJ8X9tf6y2dwfbSsKTb+r2RlmSYsU7CT10nSulux/r2yvr8TFwDcQk3JVa3qlTrHcPTA5sfPjK+e2o+Wi3VpgVqCdQUG8+2NBUPGSZ9h1UGXCcDd1lbuGgmTs13m7KoojHKwNh31GZjLVEen9IGM3QCIYsVg5LVfy3UGEU0VOITlZ72LAO31litcZtBIPnjIDcqpr3/15XleKRk4XeWnFG1UHIlhUXCetcaULQwaGMU5bitno01mK4XpBmgSqHUJAN6Ea4uRfBTbren329xfSdM2/YY3g+VIRzZXSb2yvLSDTzngSmLz9JZe0vS55zpvGNZA0sI7LcbeR8lSaxXKrkFwMTbK98usXlYTbsxDSGI5aUKGUNrfWtRUoNiaIGotXFPx7GnlIIzMhjHEDFafLebjWCh1jVgrWZZI85qur5rA/j93M/93M/9/C3OvwJo3y7OLZCkrv8n/8X/cVvDKoE3kuYj85d/5vLL/8b0+Y+sr19ZTkfICeut1FYqcE6q+2znRP20Bjd2uL67DZGgmrKoyCG1ATRQs/g3aylobbBOBkm/HVq/uISZci6UkEUtu8y3C3GtMgAbZ7D+ClPXbeVaKEGR80xOiZKrrOmtaStXhekMrve4QZTMWsTnmFfBLZUkrT+itjXV1FhZszYwvOlc45FaVOt7t10nIZhrAr9CvJxIxwO5db7XUqhGg7LYzZZu/4DpB7Tr0H0HxpJDZP7yK9PnXwjHMyUEtFVYrVHek2NCldLg9waqaoEmcL0MwsqJP1VphcqJPC/EVbrYW40S2lv6oUP5psQauZG43azkQp6DDJ/LItSCIjgl3TyvdpAh1HgvfsWGNLLdiNuIKqwa1F8GVEl7pyjr93VeuXJFTdczPj0wvHvE7XZik9BGbgTQlBAp64xCmpcoQhCo2qK7TmwUvm/DFlDF5hFeXwjHE2ldBezQSAUC5pd6UGqRm6KYQSmxW2xGdM6kLL7jFMWXXMQkLRxX9HdimVLYoW882R22lyCaajxZsQEcyOuKajdmqqXPa+VWP6utacrjVcFdSK1r3W5GTO8pCkhFlGUxllBKC5Vpgx4Gtj98Ynx6wijxxAqWTLBXy+GN9XimV4offOCpLvzUzfy6dnyLPUlt6VyPMVL1CdwwUNM0M26GWz1rSpmuMzeShoTAvjczadOGzphY1oB3XoJ+UfihSSmOxzObzcA49hijWRq+yTawvVKqcYAV8xIYhp6H/ZbYWpm0lm2DVpp1vSui93M/93M/f6vzb0jNNz6ouv0P38+1QnK9sH77I6c//mcuv/w94fxCWmbSvKI1jNueYbel22w4ff1GvJwxzqOMbV5K22oYDYa2qhVpkjDHtoYWD2fJpfnaDHbbyzq8rYNJ+QZqr0W623NKokZmWdlrrXCddLIbY9pQkyS9HgVsrptKo5XGDTIkS4WmEp+jdxhvKTHehqycRJmTjWuV4IzSKNuGayt/7xX/pDsv4aGuw3Qe7brWT29Jy0p4/kyaZ2pYISdBOGmDGQbcZofZbG+BJbT8vnG6ML98ZXl5Jp4v5EWahKgVZXvCIughTQusNCXOdB43erkpcBZjLNVoSpThKk2LcDxbpzzWYFvgyDgr/smuF6W21TyWEEmXhbzIYF7ae0lbhe0FTZTJGKVvvFNVQHcj/qGXcJLituqP08Tl8xfOn78RzmegSKq9gusHNk+P7D59xO/2t0FYaUd1nrIupPObWBGUsDpl/jKoXryI2ll5P2sFOZHDyvp2IJ1P4vOsooJrZ+X9VSXIVrJCXVuiapU62M5hjEIVGbyt97JCXhdKyIIba/YFaoPRb0e67bVGVTBTqheY/PL2xvzyTVRcKzcANVVK+zxobTD++wqeUsg5UlIhrvJ6iGWkBaJikpughlFCaVxvqdWhvKd7eGB4/x7nbfMLS+gsXybm11diWFG1CB6tgkYxGENXA3555UOC1/LEr8sDdZRAWCqFse9QekNoAULTiBMxptZmVG8MztTsGs57hqEnxiQw/avt4MYkrrL6L4UQRGG11tD3HWGNxJQY9hvxllZpoNrtRk4nYRHbZv8Yx4Fpminle1r/fu7nfu7nfv7659/GEf2L6k2R+RQlziwvf2b6+T9z+pf/zPnLL+S4opWoDsYY9h8f2T4+0I9DU9c0/W7D8ZdfKTFI53lLYlOkcjEWQdfkLCESAbw3z5q19A9b/KYXD6dRLdWuxa94OBOXKIqQMzf1TZRJ6DqL7a8985qKIq6BtMamRnmkkFOSy9qbNmw5+f2VasU3ifXtQlqDNC6lJD/TtN50o6Wrvu/RzS9aWsrXKoXbbCS9Tm3KqQU068uhddiv5OUCsWFrjEEPW7r9o/g+rUW5Tl6HsBAuF9I0Nc/ixHo6UVKWdqI1YrSBElrtZkuqG7BD37yoHuNk8K8pksJKXBNhWiGVFhQC5QzaGbRzAsH3TuCtBcq6kCvEaSHPM8TSgmPNt9s5MJpiFHm+kFfx2KYQMb6je3onCiZKsDpWBtS8rkzPv/D2p5+5vBwaLgrQCtt1PP30gYcfP2K7oZETMlgHxgv39XyEEm+w/aqaX3PcyOo9R6CgSqKiiXMgng7kaSKHIDWgVLAOM46imrea1VKTDOe1guvwe7mpUCCIsSAEgBxban4tko43uinHCqyj34243qKVeG9BUbViObyyfntmPRyxXooZrtuAnFolrJVmLGqlJlEecxaVtsjE3Pro5YbK+A7dDaiGTFOoVjhQMEPPw9N7TCtDqDlRlplaEuFykVatJUp6vbdYB7lWUhJmbg4BUwoPVvGgvvIxvfC6PvHKR16iJdeCM1ZA91kGQ2stTrn/Iqm+GYc2T4vN5YqHug6rKWfpjFeifK4hsC6B/cOWsK4toOSkVS2LwmmNudWUpijp+pRlGI4xkktms9mwrAvjOPybvibv537u537u5//4/OsG0es+vq3eawqsbz9z+pf/J4e//19Ynn8hhUkS1tbQj55+s2HYjfiua+qaDCA3TE/JjO8fbhWcJWZpEUqZEhof9KpiVhkG3diz3Y648dpTXkXNay0zYQ431M0Vc6PaqtNYi3VOVpAalHOiToVIWgMa6ebOSTiLRosv1fZGoPd9D6imyErzTwkrcZpASUDFbwdqknWv9T2mH1BdJwNMzhKm8E4U0L5HOfFB1lIISyC8vUkv+bpIo1EMlGVF+wG32+J30nqkFFRjwXnSsrC+PBMPB1HKtPTRqyKA8jVOaGVwfWOARhlSjLf4/YZuM0pIyTmxFmRpI0rLSo5ZBkRncYOX17FzoocXbit40kJdCikrckzy/LQQV2n+RfGLtq76BqXPaJTKdPst2x9/ZHx4koBULWA1WvWE+cz521dOnz8zvZ4IswTFjLWMD3se//CJ3ft3WOdlwCwFXAfGk0OkzEdUTRJ4wkGJVG3QXY/1vSCYlnNrSIK0zKynE2G6UGvzKiZJgOuhl4KC06n5cr+TEKqqYgMYesE+RbFlCL3A0e+3TG9HyjS3sgUn6qt1uHHEDQ0dFOItuV5qIby+EY9HNOBbT3pcImGVwUtVaVPqNr34LJN8jnISJVQetyjfyii0s/TvnzC2k4rVOaJaOj6FgNs/0n8QvqysORLKaOK6MH19lv+/1fhNR1qDpPtBkFvz2qwOBWPl81NyYadhzwt/UBO/1JF/Ouw5+w3WeVTjeTrvGIYB5ywhBJZFWr+M1WKtaSzY8fbfxBauqmgvHfNCH1DY5r9Gqeb9NDhrcd5xvkxsNtLgtYYo8Hot4amu60gpEsJKDPGOb7qf+7mf+/kbnt9c8fnt6y+ylsuJcPrG5ef/zOEf/1dOP/8T4XLB2KYdVuh3W/YfHum3I9Za6WPXWkIIKRKXGVJCe1kjX7EyMSTCeaassnanSpCiAtob/NjjBwmpGGdRtZKWwDov5CA1hXltSh+AVmijm6dT/kFpQQoVWYnmmEVd1bSqyIYSqpVu00la2zmBm+dCDLJ6B0nol9TSvtZRSoPLu4Zg8l7+XLMyaGNxwyDcT9tqF7Uk8ZfzieOvX7h8fcZ6zbjbYLSh1Irpevz+kW67E5YqNOB4Ja6BcDwSjidqCljvqUqTY5DHmSvllvrV5DWQYkR5R7/b4Mf+liiWkAptsFhYThO1ZIbdBuVMa0iyNK8DWkkYCCXtOCUkwmUmZ0mAX2tDEViVsDdV82HmSimSZva7HbsfPjE8PooqSb0xReO8cPz8mfO3Z5a3E2ENrGtEO8v26YH3f/d7Hn74KGva9jj1uIV+J+rdfPpewam1/O7GUCm3MJM8nQLCT8tMPF9aa1YFSqsBlVV9zJV4vlCzrLhVlRID3XUYVbCdkyYrbaSZqo2o1ntBZxlDrYW4BuaXN8Iy47ej2B9KkVW71SjrUMZBjKzzhfXtIGq0FRU7zIH5PJFCxHmDca1FqSn5nbWkIDYIpUWdv3pwu90W4xx5kfIEbQWanxprtWTZHNhhQ//pE5unR0qYCW+vhNOFGFbhnlp5bVNILJeZdVoxWuF7g/G+eaoLuoH5rx4JZS26Fo7nwB+fM2+7v0O9/4mMYl2k191ojXPS0OSspdQqHtFGEfDe4Zpa7LwTVThnrJV761oKMWbsX6CXcs639XtpwUTnHCFE5mWh7yTE1vcd87zgveDILpeZ//P/5f/6r/1uvZ17xef93M/9/P/r+atWfIbnP7O8/JnzH/9fXH7+e6bXZ0rMKG2xxuAHz+Zxz/bpUTrKyzV5LKzEHAJxvpBTEo5k30t6eo2EllxP8yor0yLQcGM1futFibRGLumtxz1eFpbjhTAtxDXeErbG6gabt/ihwxglKfMkzM4rn7JqTQozTktISSF92MoZ+u2Aa4EYqvAZw7yKwtcGEJDrquu6NnSAd5J+L1WhrEf1nbARXSdeQetuF6UcZD27ThPT2xvr4SB+V2uxvqNaj97uGfd7fN8sC82ekGMgnE/EaSIvqwQ6jKZUK+iZLPYCpVqa2DlhYaaM3/SMmydMPwCKWhLkSE2ZGDNxTdI4VauwO/1GhvFBQPWK3HiahhoiJa43v65YJypGKYrS5JLQRgJhpXkm660MwDFsRjbvP9A/7tFO0s+1YXOWw4HL8zfO316Z3s6kJGtj4zue3r3j8Xc/sP/wAeuaIo5Fb0ewTkJcb9+gRJR1gBErgfegrRAPampBp0otQk9YTyfSPIk6WpGQjpf3QUqFNC+Qk4R1WshM9T1ut8WQ0e3x1QI1ihovffeNJVoquUqQSWuDf9zBWVNDIMRZMGW9w9gOZ4QtSqfpx5Gwe+ByOHD++QtxWSmtD74bJM0v3epVmsVKpcYW3BuEcKCswT/sseNAjaLmC55KkzOkkIjLQo3X10kTLifSHydYP6JKJl1migJjnBQ3hERcI3FqA60xaKspGEhtKPRibant5q6UwnqeWKfAdLjwDvhwmZnqK2/jDxQ1UBuxIZdC5x2VSpgDKSW5WWy4J3lRIaYk2xKlb8OmQkJRlXprQ+s6L+QMrXl5eePxYUOohe6GipLfcVlWsQs0ru/YFOj7uZ/7uZ/7+euf3zyI/tP//f8mmJgUhfPpPW7X0+83jPsNvu+lDrMKq6/tKylZAkIlZqrWaO9JITE/n0jnWVAzVSDotVRRyB5EiXQNWp9zJq9RciNVEaZZPGgxo42s2rURO4D1VtA/SgbQWisJzbok4rKiKlhnhOnohCWqrMYNvfy5tlIsMZDOqyCe4rUq0jRbgqhWxjpByVhpV0JpsOJ5s71UXFrr21pUCXQ9BNbzxPnLV+bDCW0Kior1FmU9frtn/Piefr9v0H7VkEJS1bleLsTzmRrDTVm8Mj7jspLbACKeukSGBoTvsA/iWaResTxJFKYQiUsQELzRt4CMtxrlHKb3oqg5AxjxXTY/ZzzPlJYq1k5U3kIl10wmywBcipAJnMd1nv7pkfHpHd1ugzKC55HnJrJOE8vrC8vLG2FdmC8rVWnc6Nm9e+Tpxx/oH/YY3zV5FTBW/lFQwwSxqXzFir/UaPnvXS8honJFE0mN7Ho8Ei8XQERq1dLm1TlpqLrMqCIBpKqkylR1ku7vd1v531uVprGiBlrvBcDf3tuC/yrkkkhxJa/Sba+pFKWFFOCMsFNtz1U+1trKz9SWkiHMC2WNgjTr5PGVUnBjj7UKjfS569ZGpHuP221xm1H8retK1aYl9RvuaF6oMYrvuZUjaGdw2xHrNNRms6hF6A1AugSW00xcBD3VDUK3yDVBSahGeiilkpe1DbyJ+TixzIFcFc6JP1urym7+wq4ciLsPHMxH4vCey1oIuVDhNkTWWkVxR0JdrimgORdQwpF11koLWoPbO+duPRy1VmKMbEZBO439QIyRNYS2oND45lnVDV+m283v/dzP/dzP/fz1z28eRNfjK0ZbxscHus1Av9vQDYOEcrQELWppHq5SoWYJrRRpJ0oxkaZIvFyIl4UQ8k1JxVjc0OM3PW7opAmmCu4nhch6nkjLCrW1GdUCSuF6AcZrLXWd1jdPmDGEaZZ0d0yEOUoyWCMsw9r4nZ3FDR3GC/6l5kyeVuKytDYmGZButaS1YJx4JFHS8iQIJg3GYIZRKiu7TlibXtK2MugJ4mZ6eWU5XVC54HovA2vv8ZudeD+3e+E+lkJJgbwmyroS54kUQlN+oChNWGYJ/+SKqkouxI29WhvQ3HknKf1OfpeaRP28cSdTplYEjm6aB9KZG9QeZyVRDZCLMEo3u5aMP5GD4JhKyiiqBJAaqL/mTLEG03m6zcjw+I7+4VH4kwpq1TLoTzPr6chyPBBXYYvGJUCFzeOe/t0ju48f6bcbjJcBorYUeClFakjFIUAjorcWLdfCPrQQTqaWJMPlNJPWmRqlRrQivFrtpF6zVCjrSo2r3Aigbn5iM3YM+10jDQjYXhkjPuKhx/adrNWVFr9uVZSSyWElhVUCablgegkb+cct2kkwTqn2WTLygNZ5YXp95fj5K/F4wVhLt+lbk1bGWPkMKWMwSHJdmJ9SBuB3W0w3QLk2UFXKX9SM5kX8nLo1QElphJXHIG8p+VyvgRwLeY7MF/lsqSp2FvGWigfYGoMb5CahgqivUZ73ZQ7kUPC+o9R6UyCVsXRjT7/t6brED+ozh+mZi3vHm97yPBcw7pZoj3GRm9OUyTlhnaPrujZpyqst6XlpX5rnBXMdzJt3upRCTJXzWdLyWl2RbDTwfcEYh9Fa1Ob7uZ/7uZ/7+Zuc3zyIPv30A77r8BvpJ1dcsSlFPJU534aioiokaRyKa2CdV0lPhyTwd6PwQ4frPf1OLtzGWGzvJLAzLZQovfBplmFSVUWpGTSYTnA+0uqDXIBa4Cisk/g4w7U+UxRH0wYi18vPNW0YombKKspnbszP1GopTeNzKuQCrRDAeM1QVRV8j++w/YDpvLQGOYf2HblW1uOJ5XBkPZ2I57O0B1XQztPtR/rdnu5hj99tsb6/KZWCgJoIlzPxeEJdfYotcBLnQJpW0rzIwKn0rcmntgIA4wy2d+IPREmNYwiUeWkWBAmOlVxbj7tBG3cLoklKXQvH1Ans3o6b5nMUqL6xnhIS8/lCCCsqa0lf14rSBj+O9E+P9I97hu22gdU1JRdiTMTLK+FyYT1fWE9nQfS0oXh8emR8emR4fMTttmgjfsDSYPJpmgRnlRNmHHGbLcZo6TI3DtX1KLQosg3tJOrmJK9FiqKUOodRhmokRFZSooYgQy1QjWk4owHtpatc1UINkVSb+qgt2lsBzTsZCmvO1CRhvFoTpWRJ1Zciz6uT8J7ujaC6GnLrihAN68L89sr09Zm8LJSQ5DkwmlQyCiR40zU/KogNQWn04HDbEdOwQ7U0T26SHvq8rMJARbUCAylQuIbRdKM9SLuV+I1TyqyXRdbwrQ3KNLSZthrj5cZOK/m7qtLEeSWu0iJWiyTirROfZ40JNzh87xi2A7731Cz+bOLCNgb86TM9I517z7HuWUqHHbYSZCuVXErDMMmT1nnHGiK+4ZtSzmzGgXEYJNDVKBcozTC4G/zee0cumZSl/tM5GUDneUEphXfur/Ntez/3cz/3cz//1fntg+jvfhROYhFwfE4yFFZK42Uq4RQuKzEkyhpYLyvrNMsqu618u52k3W3ncJ0A4EtM5GkmTgsx5oZ+ibJCb6xGe62GbM1IopjmNkAmcmrJ9yWSGjBbG43vnfys3ouC6izUIr7PZUVZuXDmVG4QcW1sQ6XWdpFuCptqwRTXCTdz6PFdf6vkrEBOmcvXb0wvB5a3A2ld0aZinKHbjvj9I267p9tusf0oK+OaG4N0IU0X8jwTG7ap5gJaVoQlXbmkhZLEEycoKeFMuqEXJVbpFpRBcEFr435e8T2dDJzi61No5xt7tRmLq3h/3f4Ju5Fgi7RTGRSVtK6E01F4lq9vpGURBQlR0/xux/juPd1+h+sHjLeyok6Zdb6wHA+Ey4V4OVFCIIYiLTd9z+bdE7sP7xieHrH9II1OWmoq0/lEOB3Jy0WsHij5d7PUk/rNRmpcu05ulNJCCUEe/7qSllV8yCULAF5bstJCCAhBQk1tANXOoK1DG4d1cpOhaDc8jdKgrcUOA9bKa6CsBI7yEiglUXNLvmtQrnW4V2So7weM82hjb0giSmWdLqznM/PxQDieoRRsKz5IsamvCrpBvKcKwGhM3+EGaRyTBiuaT1tsG2FaSJMo6DRFthQZNl3n8bsR13e3z5TcTGjiGlnPM3EKUKoQJOSDLxxSK8xVY50E5LJMhTktTKeJHNKt7lYpJV7boNhuB7r9IGxSreUzvEj7WGqKbcmZQR/p04Vd7bjogZUf0WZPsA5TDWtYySkRZO9OLoW5YZhyzlwuE5txFJB9ywyl5oPVSmOtqJ+13QQqJzt8126+jqfLfRC9n/u5n/v5G57fPIgqI17NUtqaqoVRS8wSGJqiMBenSRSQLBcG31n8ZsANHdYaSZV7i7aKWmA+it/zusLLWS4mxih01zHutyhjW8uJkv8uy4WjZGlJirMomrVUWcn1Htv772tpK15QSiUv0giUo/TJVzTGtbpO2oodhaot1a2gKOGH+s0G0/cyRHgvvlSlyCkxHY9MhxPL66H5V8XT6kZPv9/S7fd0D0+i3PlO/KS1kteZdDkT54k8z+R1gdavXbI0+aQ1Skr52hNeK0ojw8fYqjBVg7CX3AbzdBsoSoiytu9c8z86qdR0TelV4l8tSmGGDe7hEbfdoX0ng3jrVQ+nM/PbgeXllfV4FGZqlvDSsN/SPz0xPDzS7fe4rr/uyikpsxyPzIcD4XiUWsyWqgeF6zybjx/YfvxA//goVomrp3KV8oJ4uZAvJ2oUb6WgsqRQwPWjrNW7/ubnKzmRJ/HTpmUhx0huN0x27BvyK7amKzDXlXwWWLv4NUUNVUCNEsZSRgv1YNNhfCfKcQvX1dv6XVikIKEfqpYaV+/RymK0FbVSG/GeVgiXM/PbK2Ga5PWbVnnuncXttgzeMz2/yGDqPcZ5sEZW6cMgRAO5EyItC0obdOflhmuaSfMiN4wAiM/S9R63Ef6r9c3f28gDpQjCKq2BNC1QxGt8bT+y3uA60xqIIM4y7JcKZChV3hfd2Iv/WUvjk/WWbjPQjR47+MYEls9+KZkUAinI+x/M7YZpNJUHDyn+ibnueNM7DmpLMo6USwuzIf99KSzrwjAIfzSGAEpuoq21eO+YlwWtNF3XkYt8r+m2hs+5sMbIZhxxznCTx+/nfu7nfu7nr35+8yCac2opbFF1UlgJl5n5cGE5nEkhNZUlY7yl3430Dxu6zdBUOhqfspJjYn2bCJdVkEtZfH7GaFznGEaP772smI34vWoqrKcJVaqsip1tXMPvjL9SMrFk+s4y7DdSIaoMNSXCFIiLqCwKQaoorahROt9d724w/FJE5VUYTN/Rbwb8uME2D6iyFpQizDPT569cvnyV1XJIqJqlaajzDE8PbD9+kHpG38tgow0VJUPS5UxaZmqIggMqhZokiZxCIscovNbSKki9PG5NwXjfYPbSBlViJM+ifOaUgNLaqRSqc6LIaSVVngiUvRot0HOl0eOIf3jC7R9E/asFUqDkwny5cPryleOv38jrgqHchv5hv2fzux8Z333A953A1JWoyDlElsOB6eVV1M+cifNCSQHbmJrD+3f0Dw8ySFmLMl7Uz2Ulnt9Il7NQDmjYp1rRztKNG2zvMa61SSluDUnxeCDNk9SI1kqJqREeDKrvwFnIBWKAmlsDkUG7QYb5LAGra8FAbd5D6yy2Fy6s1rb9e+FapnVtbFIN+tpX30yWpaAq0qzVDZKGtx60Zr2cuPz6K8vbKyWn1rYl7FW/3bH99J5+t0Upw/DwQLhcyPMin7POY/tOBuh1bT5d1bCfmbCeyWuQKtOYyCFTgO5hQ9d5eTyDhNeolTRNN/xWRbXyiCQ1uQhX1zqLH10b1DXXOtiSCyW2G7rWb19y46fqFu5zVlTIzt1qekuMpDUR5pk4za04wqGyfAarNnQPW7HjOLEMbNTKPs5MHDj27/gSR14uhWUNjEPH0HfMSyHFSN/1UttpBKO1rCu77Zb9dssaI/OyYq1hs9kIWSNnYgPcn08XGUTv537u537u5292fjvQvlQqheW0ML8epVVlDe1ikzHO0L/bMzzthNuJrC5N68COMYtPdAnUXIlrpOaM7ay0q4ydXOCMaUEd8eHFUsmKlswuUqdpTEtiF7Su5NL4h6WirCIugel0ZthtSctEmC7kUrFakryq1f5hDV4rTKv3pgCGxgL1dNsNbhgFEWRlPV21ZjocOX/+yvz6Sp5m8hobE1RYoX7jccPA/g+/Z3h8AiSAUlIing7E6URZ2wCK+OlKEih4mBZKEjW5lIwyXtS0weO2A27om8/WtmBQIU8zy+lCuMw4Z3FjLxaGhrGqOUPOkqZvNZKyigT7+J5+t8P1ndRZ1kxdpdJyPpw5fP7K+eVVmJRBHqfznu2n92w/fmD8+Ak3jm3VScNiRebnr8xfvhDnqSXHC2ENcqPx4wfG9x/pdw/oThqlGi+JtC6EtxfS5QSq3uo+S4woq+l2Ymsw3bWdS1auKSzk5UK+TKQ5NC5obeKpxW08brfHjiNhnlleXm7BFUoVBJOzQiOoYoeoVYEGaxTWd9iubz9P1vl5XaTQoGSZOY0grcQHakSpNrZRDBr2vnFV1/OZ6dsX6YpfVmqzrwC4sWf3w0f67Q7beWGrKsX48Qe6x8jy9kIOC6bvqLmKWlsBZ4lrEhtGTFRK83o2vujY0z/t8dumVmekdjQnSlWEJbGeFsGIdQ4zdGA1OSSUUvRj1ywyEtYrreI1raK+u95ivGve8Cj7huYf9UMn3GAlLNvaFPG4BubjmRQiWkndqzSgiQ2g32/RffedQQrkkBh7y/v9gPaFJV349Wz4h5Pnl9NKruCdpaTM+XzBe09nBQ82zQspZfa7TUvXZ5Zlwbn2XaWUrOtzIcRIqZmhv+Ob7ud+7ud+/lbnNw+iz//4J5bTmTQL8ociF5lu7Bje7Rh2G7SRJiGtFTkEpudX8ppkdRZFidRGKiFt5zDd2LrhBRNUYpQe7+Zdy2uQIBTq1s1eSyHEhbCsxHWhpHxTdHLN9NbjO4eKmXCeZUi2HmdlgEBr3NDhrblhkWoDuSur8eOIHyXooYz0puMcaVk5f/7K4ZdfmV+PMkR7UWi0l25v6xy2hYYUiuXbF8FLjVvidCYeXsnLDEV4qBVNiuJrXS+zqEeNc1iarcFtN9ihx40e4zt57lOm1kI4zlJjerpQasZvR9zYGpeKXExJK0oh6/haqamCc3SfPuKfPoiiFmYZjKPURV5eXnn7+QvT24GSEqUolKoYZ9l8eM/jH/7A9sMH7FX9rMI3jRnOf/6F88+/oAiizEVRA3Op9E8PvPsPf0f/9E54nrkpwdqIgnd8JRxfb2UH2re611rpthusM9iHR1lpa2GZxtOFt59/5fTrL2hdGR4f6PpBHnvOuGGk2+8wvRflFIHYW++ZX76htbRt1RDaSluJL1UprBMribHm9r8B1FpI00US8AgvV1mLqn8RRGoA+Vpqu8mR92lcV7mR+foNVTNGces8t93A5v07hv1ebjRqFQKAdVSliNOZdDmLMu43gqLyhmotZV5ZTxfSZcZ4Kx7RKDd0yhuGxx3d5qo6q7aqTlQU61KYvr2R1yDvFSchtzxFlCoSRLIG47zgk0JAOSvkhstCnhehXWjxsc6nGa0Uw0684Ma7ZkXQhGlpFobIcrlIMCxluqFvqLIKVqwMruvAyGNXRpMaJmzYjvSbodE6YN9rHjaKv3u38v/43478fHbw8Am/2bDOM2tDTzlrGfqOECLrGvC+tsavwjLPdH1HrRVrrAQareF0uhDC+a/3jXs/93M/93M//8X5zYPo5csrKYpq0Y093Xak33T4zYC6XpyGnkplOlyY307EaZVWJG1urE+cpRs63DiiapZEcK6QxAcpuKUgfe3QwkNyQV+XWRSzWQZUpVX7R+NHz6bvRIGCW3pXNfUGreR3cK06sqk5IF5UP/TYzYA2EvbR1oHWzJeF46//zOFPf0Zr6ek2usrFtaGgTC8XW5oCZ2xLnRvF8voVczoATdUrMnSscyaGSFqCDBTQLvZWEFCbHjt6bCcVi8o0SPcaCaf5hrQyRtPtR1GptKHkFjRRCmskcKNqRRXQfYd/+kD3/j3adZRlol6OUAp5TZy+fOPlzz8zH4+iJDbl2FjL5odPPPzd37H58O6GLVJVGKbLtHD6/CvT12+ky1lKjKwlRVEWjZULu9USVsm5YkoUhM+6sLy8EM9n6T7vHGbcALRh3+O3D6IoqtpwTNK4dPr8lcO//Ew4n2RFjOLyNrN9v+fxpx8ZHvbYQQYWwQkp8d+mRJkn8QIbUShBwjlifxAPphZpTIbt1uKTVgmUlZLQzlDRlNCqPK3BDUPz1tZWtWrQxpLCyuXlmfO3Z0GRZYXpPKlGaqmMHz6w//EHnG8KNlUamlDkZWG9HEjLIhaGZi0oVdqQ5pcTZV6uoEziZZHGKK1xDxv6/YhWooQrkD+7RubDmXVaSYsMoNZLKCpGGZr94HFOQPwoRU2RdZ5liA2J0AZON4qKGdcWOvOOYdPRbVt9bVXSgHZZiOvSnhdFnALGgBsH+eyndPORG28xvZef1agc3dDT73ZY75p1gja4Ws5vRz7/47/gf3nhf9SGXH/koP8TgYHrRiLlgtaCmjqezux3W6yz9HQ4L/5XrXVTTRNPTw+MY0dqn8/7uZ/7uZ/7+euf3zyIaqsYxw3j047uYdO6wBtI/XIR7NDhxPR2Zp0CznfYXqo4jbcC6h47udhVCZOkeW1MUEOcAmkV7JJuqqBSikLmfD6JfywlClVW8Cicdfihu/XYa2Vv3j7VPJUV1aocG34pJ/GGtuSyHwbpEYeWXtbEELn8+pnL11emVxnKup3wTdOS0NpKa463Mqw0LIwkiL1A4L0DFCWK+qO0cBXDFJgPF8FKtXCEouL7Dtt3sn4fB0zfsElWPKVlXQinM+vhLHaInPAbj/VOQtA5U+JKLRnbOWF5GuGrmu2W/tOPuIe9JP/XVcDvJRNi5vT5C4c//8xyPEqjkhcPn+tHtp8+sv/pR/qnB1nrx+ZlrTAdz5x++ZX55RWydK7brg0PueJGLwO+95AllDL96Y+Ew5Hh6Yl4Ody62o1z2Ov6toHFTacxThRe8U9o4mni+OtnDj//Sjif5HVVMlxY3zE8PfLu737P5vEBRfNplgrIzy9R1LFKQfdS6ZhzY8x6jx1HTNeDNi11LjcuOUZSXCgxglH4cdPqYBO2FyuH6fo2nINSBuU0cQ1cnr8wH9+I8yQYJjTKig3Cbbbsf/qR8eFR7BgpIf4QqbXMKRDPJ0pKYg1oyK0cEuvxTJxn+T2r+Kjz1fPbWfqHDbbvqUluCK582bQkLl9fiLNQGUrJYs2oipyrrPB3I0ZragrNEy681RQKaRUPpdIaaw01SrhIOUv3uKUb5HOO1o1ksQrCbQ2igEvbAtogVhNAaUXfDZir6qw0pVWjal9xw5ZuM4hFKGe0teSUWS8zr//0Zw6fv5FDwA+eimYILzyeV/7w7ve8bD/y8zmRq0YhAat1iczzTDplnHPEZPDe45xjs7HM80Jo4St1jdvfz/3cz/3cz1/9/OZB9MP/8JMka4tghKoxVKVYLxPrUYJHteFius0oDEtncN5JxSEKXQrxOLdksnjXSkzkElrDj3jtYs4NoB0JIRBDEM2qQlWKru8Yxp5u6NGNv1grVIOs043GOVEkaxIzZC2yPjVDj+tHCfqo1oGehCG5ziuXlwPT8zPhcqHWitFGUsrGojX4fSfQ+FrbcCmPw1jbIPYOa2zr2UY8cSESLhNxXslJQNm+U+SSUNbT7Xfsf/yAclZ67BtcWynxqy7nC/MvX1FGiV/UAloCOrmWNkC3IaRW4rJifIfe7xh+FJ+qokJYqFX4rus0c/rlF05//oXp9Y1Soes7KRXYbRnfvWfz7oluuxVFsWRqKORaCeeJy+dfuXz9So0JYy16kNVrNQZNFR5j3zdFSzrHlROPLuvC8vVXtPeYvoW4lCTgTddjrbBbqZlrPWe8LBw/f+H46y/k8yTQ8VzJRWout++e2H36yPj02G4OoCZRskrJEl6KURR2a6Tv3DpqrhgUtmG4lBPWaW0qWF7mhhUKsibX1yBWgpyxXS8c0EZBgIoqlVyEFHB+/kacJwkvlYoxFuUcfrth8+ED/aapv0VUUKXFS1pqboUGi9xU2QFlDXlNrOcTy+sJUhZVttEjUiz4bc/wbkc3ymBZchEvcQzUUImxsL6dycvcPNUON4ivU2lNv+txvdAVakzUInSGmDLLZSaFgPcO660MsU29tZuebrfFdn1r3sotjLeQUyHGeFOIC0LbcNcNhlZYbyWolaS9SjvbanoFK2W7TnzhWqO9I4eV6Xjiyz/9zHI8NTpHL75gJTeaDz984N3vH4DEr2+Zn5eRbzNMq/y8l7cTnz6+o+87AeTnzDTNOGsxRpOLNDXZO77pfu7nfu7nb3Z+8yDqxgFlZaiKp5XpbSYugXKF1DuDHXthfvZOPGNtrZZXYRAWBbm1mtRcb4gnTGOQxiC95SmSWkK6ZFkzywBm8Z3He4/tnbQBIf3VFPDDgHEyNFGKhDG0xnQdZhxwmw22k8YYsiirMWTmw4nzt1fm5xcoSVBN44Ay4kt13jSWqKw2S5KmHWvdjfHIFTgfM+v5TG6/e1oTaW51jtbgeyfNNUNPt9vQPewxw4g2ohJF74nrKhYAK4D8zcMjqsByOAh2ySrBzKyJmqRzvGpRDE0vquDm0ycJiLiBWhJ5WUiXM+Fy5vL6xvT1hfVyRmnoNgPWd/QPD4w/fmT8+Ak/jqJ8ZmmvKSmznE5MX77IajpmfOfR21EER9UUZyVIK0H2VPHwao0Z3Q36T6ktGCUEBZWTNEttdmIlQCwOOUM4nTl//cbbn3+lLBPWihpdlKKzjuHhgcefPjHstzI8Vai5UFVDfEUZIgul2TLkZkZb3xRGWZ2T8y2VX0KS5yyslBhuhQHSB6tvwSPTjdhhAKAimJ+8LiyXM/PrC/PrGyXJoG60QXuD320ZntqAL0yjm3cZ5LORm3e25txUTEGahdeJ5fmNPM2UJJgpndqf7To2HzeMjxu00hJAKlJPGVcJGOal9bNXqdKtrUVJW4PrvHB7r9sI60gNA7Z8vTCdZ0osGIPglkJAGfFbd/tBAmtK2qtKDNR5Iq5BrBhJviOUalW+tQoHtb8OrUoqV5VguYx3mHGkGwQtpb1FOd9sLYV1Xnj75Qtvf/7MOotf9RqM1Bq6xwf2P/wg9auNJ/X7R82PeeHz68o/x8r88A5VMsfj6da45JzFNdLEZVpE7W1q8/3cz/3cz/38bc5vHkTnlyNFKdIk7SoUWX/bzmOcwfQOP0pdprGi0sQ1SsNRauu465CQy62iMAa54JYsne61VLSW1piCAqfw3tIPjRGpxHOqvWtJ47Yirwqlm/oJGN9juk6A41ffnjGUFIkpEy8z0/Mr08sz4XwSQLkz2M0gtYVaCV/Rymq21kpJlapFrTHei4Kmrt30kTItpJzJqRLmlRLLrTrQdh43SD+5227xe0lE0xbIJYlv1fgeY72EXowWIHqF/mFHigvLYYbQ2Puahgsy2HHL8OE9m/fvccOIroUSVxk+p5nLt2/i4ZxnwfwYUa5N5+kfHxjfvWN4etcUSid94iESp5n18Mby9szydoSchM869KI65vod+F9bIM1pqq4opENdOWGuXtmg19c+x0hZFmS8lxYnax01JuLlzOX5mfPnL/LcxiSFBN5hx4H+Yc/wsG83Hy2Ipiy19bjLGjmgdL35JbH6NmQZ5wUTZJyk4yvUGEnLJHYRI4MhShEuF4xzuK1UdxoriqFYjGVQTPGqVH5lvZwpWRBa1ktIqtuM9A8PdLu/GLZzbt5VaWHKKZLW9RZak+J7TZhXLi9vhPOEaf3nteRmWXD0Tzv63QZ9XXl3hqosOc6ENbEeJ8qabminVNpg5Sxm6Og2A4pKWVdyKdTiKNNCmBbCZRbChQKjrkO+wvUd3X6D34wY2/irrZksp0hOiVwrKcln2jkrn22r0VYJf3cJ8tprRQwV7S1+HOi2G/wwcFWItbXCWp0Xjt9eOPz6lfn1iNIV781NQfXjhu0PH9j9+AmjjGwXqqi+aQ3Mhzf012f+bo2s5Y2t3/BqO845MAfVGpoUFfGq1lrlRvO+mr+f+7mf+/mbnd/eNX+eRcGhClLGCybIdRLaUc2DWXImXFZRlWqlNDVBVmYSRopLIEWByteUbzY+pRTGSVuLUrp5OzXGeaw3gnay+hYkuVYTooqsypVCOWEruqExNqFBrjPxfGZ+Fd9neDuQUxAFtxO/q3VW+up1A8er0rijCmUMbutBy0VUtz7znAtxXgin+aYMxhCpSeDZrvPSqPSwxW83Ui1qpE2mpiQDi7oqruJ3vA7ZOSaWy5k4XYjTRFlnqKJyaWNRrsdu9/SPT/iHB/nfamnc1Inl9cD0/JX59UCcJigF42Ut7LYj/f6Bbrel222Fj6qUdHkvM/PhxPT1K+FwIK0zikpOFeuEE4lSjbEp3QaqVmqRd5QwXmX1bZy9eQLzupKjsCNLEQVSlSo8zcMb6+mCGQdpQWq+4JollNZtB/r9nv7hkeFxj+v7hkJqr29K1DCTFlHiaOqZduK3NM7LulcZlDUo26D5pUjffFgpQZp9lNGQq/zaSXiWbrMXZqmxKNfJe71k0rKwThfmt1fyNFFShAb5N/2A7wd5nve7FjyDdhshqmXOIlKWTE4JhVhKcoiEeSbNgeX1zHq54Dq5Qcil4PuO7mGL3wpeTNdCVYayBlRVrMvKcjyTpoWaC9YZlDOUIh5g04gMxmjyEojTLFYIbdrN5kycVkotfzEUK4xzdNuObrfBdB0aLR7RWdb2ONtYuRmUlkGuvU6qhaWUkjILsWNYwaZZQ/ewo99vcdZd71vRzlMLXF5e+PYvP3P6+kLNiW6Q7wQA2/eMHz+x/fBeQpBKQVxl1U9lOV2YXl4J5zM5SBObT9/4nX/jMWq+ppGDfWBhS9bb757rIkn7rvP/9m/Y+7mf+7mf+/n/ef4VzUoG2zlsL4OeuVYWlgo1k1eBhkvNX+aaE5FWxCKd89MqLSctPFKSwMK1NW1FKuEHbbQkqLUR9bNz+ME1L+F1YJMLmrK2rXzFo6mNQytZEZcUCevKcrqwnk6sR/GspZhQBanp7GzzYl5rPCWJLzWJ14uoERW072izOCUmUYymhTgtlCwMUWNa8Gbj6fcb+l0bQL1HaSWDefMT3nrilRKFTCmq0qzzynJ44/L8SjyfQX1/Mv1mpNvvxTv3+B63e7wpRnldWC9n5q/fuHx7lrrQRQYRpQ12t2F89yRK4m6LG7doq6lVUUsizBfi5UI4X5heD4TzhdxW09pprJdB/YpBopSbd5dWFWo7hxl6CcwY254ssWdIFahqwHhBB5UWYpKWrCPlS2pmYGlOcoOsfcenJ4anJxl+tITkSoq3Py9JdLEQVJqdw4sdQPyf3W2guoabypooNZMXwXwpoyAr4mWWIE4/YLuebrcXRV2BNo6qNCGsLK/PrAcJIdWa5cYkCa7K77eM79/TXe0gjQVKq5PMUViaKE2l3MoichHs2Pp2JC6zVJmmLKGsKrD3zX5DP3YY0z6+OaM6R6mGZQrErxICq7nhiYoMu66z+LEXZXnooGTS6UJeY2N8+hvLNofYVHdDVeJt7QbxENvm/aVUapE1fQyJFAtX8VluFIGim3VW3uM1J6kK1oJo0t5gu5Fut8VvBnT7zpDyB80yz7z9/IXDL19YTpNQOzovWxCj6fY7dj/9juFJfNAVIEaUMaS4Mr9K1W5eFnQW64NYaSBMC8txZlefedwemNOGU35i3nzgVDUVxeF4ovP3QfR+7ud+7udvdX7zIDq822K0YI2UVqicSWsghladmLMMAaXKGtboW6p1vkyEIMOG1QZrrQC2nVT/GWdF1WnsRXMdTBvk23QeY7WEmKs05Jh+wA4jrhdf6nWIrDmRpgvhcmE+nJhPZ8JllrRzlf555x2u63C9uw3LAj5XGK0b9L79v154oqaTNXxag1R4Bkn5r5cZcmmeQ6kv9LutDFB9J6gdaIB6uUprxA+njLsxUEsphMuFy8sby+EoQ+QqIS03dpihp396z/j+CTeIp1M10HY8H1kOR+bnZ9bDgfV4kuHFNCV3s2V4/0T/9ES/3WBa4AYjCtlyOjA/PxPP0sRTU2p4LOmyN0Y3tdjLgFBlwIEqNyhtsNFGN9SmeClLaraLJF5WIe6IAlqLIiepdLwOlCUXWS1rje46Nh/eMzzu8NurAsoN0J6jpMlzasp7IykoazBakFy26+U9Zf6CA3qt4ZxmYYAaTU5RWo+0bdtwixsH7DiKcqrMTRGMKbG+fWM9vkqdbRAklzJQyXS7LePjE91uJ4Exo9sAKsUPtbau+isSSgEZQAlj9PmV9XCWTUHJwtEtBTt0DA9buu2I2/Qy0DavsrKGOK9Mr2fC8Szeaw26Ngi8c/hNT7ft6TaiGMYgtbhpDd+V5VJu73ttjHTAtxCPHTx+t8F6J2q+dOwSQxIEVEzy87IEtWopGKexTr4vpOOzUpKsvFUVnNj4uMNvt/Le0ka8w9qQ15W3P/7My59+YT1N1JxxxtzUeOM79j9+Yvv+HXboG7ZMHitasZwn5pcX8rzKJsBacg7yHq2VeVqIS8CgcZ3FEOnLgXE6ETmwjO+52EdekyGkO77pfu7nfu7nb3V+uyKaEsoaapLVYFoDYYmtOlG3YUB6s9W6soaVMAXCskqFp1EYa3BOQNVKK4GJe4vtOlFFaWtdlMDBjfgkdavqNN5gm+9T+64NGFLdV2JiORyYX19ZDkfCPEnrUKnivwS8d3RDU0+NaV5FWWlqZ8TP6Syqk9W/dlZUuxiJ5wvxPJHb49VW6kilFEgxPGzpdyNusxH1Stu2vi6tb7y5QTPUlowGWe8u5zPzyzPr4UhchT5QUkZbQ//wwO53P9G/f2qrYY2ygkgKpzOXL585/fwrYZrE12pFVS5aY4eBzYcPjE8PuL5rQ5Wk0XMpzN++MX372oaX1Hah8poYo1BJlFjrBBOlqNQqNxuikHtsL1336po0LzJw5bxIb3kFkGBaqZUco/hEr37DksRvfFUx+4HNh3eM7z/Q7/fNXiEKOLW29HtooP3chqgqQRsj3mFjHdp6aU66PtNKU3IkrzNpWWTosqKaow0YITv4sUc/uKaa6TZ4Q4qRy8sLy+srNYcWWBJVHmvx25Fx/4jfbOXPWfudMFEEraWshZbAFluJ7J/TGpm+fhPlrgWESBI2Mn1P/25Pvx0xWgni6vretZUUEsvLUZTvmG9q/tUm0m1lALVWbtbS1Drnm3SZUsGojDH69p431pBWy3w4S3tarUynmZIr3ban326kcvdyYZ1XShYbirFWrCxW/m7jLdZch3io1jQkVWbYb+n3O3wnN3ogzyNGM70e+PYP/8L07YW8rGiBEUuTGsIM3v/uRx5++AFtNKWprUorSqpcnl+Ipzd5nFnYv1hNyYp1jkznNpy2prGqNaWCtYaHTYfrCqU+U+zEV7PhH4/dv/d79n7u537u537+O+e3D6LKEEMhzHO7uDafm0J8hUFW7yUlKJFSKikV6Y52VvrjO2FKWucEjWSEF2isRXeyutZF1neqAemxDu07/HaP7hy6+TVVU5pyCKzHA+dfvjA9v5Fy68Zu4HgN+MHhnL2pMzkXYm4DpXPSke6cKL7OoToP1hBPE+HtKGvKFiwxzlFrJseMG3rGpycZjjsnAw0KSqLWDErUI3VN3lYJi9RqqCWLEvn2xno4SrCmIgO4M/RPTzz8/g8M79/L4y1ZhiJjidPM+cuvXH79lfVwasOutOXEWLEodr//kYc//McG3c+tjajVb769cnl+JoeZsiaoEgi5rohLkdCRdYZSZODKKcvvZmXAdVewOrTnuoAxpGUirwtX+lKOqb1/IKUoq35AObET1CBKqB17tu+e2Hz4QLfdoXtR7lQOMpjHyHo6yvurNRFxrZF1XkJernFjjW2rcKEy5Jwo84UaoyxvlZJmoBBJ60L/9ITx/a3EQDX/K0pA7MvLVy6vz6QQcGPXMFtR+uD3O4YHUZq1sbfkvpAcCqUkeSKsKNC0alqyIsXA5eXA/PWFvK7tv5ebJm0Mm0/vGd8/4jtHjhlqIs8LYZ4BxRrEHqJLwXiPthqrHMoatPf4zYgbvCjYMRIvk7wWxhJDA9mj5HerAuAvtZJCYJ1myvWzFBIlyWefmuXms7WCUQu+81jnRRV1hn47tPBaatgqCRBWVXF9z26/E6qGdY1IIJ/nFCOv//gLz//wJ+Ky4L0UHOSYoKHLrJOb2Xh440Slf3yHGwaUtSzHE8vzF3II8nNrbWJ0Zb0sTJeFdVmxSuGGnrAGSmlDtLds3m3pNn1T5jNaJ/p64P32npq/n/u5n/v5W53fPIhOh5P41UqVsIeRC32cF6bTTFxEybOtC17pirMG/9jT9R6FwreASYxtHWgMWhlRsJQWn6QGTCcX1b7HjhsZIFHogigYwHq+MH17YX59IZzPEpxBEtG5gDUW5TTWgG5Qe5SSJL5xMhB3goFS2pDbAFCBdBE0VTxeBJ7tLXrspT2nSlire9jhxlES1NeVItegs0dZd/MiXodEKsQQmF4/sx4OxHmmlChe2VwxnWf89IndH/5A//iEyhI8UkqhuoH17ZXjn//M6ZfPxHnBOovrnNRjrgGjHMOmp/MGk1bSdMK++wS1EKaJ88sz4fSGLoW0SDqboiX00TrFybRaSy3qZ4VSK840QoLvxG+JooSGPEKGvdoQSAA1ZkqplJpbr7gMBlppYa+mTEkVjOHhdz+y/fgRt92hfScNSEqBqqSwUJaZcJlkGDYNn6RAO9dCaZ1glayjhhWMrL5LyaTLmRIXmqQqQHOlyfOFkgQb5fotqpN1N42Fm1Pm/OULl88/oyjSduU9JWbiMmF9z/6HHxkeHzHWwtWvWXIb6oKEj7TCuI5SIjUGUMKnnF5PTJ+/kqZL8zzL+1obh9t4xg97+t1OhuVpxmw2GNMT54n19UhaAyVJOFA705R6he48fjfinEPVAmEh5UINCWUsmSq+4xCbPUO3RrMCZPFNnqeb2qyun4paMb4TnFIBbZTctA0dxjpiSthRmtY0oAXcS1FZcLAoaWNrXNqbZxb5e6bDia//+99zeX6VggcnFh2o1Grwgxel3km4Ka+hocTOdE/vQRnqcmlDvvhqlfM33FOYAjVEOm1FCa+twMAZ/LZjeNqKctoCVjkmSsikORBejv/e79n7uZ/7uZ/7+e+c3zyIxjZ0uM6hjGZpydocIyVlGVQG31Z7Ehyy3ssqsSXEm0UP1/XYoYec0W3oqDFRDbjNBrfbYazHmIZNaS0uOReW5wOnL19YXo/kJVBbkEZZaUxRgDW6ge4lrV1F3pO1v/Mt3CSJ25IKtbXG5IYJqqU06wCgrcwnsdBvR4bHB9wwyP/eBqqahQWpnRePaS2tAaZwQwAtC/PLC/PrK+t5oqxRfl9jsMOW3e9+YP/73+G2e0BR4wo1gbcspzOv//hPXH7+mRwT1nv6sW9MU8H4bLZ9QwVJyENpzfr6Ij32y8z88txUHrkBsN6TQpFhr1R0KnjXoY2j1EJKEWhMR2Pww4D2TpqtUoYiz1cMsmo31t6Gi5IKtSpyTqJOXfvYlWq+RtDDwO73n9h9+IjfbMQ32CD9KifSuhIOz5QYRKk0Gl0yGL5bAkyHoqXHammNVj1lnQmHF9I8iX/XWaEdGKleTZcZ43r6jw9So+m8BOhyIefE9PzC2z//kTRdpHO868jXOlZtGN+/Z/fpE7Zva2Vj2xCbiMvSAl5tUDPNHmAMBc30cuD086/kZcHZjn4YCSGQQ6DbjIw/fJBgXqnUmMnzSq0J03uW85nzl1fSEtCSyMOPveCTSkWPHd3oMcajgHA6CXXAOVTXsV5mwvEiirQWK4zK+YaIWi8X8eyWFvoBlNH4wTMOHc55GfiaAm6dRTm5ibPO4TvXVEi5Sa3NqmN8T7fdYFvpASgJ91EppvL8Tz/z7X//B9bLxLDvsUYR5kjJ0I8e1cgcONma1JLa50a+b8LpePvsX593bS1hXpneLmIhEplaeL25YKwWP/fDBjf4W1GBNrJBqLlyuZxZzzPrGv9937L3cz/3cz/38989vx1oP1hq0cznhWWaIRWsEeyQ67SwPncjfjNQagvlWPlir7lQW9e8NRYayL7WCrrKhWP7gG/8QK01JSfxnipNWmfmb8+cf/3CcjoBuvXIO5QyaAXGaPF8KUlU51zA1Abr7jGdl59jLJLYFz9jaq1HaQ7NLqAbb1RmEz/2bD48MWy3LSihGzsSQImftD02kZZKS3QLmicsM/PxyHo8igqZ22rTOfqnd+x++pHNhw/YceSK9JFLtGJ6fePwz3/k9OUb67xgjKLv/O1nKaPpOo9pYZAqyS9KhXVJlLIQv34jx0StqtVtWkBTcmMkKqQ5xlhZIaeEykhFq5WqUqVVg8MnqmoUhOlCWldRv5QRn54ulApxXeQmoa3lSysCUM23uv3xE9sff8T1MtBjWwAmJ/LpQDgciOeDANn7Aa0NKkWUd8KGdT0aIAaUH8BLSh+tyPOZ8PYsLV26YrylKvEeS4uPwb3bSLOSsVQrNZYlFKbXVw5/+iPheBClbCPewLQulKplAP3xR1zXy/OvxV7AOpFiJswzOS2AljYxY9ClkFNkvizMX9+I54uwU3UlpFWS8J1h++k9w7sHTEMSaS8r9lIiOcD5yyvxcCKuQQgI/YjuHMoqtBLftfFCKigpk9b19vekXFlfj9SY5HUw4tU0CHv3cjozHc+iBmtRwHOWQXPoO1znccbL+7KKJUcZaby6vn9UUaJCaqhKbCzKWNx+K7YFrcWbnIIQEazncjjy+f/9D8wvbyhl6IdObDslC1bNWpSSVTzm2pYVsI3jq6xBWxk64xykvat9fuO8cHk9EeYoK32rWUMmxUg/DnT7kX4/oLWlpIobxAJELaS1cDleiMuKUprt4+bf+z17P/dzP/dzP/+d85sH0bCupMtCKWBQ0PBNtnN0vf9ecWkMuiq0Mze0jjYWq8UXWdMqpTpKqvr8dot/2OM631BQEiLOMRHnmen1leXtQFoXcqzkXHFe/n51bYFpzNFr+r0ieBbT93S7UQatUm8Bl9oU2LSsxMvaFCCFMaIWYi3dpqff7+h2G7lApUyticaWQXuBziujRQ1LwsfMUXyHYZ5YzmfC6dx8kjLM2a5n82nP9ne/p9/t0N6DstQqHdq1VFKYiKcjx5//zPHzr8SQ0FZhjKMajes9rpMhqZZM1XLRp1biNBPmtSk8ihiSJJStIcYotZpWYxQNm3X1RMrwoL2XGwzVqAFaPK/yWiZyWMjrKkOlFf5qzrmF2TRpXYjnRVqtGkCeUjDDwO7HH9n+8FE8fdqAFs4jOVCWTHh7Jr58u/lxtdGonCjZYvoB5ztMJ/7DmgKopnbXQl1X8nKBHGTFalTDBhVMP4gHVLcWJa1aRaqmTBfm1zcOv34hHF7RBvqWLC+txtVvH9h8/ES32bQNv6zvaw6kGGUon2exBlRp8knrSlomMI7l9cD8cmhWiIJSLUKlwO1GNu8f6bYDmtpuYjLVS4PRcl6I55k0rVQkvHQdcnOtOG1xQ0fNirwkCg2KXzXKGVlJxySfOWtJNZKyILLWNRCXlZQSpYpqLTYR8H3PsO3xvqMfB2lEu9ouQLBp3mJtW97Ha81spRpDt9vQ7/ZY7/+CGJDRxhMzfP37P3L685/RFPqx3UigKDFjvcX7VijhPWUNwhmuBTDyeWleYG0t6TxTi1g1SknMr0fm00StCtv3eGuAtuXwjqe/+4nNhydyWAnnSWwe1lDDKjeVSmGUoR9GqKKS38/93M/93M/f5vzmQbSsoiygCrUajLP0Y4/vvSRaUyWHLO2NRtbZkn6vqJSoWlQ+5Tx2M+AHYTQq75FqQ1n5hvOJ5XhkejsISigKnkcpjba1IWEadN7KKjjn2uDqlZRFgaq1YjW47SAXyHkmzmtTMjUKgaBr75oHVdiHbjPS7bcNFySqDyDBF93aeJQ8Lqp40UoMAlKfLqzTTFpW0rqQQutY1wY3jgzv3rP59EHCUbYTCkFFajSXmTRPrT4zQK2Mm4H64R3HlwPOGqk87FxbH8rQrq2mlEpYAmlZJbWsFBXFugSUMnRDj+uvtgkJZZVSb49NVYVyRuwUnW88TGn7KUlg72mVwV1KB0SVTQ2dJInkTF0DOUiQTVS7DjuO9E9PbN6/w7dQCY0oUKKspOP5RDweIUtgC1Xbut9jNhts36O0xXhpaRI1Um5ccorU6YxqdZaliDqsWxpaG4PfbNugjoSVKuR1JhwOXJ6fOX3+SgkBP3jpNK+iLne7DeP79wwPD2LDiOnGfs1Z1vBpXWTY9Y6Kbq1hwjgNrxNxERyWzqX5ohXJGLr9ns37R1znaWgBqtbyeYiR+Th9xzjlIiQGe1UBLaZzdLsR4xwlJdI6yw1C8yankiiXVZ5PuGHCamnBpXkV+kCtsubPSiwaWtONHd0w4GxTmZE60auH1jhHvx1RSm6eJDwmK3632+G2G7rtRvi2pbTVQkfJmePXZ778/T+RDkeMNpjeYzp7UzN9332H4NdCang4pQ1u6Bs+6iaxE08XSghUY1mPswzuc0Rpjb9+VnVFWy+tSz99xI3S2uSGAT+MxGUhzCvaaHzX04+Gcb8jLCvT24Fwnv/937T3cz/3cz/38988v30QjbX5sDT9xtEPPaYhYEprTTKtbYjWoV2ypLBN32HGETeOkra2rsGu5cIY5pn5eBLo/OEgvsJKUzsbIqdUjFE458XnVa/tLDQmo5LGppQR3I+SQMPrEe+sKJoFCbXQakCtacDzTlqithu060TllNJDALnwYdFXwH1B2JcpkFuae7mcpTmogipQIthuwO32dPs94/t3+M1OPIOlhYBSIa0reboQjgfIkSvWqdZCTVHWlZ/ecyU+qabolVwoIRKXSEriacPqtuIWZdUPPb7vsU58joL9acns9ryarmvNWC0ElCs5r+Qsg2i8zKR5QWvTgllSfRnXlRhje53UzY6AUnS7DX67o3/3juH9e7nw18o1LlTCTJoupGUlr4us8IsMeLVmcoGcK7ob8fsnGSpjas99FWZkSRL+yUUGHquhiK1BOSura+/FbtCS2fUK1p8mwvnM8vbKOk2oWnBefKhoi9/uGB8f6DajeEhrkfcb8trluJLCChRs50UpbFQE03vi+cJ6vJAuawPdQzUarMUOns3DnuFxL1uDdaHVJREvKykk0hLIqzQ0yQpCC47KOXRn8GMnnyNj5EYoyOuAta2is0ipg7PQIO4ptr83RmoRCoTWclNXSyEbsFpLk1DfY9r7VBkjN5VWo5XFDqLIqpJpYz0lFUw/4h/2dLtdQ3E1JJaVf79eZg5//BOHn3+Gkug3PSkVlDe3BjU/dGIdKbTnOVOrqPSCeXMo69pwWyhLIC8rGQjzzHKaKEmCisZaFFIX7LcbhncP9I8PUqvbSiVyiG2w9gxdL7+3fOBxRglLduh5+/nzv/uL9n7u537u537+2+c3D6K2F0SRUVrseFq1lbDBGFBKUDq1ykpUG4MbpBfcjqNAz61UV9ZcSCmRL2fSujIfT5xeXsmzgLHRCnddeWslbUv+mrQVRmIVyVXY6W1wNM5StZELUBUFSqMavUj8dCjVmNmi2PlxwI4D2rVVdy2y1tTCJ1W0obcWae4pihwD4XySJqJVkFU5Rblwa4fdbOg+buka2FxaeWRQKiVJ8GU6k2YJLV3X4mjT2oFSszHIxd74FuJpzNR1jTL0rkEYqVfUFTRlqanV2xHrvFQu5iL+Uw3WG/mdjL0NxrSVcEnSlCMoIQmoaSXKcM4Jovw9MTTovRI+rHYGv99KDefjI363w/bbxphta9t1bcr0WRBPGLgl6jM5RHIUn2muoE4XtOtw2w2uG6SUoARKyeKQUNIfDxJgyctCrQq328r6usHiK1UKCKYz4XQkL+Kf7HZbTO9Z3YWaC36/Z3z3jq6xYGtpXFTVglcpUlMb4oyi0jrWq7RKmU5S5a4bqBni+kxaIsZKnabfb/CjxxkLOZPCSgkBrTUpJpbzQlnCzfJSk5bkvZfPkd8MWCOWhVohL/LeK7GFcRRQmiLeDJw5F9Z5JszCD1VI4r1gxJ+NIMlc45tew4NoLfYXZ8R20/Xy765wegSor7TBP+3oHx9FTY5RvKINhRWnidMvv3L+8o31cETXKv5OYzAkjFK4lpDXSkPMUiuKfO6xFuU7CSTmZm1oYbycC+sSiUHaqox18j3Ubmi0dWw+PDF+fJKglHA50CjyOpNTlgHfyHeGlFpoIQkoWC4Tp8/fWM+nv8qX7f3cz/3cz/381+c3D6J+kIuH1oYrjUiCAbZB0luStR/QzuM6j/a+KTnSpJRCIq8LOQTyuoga1HyeXd8RGp/UWIN3tl02VFt7Qs5FcEdVhjJtFBSFGzwVGRZdBlVa6Kj5zpQRxUVZgx06XFMJBYhvRFVtfkBlWoUo0v5CS9NmDev5TDidCJczcZklBAQoJcpq97TDDyN+s8Vt9uh2ca+lkONKXiZKCs1LGijrFfjeeKw5UuPa0vbq9rMVEiAJ00paFmIQBS41RJI0H0lloh173NDRjT3GW0qVttXa0uOm963/3bTWoyhVlyW11W1pvfHNrFsVKWfyGskhCuvU6KaAlnbDMbL59J7h3ZMA/bteBnglnsk0T6TzkbxM1NgGSSXKbo5BMFClfme/Oik5MN4QJ4Htm4f9rVJUWyc3PGGRFqjmPywxiN3gfKD2G0zfQynynM2Xm/oqbUfX9/VIt3/EuK6pfVa4r1SwjlKqvHYpUmpBF0F41bZy1r7DDiPGe4xzyI2DME3ddmR+PcjKdxywTtL1OQlKKa2RtET5WaWicmkKPzfLQ7d/wO+2YslQUq5Qrm1VOZNikhBZY2ZefdJQpanpcCYsq9AkrKHkSlizeLS1QluhIkj4TWGMFV+v1thRBut2t9c+jVWUZ6Vx+wdcu8lUQA1SB6uspdTC9MvPnD9/ZX47iFpOk/WrfOZNb3FewkYCmihNpRV1uiLfL9r7xg0WK41CEaaF6TixTgtSduEx2hCXSFUw7LbsPr2jf/fQXhd5Tiq0DY5G2VaUkLP4ga9BxQqnr8+8/sufWQ5HjNP/lu/W+7mf+7mf+/kN5zcPonKhldW0vgY22pe3dg7rN9hhRHe9DH1SOA1KEddInC+ky3TzlFGhKgO1CMoI8J2n6zsZBhHWUwZyqTesjHGtm72xF1ESbFJVAgba69uFWDbrCtf3dLstdhhuagw5tRlQtcBOq2IsWeDxf7GCDtPMfDywHs+iQsUoAWPv6B52DI9P9A97nPdt4PXCMKyVvMzE84myLjJoIYOGuoK+W7VlaRxO3RpulFKixMXEer6Q1oaWQgJbMUjApB97xu2I63pR5XoZ4NAtnJUKaFmpXv11JWWorac9BMqyghHOaW11hiUX4ir+0ByjvNZVBqSaCqUWuu3I9tMnNp8+4q8qpDHyutdKnC6E04Eyn6XBKAsoX9BakNdFQjgNqK+MsEO5Nfw4GUg7D1mUX4y9/dmyTJQqChpKxoyaK/F8JK8LZu6gQlqWBrLXrc2oPSfdgBs3mK6X90Rpq3ClyFURpws1R24NWSmJZcEYlHG47SCtYFeA/u3vbkG8voPd2F5T13BfoFwv7+s8N3pERrWHp638We08vg2CVSlqiMScqSlRldSBllXUWdV+54L4nFOIzMcTl9OZ2DBhfedvwTJRsK3cLCq53btWuV4/e8ZbYYYqJYNbEYRRRYbv7vEdbhzRqtEvmo9bqcpyvnD8+o3zl29t/d3qVxXS3OUM3diJqlxbeUAVj6+xwrSlVa4qI9W/ppdWsZozl6+vLEdpfUJdtx5ihu3HjuHdI+O7J9zY3bBO1/dGVa1BSstnUGndbroyGM0aVt7+/Jnjz78SJ2mTIl+N4vdzP/dzP/fz1z7/KkW0yX+AfKHbfqDb70UFpbaQSuOCKkjrRDieSNPSYPXqNsCWUmRdGGILohuMacOIVrdmJkkhV5TT1JiJa2wDZWtloaKrrKa11nKxKQVlDH4/4rdb3GbbPJL6lk4v2opXtTbeZ8k3RaRmCNPE9PLMdDoSl0CeVlk5qpZ+3+14+I//kc37J6w13/u0q6wJyxoIpzfidLrVQaJFSczLQlnXBuGXi7RUeupmb6iEeSHOK3FZuHaoa2eIIVLIdNuOYbOh32yw4yDPU6koe1UWQSEILeM9tFVzSbSwiqiJqrb5u9Rbo1DJkRRW6XFXoDDi3cyiarntyOOPH9l++oTrB5STLndlPRVNXgPr81fi4RmaR1Ip/T0sU6qEZdbYqjS/Y6tM57GbDW4zyt+tNKpmSo4o7Sg1ktZLawmqopyV0oZIqClBC/CQmj+0hctKlJ/ndg/YzR7jBQ8kyK8MWpNLIU4TeV2pZFGPEUW5pixNXNudDEYCkZLgWopNQU3Nh3qRkJJplpLmwS0Y1tNJBmV9DfvIkGwaKsl4j6aScyRdwnefppFBcjldyGtsrVmQojB6Xe9YLmeWw4XlMhFCkqFTQ04JYy3d2GGtPCZtFK6Xel0JvjU1lKaupoTyHdYZISNQsdsdbv8gN6VXBVYbaJ30p19/4fTtmTjNt1V3zlJqYKyh23T4TjYmNefm6dZtla/aAGpQ1soGox/l+6YW8hK5fH0hXBZc39HvBlLILMdJAPV9z8MP7+j2e1E727q9VHntqjaihqfQ2K6NVlHFzrKcL7z+8U9cvr6SWhmBbRad+7mf+7mf+/nbnH9FxacohLLeHnCbDdZ3jWlJuyBpabOZzoTpTJ6n67+gGkcJhRRX4rpQg9QDmsYKrCHIBaNKRKgo6cwWriFoZXGdpdgsvNAiKpWxkoCvMVM78da5fsDvt9h+RDlJGpNTG6RkKDAoiKFtwC30PTUn5rc36X0/n1mXRdqkongo0RqMxXedDElaiQJsjXgJUxLva0swlxBvCXbZaEo6Pi9LK5VpXj6qPI8FLq9H5vMFVVVb5Spq2yRrZ+m7Tlbv2y3Wd7cLLSWjO1EiK1r8dq2BqNYCCUoIgleaLtRUcN0gw3FDS5XUvKdtxS3InBaeArr9jt1PP7L94RN2u5HgVK5XnwbhfGF5/iLqkgBGIZYWFKrEORLn+fvQbLR4c5tybfue7mGL2+0xXYcqhTJP4jG1npwCeblQamrhpCLr/lRaOUBT7EH8hAqqrpQkoSbbD/iHJ2w/gBf4OimK4qgU4Xwhnt7k5qANa2lem63B47Z7UVBdq3MtBXKrfzWaElfSepH3dilyU1UVSsnwnZaVNF2gJkytMlx6h6oyfPn37zBaE99eiesMzStpvKcYR7zMhNNJ/jdlqLnKa68FNXX69sZ6uciwX+sNdK8M2N7huh7nu9smw3W2qcxCn9DWokqlhFXa09pGo+aEGbd0DzusbSn/WgBZ4aucmV9fePnnPzG9vGHcFf+lyKm0UJxjGLwQI5QireGWhkfJ+994CRlpZ9G+Qw8dNRfi4UxcFpa3M2lZhTVsNCVKi9KwH/HbDZvHR2wnNiAajaK2YKL2Xqw2MVA1oKRkQzYYlulw4vDzz4TTCWMVvu8oCuIUSOGKHrif+7mf+7mfv/b57UD77QbTC3ZJ2+8qkaSYc+MpTuRpogSp+wRufrFweCMuq6Tr27CAMlANpWRyyYQWprBemKQ5FUpCfKNeSRWoEz5maQpVDqJa+XFkeP8g6qx1YP3N61nD2tiiCvKKqplqBGiunCXnzPztC8vzV+I0Sbd5LegqCk3W4gPtdxtpZwJqikx/+hM1Bba/+wM1BNJ0ooQVaC0t1oonMqzk2LyBV2i+1eSQb77IdVqktrGWplgpqlECcXcO3/iffruVGsySZKAvFd91wpfspB4zxyhetxgoIVG1kqai01nCMdbgelG4S87klIkpUpaFnKQlSilFyYmiFMPjjnefPrH56SdhqjZGqahKjhwS6+EL6fSGODKMDHBBeuXjGlkvq4RbruKwtejOYaxHGYsfO/x2g/Y9oCEEqQfVWoaW84GiKso7qvE3bisZaEUG+hr4AknVt/nBdB3ucYcbt9+bkAqwLtRaiDGyvr2S51k8zd5Q10UsDNpgdzv6rQzHtyR7Y5RWFCVHSblrjVaO2ntoqf5iLCkm1tc3VC4Y3UJOKjc/ssVsRvymh5RYvh0Ek0XFGKDriLmyvD5TmsKptCVlYctSFcvxwnQ4U0rGdUZ8l6kQ1oj1ls3DBuccWsuQh1EtYFfIuWI7g+uFZKFURXWNHFHkPesfn+j3j7KeT2JVwEnQLc0zly+fuXz5wnqcMMZIsUJT12up+N7RdVLnK8Mz8j4zDmUsprN0u40ov7XeqjZJmRwKl+cD6bJirKJ7kNewNluJ9Zbxw5P8+evNl7ZA8/FSG3u2taApUbFrkhvLVOH8+TPz4ZV1PpOblzWGRF4zbjfyu//T//xv+3a9n/u5n/u5n//D85sH0fH9x5Y1MIL/qZKqjtNEfHsjL8tNgZMmHk2JiTSdKTmhlcJ3MmBRJJWL1sQQiVEaWVQVlXOdZvS8SgrZWIzrMS1tT9GiECppPXKbDd3DHjf0krDVcjG7ekAleKGkHjJXUXDsIJ30a+T4x5+Zv30VpE3JjRNpMNpSTaZi8FYCFNdOb65pdmeolwvzn/5Z1rPOSa1jqzQtIVDCIsNeGzpt52RQi1kGuGllbaEla2UJuK4R5y39MGBbbaWxHrfpgSLImhBQWtNvR1zfoZwD41HKourEenoT/2RMpGluTVXtgq8lqJTasJVzJi+RmqqIfDmhrWZ42LH/6Uc2Hz9ih4FqG8ooCworrRfWy5myzrAGoFKSpN7LuhBDIq6JnOttuJXUtkW7rgWrGmLKC1+0oqglyhCcC2m+kMOM6gfx3caVMl9QjeepO+G9isVCwOPir5Vwmt/tBeVkruqeYKkkqb6yHA6E01kUuebrLUsAMqZrCmrXyQBdUmuggloztSTSMgtGCkT5VQ1dpDXVeMLxRJ4nnDXgrJAOYkR5i9vJ+1ZRyYcD4TJJAK5UAdZbT7zMlHWV6lgt9ZqojBs8JUWm5zeWy4qmYK3BWk9uavNmv8VtBvzQUYJwgN3QEeaVHDNmM9I31V0+uCBr+Ua+GDf0261YAJaLfK6MQ1lLjZnz568c/vQL8XKhpNQUbgkZlVpRVjEMA8Y6ITLkgiajjcNtBgrf61qVFf9nyZWUM1pH4hqIk2wP3ND4uUo1xm2m346M7x+xrSChKlHeZcdQpM7XWvF8V0WxYiGoVJT3hHnh8OufmV7fKHNoDF4ozUv67j/9ng//83/CPbz763zb3s/93M/93M9/dX77ar7B12VoWYmnI+lykYt/qaJStDBCrYUcFunmBrSVFqJr3L4UCcJcO92NlXrAnBIpZZz30qriHMbYprIoCbtojes6/H7bFDTf1qjiP60xUq44HSMKKCm3AVQGjeV05vz8leX1QAqrNEM5Tc1QsqJURclGoPlKVqg1F0IWPqPtXUvff/epms0ojy1F0hRlMC+peS5lODNOHsc6raznSVLw199NKcIigPF+MzJu2xDaSfBJGyUKW5Jhq982JJb3bTjSlBBJy0kA+9PMOk1QK6732G5s6f1CrbmB2EUlSjGTc23rf8Pw7oHdj5/YvHuHHUcqVzZse52WmXg5Ec9Halhb2EtYpDllYoikOcpAVMRnV5WSgJfV2HGgf3yHGyVdrrjewAjiKqeVdZ4b2kiB94JSCvI7U4SbajrXbjyaLxctBQrW4PZ73LC5qWe1iBpbkcai9XxmPR4wXkoMyNIVL5WbHe7xURqgTEtcFwlxUQVflZaJEqMMhi3go9pjrEoarvLlDEmGoFzkddOdRw8jbr/D9Z58ORHPC/GyyGtrQDlLCpn0ekAhdasoSEnQTqZzLOcL09sZBXS9FwVfgdKVfifDnzKueYQtZreV7vq4op1hHB/QXWsMi1mCaFFqaVXX0b9/RzduqCl+9yg3T2VaFo6//sLx81dqq7StSoGy5FoxGqxWWKPR2khgrlEpMBaM3CS4rhf7iW71sc3jm0NkmgVlJQFJoVmUXChRXt/Nh0fGpwdM1zebhLwvSkmUqiS055y0MWkNuVBjkBsKZ7m8HTh//oVwvlCWlRSyhLa0xm02vPsf/sDjf/gDpt/cPnP3cz/3cz/389c/v3kQlbagldD4lyqLIqWcFyWTQs2RMkuTTK3Swy48TsHDlJqlTjAI6ql7kA7neJpJBbrNSK+1DJ+2BTxqFf6h1fjtSLff4zff7QFCly9tzS/NTa61stScpWpSyUUsnF65vLxwfn6hpox1RppplFQLgkJri1WCqSoxiWJYMtoafHcFa/uWlNZysTOKmiLpGkKqjVdoDAUJDlEKYQ7kEClVFFJlDM5IAAkqtuvxm55+HIXdaFVrC4rCNvUDbuwwDeUj7TOVEhJlbW1OcSFOosLaljxXRgZEWcOnprqJqik2hIrtPd12w/jhA5unp8Y+VdB670sI5OVInE7kafoL/52SNadRkCGHRF4jKYplwhgkqKINZuzxuw3+cY/t+hZE07LlTitlDeQqqKuKpLDTvFK1EsVUIR32SmN8J8NnjLLKRYI/ahjpP3zC2usAKvv5Wgq5JFKMpGlG1Yrb7kBL6lt8oV3jdW5FaW3FDLWxNWuMpBgEwxWieINNa/iqlVoVOUTC+SBoJ22kUawWqLo1TQlXlxwJz1+lNrcCTqPdQE7pFvRxvim0FAn6+J5SMtPbkWVaxOZitDyHWYgSvu9w44Dr+zacq4ZHkg2Gdq5B3TUlCFcWVeTxO4N7fMA/PGKNpM11PzT+rAS51sMbp19+4fL8Js+t0uiuYcpaIM2o5m+mNW6VIjk+rTDWyufXO0jttYlR3gO1EJeV5XSWz0dtGw2lyWts79OOh999pN/vb/YIcqaU5lftOilpaNQLattOpEaJyInTLz9L6n5Zm6XCoJ1QNob373n/P/1HxsdHtO2k5azcB9H7uZ/7uZ+/1fnNg+jll5/b8CLgerwTvFJoLTA1t1YSUU9qFqRLzVVYhylRqBgnKCHtBc2S5hVtLP3DKINkvf454TW6XtTPbhwxw4hykvCtbYWIkpAKLV0ttUatE7sUSlyJ04X5eJC0cYwCs2/VijlXSBXTeKfUSokCV1dKY3sv6s4wNOh2Y41aQ6WSUiRPQUIvzTOrvEVrRQ5JWJFBlKZaZSjNSZLSfutbGMVhnZUO+bFHN/xRLZlSCso6XNdhfNcakBpGKcvwn0MgXmYJGTVMkaS1BcRe0jWdX5E6VfHvaqPAeYaPe7bvP9DtdpiuFzh6RVbNKTWA/5F0OUsqvcjfca0nrRRYv3MitdJ0vbmlpu1mi9uO+N0W7XsUhRoXKtI3n3Mih5mqGr/TGFQuYoMwtg1OorxpZQTsX4pwJrUk+muOsrKdZ8LbK+wfRMEDSmkVr8tMqTIga9VqTmOSAN5ujx23GGOkNahU6atXpt1gnYnz3Nqj5HGpZgXJyyo+1lVIA0a14bDUdkMiJAC/26BqghQkGHWeRYHUFqUtMSzkeZUbMeeayJ9BVXJOYp3ICagMQyeDVRIGZjd09JsR00n9bYn5xqEVpVBufLSx1FCaFaVhi9oNZbfb4fcP0qpU2+dLy6ZgPb4xvR5Y38RCoGxrGMsF6XHXOFXkBs0InktwXeLbrVVeL9336K4T77aBtIgnu2pDWVbiFCSo17kWuJNmJoxj+37H5ulR+LBKg65wrZk1nQScjGmd9PJWqjHKhmBdWS4T8/lInGbiZSGXgnLi1TbWsf/pBx7+8Af80MvNJe39qMy//5v2fu7nfu7nfv6b5zcPojWLYmi8R3nxp8X5Qg6iGkr/OUAlpyor/CRtPaqx+yTRbSQln6QnXFUrrSkt3KC0agla6aTvtptW16ebuiQIJWUa7qUl0pv02biikbjMhPNZqiTXpSXmBZYuEEGgaGltqg3QUq48REn56s5jvUc7DUq8gdfhoFzDLKU0tE3jmmrxyJZSWJeVOK3ULMOP6zypWRBc393af1wnrEStlawodW5tNp2s3527pewlsJzJLRCWYyQt4m+T9Xlt6ldCFdWGSvknJ/FdyqpTfqYdR3Z/+Dv6ze6W8K9VfHRlWcnTmXQ5U2KroqRtx0ulpNaKpJSEz4y6rWGtl6Yhv93itlt0L+1SFaiLrN2LsaKE1grOoE1HzaLu1lRENdMGVaqsj7VgwaS7XJSymq+/g8E4Ub7XtxfyumK3O1HyposkwRsrk5Qk7O8sdrPFjhts192qI9HiRUwxNp/vTFnnxrsUpVuwUZU4X8THGYIEfbQDVBuOlKTshx7X97JenyPpfCFHWYGrLH7HNE8Yo/D7rVhbGlu2NN8yyAbCGAPeUaPcpFTETtGPA77rbrzMlOT5QheMdeJ/LYWyrK3ESxRO7Tu6/Q6/3WCdk9dfjLxUIJyOTM/fmF5fSWtoHl+5GcpIq5RRCmebMtyGtty4r1VBjIkUA3WppBgZovw8FVfS5UKO4sm8KqDKC3YMgFLo9lv6p8fvgSQtuLRaorznrUO7DqOBLDWzNSXxsafEejkzHY+EaZHntNUAa6VIS8aNI0//4Xfsf//7hq8CrGs3t4p09QDfz/3cz/3cz1/9/Hag/W6PcR4/DihjSMssbTNlQdVKSlevqCK3JD3oBnYv5FrRTcEyxklLYBXFCAXaKmzXi/LX/tGm/XoKagubqNrahtSVSSoesFoyYVkJlzPr6USYm4cvZVG5jEYh4HrtLFobSKJ+llKgSJLbD+LHVE2J07YB1GORFqAYKCmiclu5X0MeBkCTUyBOmRQSYV7FVmA0uimhymhJ32vT1o60FH6haOm39ptRHr/vpJ0pBWoWv+mVTlDaxVE2k6XRSBXGG3IIrJcFq7WsfRuLtSpQRmOtBE5MG0bD+Sg94uPmu/8xSNq/tLpPkN+/pHydawUtVRoiyshFWxuN2wy4K7+172/K4RUKn4LcGEglqgLXSao5R4G0r0lS7Up8i7W9ziWLCix4pgJWSZ968xVqozFDJ/3rORHOJ3mOa2k4ItXQUho7jNhxIzdWSt2g8FhLSZl4PpIaakrahMSfrLxUV6ZluSG6JF3fUFwlk7TB9R1uMwgsH8jzLOUBKZMLglxKRQZYrfAbKYLIUawTOSVyClSKEAasRStFXgIlROKaRIXsO1HTvW+4J6i6VdS21jKt+M4rbQxfrMa/e6LbXwNT8j6RW4oqafjDkcvzC+H1RQbrhjwwWssmoVEArLM3YD9JVERpKGrmDaNQSVrOSq5cnt9YLxPeG1SuDWHGdx95lveZ7Rz9447ucY/pBvnv2mMT72oF36pHc4Kqm180U2Mk58Q6XZheX4nLIjctckcndhJn2f3+Aw+/+5Hx40e09UIFoLabSeEJry8v//pv1vu5n/u5n/v5Tec3D6KbDx8FAN9USN2PxFRYjv9CmqW7W5QIMF6Up5JFQVJKYPXa2uZrpDG8ReFxmwE3dKI+2lYpWEtLKRtU64GX1PW1bk+8fSUlYpi/129Oa6vevMp3SobMtjKWZiiLQpFLlI5qb+WfvsM6dwtHaKMFPXWeBINUsgyEud76rmX1KxdOjSbFQJhmllkUS+ss/X5Pt38kzRdIEWtMa5uR1aa2EpjxDU6vnW8JZkl5lxhJ80ScVlIU/irXC2qprWdby6pdKYzSWN+RggTCjJZB3FgZGLSWcJdpA2KaJ6aUceuMTlH8dK1/HnTDZdGSz/W7N7UoitINKWToxkFqIYe+WQiajSJHSlylSSkESg7t9ZSENXFt7VKRGmUIVdqggZyj2Aq0DA8l50ZBSGjMbXiRod6gURStUVXwP4V4s1IoYzCbHdb30qOOhFikThIJYsVAvFxI86W930XllsCdFY/z2soASuOhNoZpzRXtDabvcY2OkNdVnreUZHBH4PK0GwvbdxhvqaWKxWJZZQAtAoHXzQ5SowT55N8XTOfxXaup1ZqqNLVI25YxHbbzEtwycuNW23sJq7H9hu7hQepYzTVEeH1NK+lyZn17Yz1fCPNMVULAiK3H3moJJJlGk1Dtc6Jpg3xJYj8xSuws7f2Ry7VUoIr3O4GuWm7UrDyO6w1sN/QM+63YeJwH3Sp/YyQrWnhKwki1FS1c2aFKa8IyM7+9ENaZtMZ251SaTzTTPe3Z/fQ7tp8+YXrxK5ewQk5CtQiF5fWFeDzKzdj93M/93M/9/E3Ov6riE2OpbTCbX56ZD6/kGMmpkNrwZ71Hg1yAWh+8at5B8TZmWbuPA24Q5U9aWrR4u5p6R6tR5BrKua7M2ikxEi4XltOBuEyieKQi+CSlpG0Gwclclb9reroECTKZTuP3W4wz4qtsSmtFVEbx/S3EZeXarlJzab5E8V9WBMJ/9YMusyimtuvYPD2w+fiB8cMn3GZHmCbOf/wX8vmC0hXTefrNiH8QtVk1xBFIcCOvE2meKTGQYyDn2sDz8jO1cyhn0DlKWCrJ72f7js27B1KMrPMi9ae6PT6jW8DG3YYQU7Pgj5YzuXxvI0J/D5ukpVU16sZmrUUCZM7hhqF1jg+tbacNB7pSQyKHtYVFovjydOsRL1FQQEXqSwUdZJqadx0qAMRvW2IQm4L+joKqMQm03Uo4pubSXqnWlqVlXWyGDX63E06oeAuQOlFRatM8k8Isw+gabi1DSilh4QIpihoJBa0bIso0gLq2uE2H9RZrxWOZLrP4XK2hWkdeFtI8oVES5OpluCopk0JkPV+I89xW5602tCgZjkOzVaDo9ztc16Eq5CLWlyLGaYzvMN61z4KwPmvzTJu+x282uM22lUWISomWGwapkz2RLidqTnSjgOPz2hGXlXKcgIJzBmtte561BBO12DrWRcgOtnfNkyyectM5sZAYMEj1pmTVtADwjaZE8bGOTw/4cWy1r1bW/UWGeYWUC2jnUTlL+5PWYCWNT4xMby9cnp+Jyywe6VzRWt/oFbsff2L36SPdMMr3QspQ8w0xFueZ9fBGWVa0hmrUv/6b9X7u537u535+0/nNg2gOkbCcuXz7zPL2Kl6+UslLpKSCbStLWrez9a4pYi14BJjO4bdbuv1esEvNiyfwSuF+qtugQVNpaKELTVWydk6XIyU1X2QtMsSUls7PFa0M3olnUFkZMrlqpKY1t5iKbulrdBtqWvtSTkWGm5b019bKYJUBdFNAo/w5J+n69XQhhIjfbNh++B27Tx/p9w8SsGrKmul6TDdw/tO/4IzC7/dYZ28g79qCH3lZWQ9HwuUinlijxSagCilHqgI79BhvhRGa8s2uYMcRu9mIIhUSnev43sXIDURPbcqitZBlkFBiOKTWQlmDDJ+Kxuj8HgDTxmA6hx1GaXjquvYcQ72qnWjSPIlFIuc21IFSVZRu7eVGI8WWqhZFTLX1fdXNh5qlmYdccGMna36lJPRkjLRUVVpwrYpC1uwDynW4hydR/lyrjlRt+EqZWjNlnomXK8hcfj/rHVgjuK9SWacL13WzckbC2K22sioZ8Kz3WCdYohIi4SwDpbKGsEbidMDcet4dqkCaA7VmwjwzHy/ERWo7TRsea5GhuiBgeKM12lt879HWyOtepeJUe4fdbOSGKa1gWmiwyE2LGzd0D49CuWjRNaqS9iRtCOcT87evUMt3oLzSdOOGrOX93w8OY5Q0eiE+zApgLTkl5tMFpSpu8MKiLRrVLCmm94DCGIdtmwTTGrdyzLAE/G5D/+4RNw7iYVZaNhDCTxNFux+51o/WGJsiLu/RtK4cP//K9PJMmlYJr7XyAWU0Zhx5+sMf2L17RJUkLUuulyKCKgbw+e1AeH2RZ71tPdT/103w/dzP/dzP/fz1zm8eRH/5X/8Xas7keZH1X0v1GmuxThQhrMOPvXjI5pmSgwR/eifw8n6ge3iU9pzahs8YySmh+00LO0CLJV9nG2ophOlCCqsA4uP3hLbtBuF+Hie0lqYghZK8iWsQ86bkuc0oXE6lZMYt4kerKcsKOBeqvgaXxE92VW4qjpwDKSyoqwcuZ9K8MJ0udEPHx//0P7L98Sf63b51Z9vrBp1rjaauid37BxnSG3S9sWtI68Ly9ko4nKgpyKBmDCUUKNKIZDupVdWt4lJ3Hjovf5fvKFUxHy/olLFWkt1NuiLXSkry2gkcH/H03Yy6irQshPNMDqnxI0Vl1NbclLput8Nvt5hR2nBojM9KESdETqSzvF7VWlQnP6umJP6/GKkkqrEYrWTFqpB/l5MEXVJGlSrKbeeljcoYVCeDaEm5rVLrd5RXKZS1UGrG7vf0H36HGwcZfGttjTtAzeQUWJ6/kdfl1gdf2tDiNj3Ke9ZpIl/Ot599rSUtIRHXAMqIGjz0GCcIsHi+kKMo86BYjgfyvOC8w26kNapE6ViPcWU6vDVou8Y6i+0cKAkc3eafKu+dVCvbzShtVilLMCxn3Dhgh14Gr1pQfYdKibys6HFgePoB13XNEiM3hRL6UZT/D3v/1SvZlmVpYt9SW5g4wtW9N1SWajTBfiLAf8C/yJ/FBwKsF5LNysgQV7k4wsQWS/FhLDOPRrNYXll532wCkQFkuPsx27bt7LnmHOMbVM4//0x8fmqbAWGqcFqZp2VlORwoMdHvdm1iLwqDDT21VtZ5Jq+RMAQZ1nKmYprZzChNKkmK4qx0vaZoK1GzME3j20c2798JG+ZERiAmsvJ9Md1OTNlmuONyeGnTyvPzF55++pE4TaRTJMeIsxc4vWN8fMPb//hPjNudqA34RoVYsDZQnef8y0/Mnz9JNxxauln7Wbe61a1udavfpr65EY2nc7PD2GbekQnI9YqgdLatxijiExqL7R39biRsNeGoSdMq4yJpmZhfD6RpYV0WNh++Y/twTxtvUBG+J80TaTq1OHLTzBA0GanMRnWN2NpWgE4TopISxIxzVsioYSAMfTMfSatW4qzVbjOImLaurC0bslo1Z2WNLKdzm8Bqqhi8w5qAcY439w88/OH3jG/eYbqeagPktQG8gziG5xdqnJD7uRmtDFf25PTlM6dPn/RA94q+xFo5o43FjKO4pOvSkDuGHIVS4hKj+vwFEvTDiB8FQS9NG1dzxOAYthtd4zVK6xo8bAbKuhKfX4nTIuO4ld605CIH/9ATNgNhsyVslM5E1US6Vq3h8xpZp0k9bd/Rjb30uilTM2CDUEq54LsB47w4qzFCjM1I0iSLzmOHoEx5U+RGdwGo5Gmhxnw9uJTW4JIKpt8wfvcn+ru9rn/J7e/pmtc4s768MH/5QppnJXJdiATG4saRWGH99SPGSF+LsdSYdc9F4S/9bod3DueVkV5iIs4rxgbC6FinM+vpiDOW7vH+qm+tOZGSrtPy+kJJia7rMd6I99o0sMYYcJ5+7ABIuYoL2w+Ni6n7yO+2WsWXLJuRc4rGTBl3d8/2zRtN/Zu+kizTGg7SPDN9/IWyTBgcNQEhyGBYMvPzM/PxgMPgQyfyQoxQMtZZEpV1FfA+bAZpQ7Ma/jRNipK1HSYBVXny1rmvEalIXrL98JZhf69pd9c1w1KiGqh+kGmvRE1BszYVphfKLK8zh59/4fDzz8R1oeSmQy2VUhWn6rqOzf0DYdhhQo9BEqC6rjKexSjSwnzG77ZY7xtWy0LMpOWmEb3VrW51q9+qvrkR9b1ShNISKVPGd55+t8V2QZPEmAW57x126JQ+dNF/todPNpX18ML548rh0xfO55nOe4bdyPLlE87AsN8pYSlqbUktMjNUKNVgnPSb8TSTTmdMuuCItJo2DeLtNiN+O2ABa2VGsl7JMHlZpQmcJkqueO9wXpngtQpFZZwVvigl4hJbRKZSnaqFXAr7d28Z7x/odnsYBeevMUJZoJPLtxyeKPNREzkXMCZ81bvaigkjz3/9icPf/oWu6/Bdr3x1tCLuNhv82GlyfJ6xDb1Tm3EkVoiHI7ZWvAtKG6KQ4nLVkApVU8F46exaJrtpiUX5+ZW4LJRF5APXnMnWemkZx4H+4Z4wbuQOz7lhtCw1NR3t6UChtEmwAyp5Xqhrgq4D25ph6+n2D+JzppUcW1NQtX6vNcvAs91oJWvAhhGyWKA5RqGhhkGD5HxJC+oZ3r+lf/NW074cwQTwvUw4KZEOLyyff2nEAYdvSKO8FvxuwIWe9Xwin07CJBlFjtq+08+PGTdsGPuAtUoyohTyumCsI9zfs56OrF8+yQm/UfRkmRdKjORcyGkln88sxwljrFKTrCWD2J+lgrX0Y083bjRlLoWuTcKlUYVu6HHj8PXgdKEI5IgJHZv33wmcL/HnFU2Gt1AN88sL8flJn2OtGNvoEzmznGfWScxd7yy2GulML+lFtRCjmj68w3ZBMp0E1UjmMe73gGS4aiw1RS1FTF0/dAz3e4b9HjduwCkcAGNgbYZD3+G8hfWkSW/TmZtB73s9vPLyL//CcngVFcM7TLrogqWn9l1Pv9sQn5/5fDgwvH1k++EdYRgx/dg2AM9qjp2XVKQxgWuuDQUX/01+2d7qVre61a3+9/XNjWhpXEOTDOMocLbBUNcIGGzn8FutCLEOd+FGRgHf07qyvhxYT2emw5lSK9040A3tYVMK6/moKUiK0vu5C/JHmJ+0RJaXE/E0Y63FN5ORHhoZ2wvf0/UB18m8QpUWtBZkFjlPSuvJiYK0p9c1Jyjju00Q6yXCUUJVqjUMb+4Jw0A3bJTA0wWZKdYZMOA7xVlOR63XL47qFLmyTp2TNi8t1PXE3e9+kNnkdBJGyFm6u60QThXqquhJf5EaWDW8cdb76PqgBCXM1dxTncMEgfIplWr9FSVlrKNUSM/P5HkBI6akfrTDBq+I1WGk22/w242kBKVQ6+WaJ+JyIp1P5Jyx7TBAm0KWIp4jIejzqwXrAoTQ8DyR0iQDNaYGZi+EocMOQ8M3GaiV9XDEJDEjfdd/TTLKmhYP77+jf3jEh4FamumpH6lWQP54eGH58pFyUmIRxut1Wk0h7WYk50w8fFYu+WUK7WiRlmtjoo7tYMU1RarE2AxPsPz6EdKKDz20aW9eVk3gyDLVrSsmF+XXBw85k1JprnMLTvnroVMDnUuGqsk0VdIAZbMrUME4q/sDMN4T7vZ0m50OKxfuLBZjlNAUTyeWpyfhj9r1lx66QNU9Fc8yVPlOMogam4HNyt2fSiZloBpcrVALKWb5vzBgpf+84KOwkoWIKQx+6Nm8fWS43zf5igx0tVaYJh1AgseZCsuZapSyhQ8YHyjA+dePHH/8GyUuTQurA5QbFM+bUsFUw7Df4LxTY7usnE5npl9+YfeHP9Dt96xPn4XfbRN2N46aOC9H6rLetvK3utWtbvUb17eblZZMCAE3ODWLtVLWiB87wmbEbUZc4xHWUsmTHMhpTdd40HySvrMbe3wXmhbrH9b7fa91L824U/VQy/NKmhfWuXFBBT0UoL1BsMOmo9tvcEE8yxqz8tmpxGUmzQs5rlDBBy/uZWkIKKP/CKuzqm2ICVuhHzvG7Uh1geHujs39A77XROaChqrWCIBdSmtAF6GiXNMd5gbFtAHTD+KZ5lUPWB/oXc/jH/7Ey9/+gklROtuG9BFkvRmtrCfGVTD9WQk0JnhlwJeM66Wvoxm9qjHCTiVlgRvfqYE8nMjL2qZkF+i9kRt67OnuZSgLmw01V2pcqTnKyJQb4uh8pOSItU7mFWvVbLf3WggtpECreQyaAMeV0tBFpVZoJiEfHLYb8EPfmJxa9V8OOsYFURiM8u6rDbjdHf3Dg4xxGKX3tIaZnMmHA/PTZ9bXl7ZObtP5WqUAGXRoSMtEXaMSiZopy3adJnQlaxJ8YdZSyWdRDDCiFORpJp9nvY/tVpO/FInLBcMUyeeJUor4tbYhmUqlWnC9V5CqsUr4cpooC5UUyK0BtZ24theiQKnAmrFdwG1G+rs7nLsER6gBpegAmVNifX0mHw+iCXjhprDScpYYlTa0LngvQ58gFhU6JTLllIk5Ui7foZTJMXM+nHDG0O93mvL60CBrtSVRWayx+DEQtiPD4yN+GKRDBcHzs0xqWIfremzVQVA0i6Bm0zrSsnD49Vde//4j1laFGKyr7hHr8N4Q14zHCy1VTEs2q1fcVkmFfHxhXSfyNEuD3Jr7skbyrN9TtaIV/3xbzd/qVre61W9V39yIdsOgh1otWo12/qq91APSCdUTV/KSlLteUsMNaa3n+g7fd63xdNjQyf0d9CAqrbmtKTY+ZiVNi3A6nZcZInlKTlqfe7n0XdcSkLzFmnp1oK/TWRnVrRESzkl80JoS2WjilFLSWj6Xa3OaSyZsNwxvHul2e7pxbG5h28DlqPmiNUbrJLcy6rmqrc2V7MD11yQjLgb2fsBUGXfK9EJdZzZjoESrGNGKJsLGXPWy6+lIXiZByq2mQCXla4qRohQbeSkEKrY93JW2lM+L1uVJUzZjLMYZTYK6jm63Iez2+HFUmEBzotN4pXk9Kka0FjACjit0oDa0lJzYgqtqjXtJuKGa1jC0xJ2sZtF0QRrUIEd7rVUNTpFT3Fz5sxfdoMFtdrjtnVKnDG3i25ily0JZjqQ1El++kFbJAS7kAtN1auSsXP1lTQ0Xpem9DFqdYj+HQU1ryc0ah8x6uVBwlGUmnc+UXAjhK5OVqoCBvCyKFc2KxnUtkajmcrl9cEMgN9KD73tNnuGqIcY4eu+ErXJOjW3V36+l4jcyAIahsVtbk13bNDmXTJzOxJdn6ro0FJoDLMZXqhMcPi8r5CQTorWUhtFyzpBrJS4LcVmwzhFCi/dNmRQT1ge6Qa/d+07fMaPDRKWxR4ee8eGebrdpqK1WLQWpFklXbNdhqg5P+v5YjJcGdj2+8PzTT5w/f9GmYwjt+y9cVamVGA0uDHS9JS6RmNtavX2AYTfQP+xw1pJOE24c8GMvfe48k6a5hRTogFSaQe1Wt7rVrW7129Q3N6IYxWOGsSds+sYVFQqnlsJyVMqMpoptn2WsWILNlW2Dw3WBMPaCqYvnQ86ZmpXGVGKkLGszdnwFhuMaaN6D94Pg7M1cdHlQmJxIy6omOMkNX9sTX42VfkZKifV81jq4VDWwwTfmqcUNA/1ux3C3pxtGNX3tSVbbal1moQhxabxK05KWit638xjXqQHCNPxTalMgNSnpfGA5HKBB7akIYO690EVrIsVIXhZMTpiU8G3KmpuW1YegCS1qMGy7FiVVqDoYlHn5GseJwTovWYIzSubZbgn7fTPutJjQnCHrsynrQp5OlBp1vYPH2V5/LkW91gJkNa3GOUzNjV9Zrqb85k/RIQKDteA3PVwwX2iNS7UYU7DeYIoCAzABt7un29/JOGNonEq971oExI+HF+LhmRIj1kAYeioNU4SiV3XgOVNzwjvpQGspLXUrtOCCLOd1aC79y5S1GYHivFAXERSsEaPS5Ey1hrSuLKfpGgFLW1dfkodqqbjOE3o14Smpcb2QFRRz6zAWnFeYgzTBBTJUU3FdhxvaFDSElizUNJpGh7+8LMTTK3E6QanNyd8a0VqkD54mNeDG4IZe79OYZipqSV4pQilCT3Ud3XagJEVlDrutmuRqWkytPsNSZFo0ztLtNwz394RxvE67DbWlXHkdFJzuR6rkMBV75QenZWZ+feH06ROnL8+YKhScMZLV1AbB9z5g+8v3LTfKg1z8xjn63QY/dPocS9UWp+v0u2eZSPOkg3Cu1wQnWyr5tp+/1a1udavfrL65ER3vdppADXK1GoRKSstKjkm/wItQS9Yj00puWfNWaBo3jrhOKSs1t7WdtY1bqfVhaS52sa7lHjbOa/0YPM5dmi09tDVhrIqOXGbieVLcY2scTWtYc62a1C4z87KyzlFYGSrOO8a9o99rJd3v7+g2cpfXdRW+ySrrHoAGZ6+5GX9Mg8w7iw1bTXXaNbo0CHLIQz6diOczeZ7JKVJrxTl/zYDHGGLLj9ekSM1MLZlCFamggb593+OcGhjjtXY2tAZ2XnUtc2yNRXuwV11TFzolWm3FHbUhtJ9XWjOaKcusadp0xpiKG5ujOWVK1UGhtsmtdZba8tCrNYolrTKo4Fpz2lawxiLou+s05Uu1mXTaVMwZ7DXcwOC6O8L+Dt8Pmn5V6YhNqWqmTkfFksZZEPklYq3B9gHby/xVUkvFatM3aw34XixLFLcpAkD5yrHNkWorBau18LwQD0doms5SBba3jfOJ97iuYz5NinOtraFpjn1yxTpHtxuwnYD5lIo3WpGXrPhN6zzOt9fghIWqOVFiwfoOv9kStqMSotokWDdhhtCxTmeW5ydxMlPEICZovQRD1EyeJ9JpAsCFppmtjehgLGkVRzanjA2XCaomsxXFXyoUISgNraKf34gVORf8OLB5vKPfbBSf6VyT7uRGxhAdwVgvruclJ96gbQdG5q/jK6fnJ9bjWQcDKxIGLdHMGIv3Ha4TUi5P61f+rDGELhB2oxrmFqhg+wGcUUxxzJQ46/fR5baDpqG9/JK51a1udatb/Rb17Y3ow52iEHMhzitxUsyhRliXFZoatVxkTnHeqQENXtOY5mYVBmZtWJ+iRjZGySGLmlcZZjzdZnPN93bO6uHt1GSWqIlhrRlybRxFIZbwmkqCYZ0XYozkNRKXSEq5PegNvuvYPuzZvX3LeHcvneUlcaZWqhejs+QI69p0grZNSNV4V+OxQ6/El9YM2louCHkqer/r8Ug8Hsjr2iZUl+knaoKSGk5DxZaqSWCDcVfAYcURDeHaUNamHxRqKcnpv6zXabKmsw36bdoKfqMMdNf12D5AzZTppFV+RVPUZRbvs2YxS02b+F6atWYwsbTr7MT2JBdl1M+L9IfBf2WZ1iaPaAcAshpJNTFih1KALjR4+RY3blvj7TCuB+8xWZPZHGfy6ZU8nXRN2yTRjq0ZDp0OEEUxoZSCuTSaVmYuATp1zS/BCeYi+6jSJ6/LSo6ZsixKrmr8U9O0tbULChzoFOu57Tz+dGZ9PeggU9SAeu8JfU8Ye6jinVbbDm21Yim4IMSRqaUFHaBEqjXR7/eMD/cyK/0jaL0WmcIqLE9fWF6eYBU1wYZOtKR2nV3XkeYTOa2NqGA1Hb+46o0hrlHxsJfVuGlRtgmSSdiYW7JXp0Sw2hBatcm6naO/2ytGdDO0xDBtEUpaZSwchHTT9PISW6vPxZpKzpnp+QvL85MmlTFivV5LKTJeabLc4WzQa1iS7vPOY5dEKQpB6HYbHUyN1WferlueF+mfG9NUg8+GzmqbkhrclVRwq1vd6la3+revb3fNl0I8nYnnWROEcoGcNyZg0JQTY/De48ce13d6+NPQgbnI6DLN0NJ2SsqkZaGUgjHCJoXtQL/fyITiLvn0alyy9t/K8I4RaA2Xulh86LGDZ51nlukMpZLXfJ18UCtd5xkf9oxvHtk8PtJtN1rdXyJAa1HTYxwlLZg4gUA+YDX9qaXIfNRtcEGpR5SiyU7TINZSSfPE+vqq9XZO1Ji1KqwGgseEy4pbTFDbHv54g+mVb57jikm5RZW2aMQiB75xFmohz4m8rJqeVTX3rrnfMeBCR7fb4bfbFkagiXJZJiiJ/TnW6QABAABJREFUiiOllXg+kZdZ0oeWoENarw71igHTTD/W6XBSEQc0JvIaIa1qprquBQe05tVJd0gVfqrkgm1axGp9Q0IZ3Linu3/Ah6Dr3Nbm0hNG6joTDy+k81HXoQobVXMRaH270T23KPbVtCa6Fr7GnFbTtIArtqoZND5cDTQ1KkRhnSbSovvGBa/1bxuQOeewmxG3kTMbJ3mH70Z8P9ANA9PTEyYl0QCokgi4lnFfdXgz1uv+vegqS9GEsgH+XT/Qv9ky7HZYC8bU6/RcWLCOFBPx9Yl8PosY0bS31EpZVvCe4e17unEkLSfWzY71eCSdZ01bs77TtVZK1c839TJJrcRUcDjKmqX1HrqmtS7kFK+O/rAZ6LcbwijwvvSoAFUHmXZoc033+dUERrs3Csv5zOnTJ+aXF9K6tM9D63UbwGKoxUhf7gNlVfxnyaWFUlhCH9jebWT6y0qesq1Zz1HIrTifdW9l/X7TlkUTfO8DuWTm81lZ9be61a1udavfpL65Ef38Lz9TU6RrOjPjrQxKVaMu4xwueMI4aDLoDTnpgSYTwUp8Pf6DW7vie09eMwat7m0fhMjp+pYp/g8PZtS4hc2I6TzTr78qOeZq7DEE71nmyPr8SoxJyTzWqEHOhWoq4+Md++8+sHnzlm63u076LpxQul5NyjJBzdcHvkw5SOvpAnbc4vpBhpsqZFBbRGOo5HlifX0hnc6KA22GHyo4L7xUtb6Zh2TOcqE1Q6YZZIqh1oyzHtMJVF7b5O8Sp5qzZA1KgGmwb2eo9WL+gW63Z7jf6/VCA+JXahTns5hKjqevxi7kaK9xhZLU7xinKWybLLVEgdZYF+q6UJPSmOwwQtcJW9RMNyZz/Xu11rb+bHpFK4aoHUbCwzu67a5NUc2VeaqfdSYeX0mHA2ldsca0aa1rE02HHQdKiqTzCUtt7u+qRsaiqVypem0xijwA+jneYUomzwvz64E4TVgXcMaIYVuLaAgt29zvR9zQSxbsg3SOOSvQoRR88Gzv7wSSv9wbBl17q/AH45ymkdDW4xdjmPTEw+Mb+v1d0xBXMO3vGAeukxv+eCBNJzWD/aDL6h11XYmnM253x+bdB0LohJfqt/jNA/3DwvnXn5k+f2Zdzu3AErDlIrVo91fR67KmEvqhHTBk7ipF94vtPMP9Xmxh56+GKB0Sk959r8axfeH0eq0Vf9hIpzsdXzl9/sx6OGnrAu1+RlKMXCEbbUdS2wj8Q/iCqSIw9I97fN+R50WHWe+vqVhpOpPmuRm/KnVtcbctcrhiWONKmkRHuHmVbnWrW93qt6tvbkTTtNK19eNlFWy9x/U9rncyzPim32sxjaVm4nFmfj1SltiW+F8nPjVn/Kanu9vhOtcMEuhhUys1Q4krJgTC/T1hMwqr00wlp1LIJ6UurceZPK/EZaVUTaC6TS/Q9hTx+x1v/vAD+++/x/ejpnRx1S7RWPADpWTq+YQpqUUHKrte3EwZUey4b+vboOW8aZOsNtXM68p6eNa0Dtce7FnJTUag/WqhloRpwP6SsiZx3mJsbVGTwvfYy9q6FGpaUdPfK5FpWQUVb2YKc9GBGkM3DIRxQ7fft2Qd0w4AuWWoJ9bDq7S97bBgbdMA5kycV/Ky6JqPoziTcJ18kRNlmZVpb7TGdH2PaVNM6UPbw70aqmlTwCzUDqj5Kznihj3DwzvC2NizRmYmaWMTJifi+cj6/EXxrt5fDyrq7NvKNibS8RVbIt46TeQuhjlfG4hf76Pkr8Ld2oaL+XxkOZxYz7M0o85r/d4MTiY5qqsC7o+jJtrGqufKq/i0qZDXVfKKvhdWtRY169Yql6yaKwKJoluIMFCtJr4lrdjNhvH9O/rtXtpJXTFNT32QkWg+Ec8Hyhqxl4lxQzvFZaFW6L/7gf7uUVKRuOg1O/1c3/X43Z715x+l6QxBTvN5JQwDrrNCoGUIvZexq+Gvyjyroew7umFg2O8Up6pX2aQYBshyzveDtKTlQgOwmJYyVr0nx8Tp+Yn58EyaJyDhuoDxnhxjQ8YZKBbvZG7KqdEMnJUKpfNs9htcJz1rOi+4LmBD205MK2k6E09nctahQoeiirW+Jamh5Kt5hqjGezqe/zW/W291q1vd6lbfUN/ciO7e7IW02Y4yHRiD7wO+67QdL1nonKTGLE5n1pcjeU3CDbUV8iW3PIwD3VYPdNt1FGpLjJRZiWjwux3juw+C5GsfDohJ2A0b8uMDL8cDp+cj6zRjSqHrOsZxr0atVPww8Pb3f2D33Xtc42KWNWpVHHqM7ylrokyvkGatnNs0iCJTDF2H7camH5VuT91HS6NZFtbjgfnzF+L5JCh51+FCixM1BjvK/VySAPJ1TRS4TiCdE0fTeEd6ecE1tFIpBVOipj3NpJWm5X/rbm7+cTWbEHYbhrdvCJudPrwiILnpOq3tj0fmp4+UdVXWvbWY3KQPab0yFMP+Hj+OXydxinWipij00bxoao2hug76/ur+Ns1AU5J4kBZNrMQ/lzzBjQPd+x8YHt/jaJpYYxppocWHTifOn34hLTOu6xWhapAxqqA4SmNYTydMVqZ8qRXXDGylhR2oyW+NelGELI1UQM3E84nz80FrWB9krilFZh1npKR0Dn+30+GiZbGbZhLK60o+T+RVFIVuu1OznlO7bvrZtTQ+qPmqd67I7U7SFL9/eGR890ar9ZyuSK5mAydPiw4RaQEUwSqUmBgF6bRg+5Hddz/gu/CV2GB1r1Cly3z+2194+eu/4LtAv98Rj2eW44zxRsivBqQPvce1iM8S49VUZPqe/v6O4e5eumVzgVwBaZUDvoIZ95qwZmnKNfW3mJLBefKysBwUAGExOOuIZIyzOLje52KsWkwwXw2PTb9LhdBbnDPYbqTEJAoEUNdISlXmwJJ0eDDoXkjS8JYoWUhKC4WMDx2uM5y+HHh+ev1X/nq91a1udatb/bfq2/FNQ4cbOtwFvXTBuyxyR0OlxkiaI+ksFp/1DtN5gcuNwRqH3W7wwRLGAeM7oOGbChCzGqC7B/r9Ht83jVnTiNaqh/VyOnH6+AvT0xdqjlgKofN4rxShnCrD3Y7tD+8ZHx9xfS/t29Lg6NZhui15jZTPv0JaMV3A9hs1mc0Vb0LA3j3KYV1yYzy2KVwDe6fzkfXTR9LpoOFcLxZirVVTF99jx466zsLMWKtJZmoNhDH4zRa/27amQVzQGjVxTCnJlY1Vb5aKDgKhV8JP0QTVeIfbbBl2W/xmK2A5jRXa9dSSiIdX1tcn8nTSmj0o29tUNWspq3GwXTtg+MAlypOKYi4XMSfLvMpg4z3h7g7j/dVAQhY31rSfX7ANzaVmyHhP9/iO7Xe/x2+3sM7N/dw4q3GlpJX1dCAdXqAUwvZOGtWctVa3moKl1sD45uY2VdO4XIpUAZeIWK8mvOYiPGrXCd+1RubDq9KTXGDY7ZSytEj2obVzT9jtCZuNeKdBVASomoC2/HWD4mKNlWazliIyQ20/E8VYutCJUlXbir5mXathJGw2dPs7SUpKvh76LtrY5XAinmc1tt5h+16SAuTKpxg2v/8j3bBRXOU6a+XvvFirKTI/PXP48a+sh1e8NThriA3x1W96/NCRq0Is3CiZjJi1sZnnHDY4+rsdw+MDNvRc0FGkqNedI9U63HbTCARJ8gVz+f6sVBdYTifSyyfB/DtRFNLZSlPeUFfYQGgMVuNFiGhnUmwf8Mbjx06/Ji7YKB/IKbUwhkRMWsNfunrbeUyFnI04xhVSXChFXFRrLfPhxHw+0/fuf//78Fa3utWtbvVvUt/ciPbbsWVXq2nJl7QRK9NHPM/kabnqIEvTRFovvt8Frm28xYWOimt55oaStO51d1vCODQu4WWFLw1dns+sr68cP37i/PmJcokobE7nWqBYJwf8u/eMb960bHk9mMBguhGMI88T+fOv1Khmw4agprhkNVFORh3bD5rklgrdoCla43Hm80ka0Oms6VBLvakNfWSckyv5CkT/ai6xLS4U5/Ed+MFrtXvW2tr1PbFW0nmWC12OHzDiOBrfYk2LmoJuuyVseoHfnaVasKHDBDET0/nE8uUjcToJXNB1zSBTKeezUmeMlaM9+Ca9aAYxQ3M169CRl0VNUB8EZA8BKJR1vZIEjG3rcGSm8n0gxUjJE93dA8OH7wibra5JXLXB9UpEKstEOh11XUtqjvy2Qs0taaffqLk4vlLWFWflpIY2j8tqYEywWKuo19JQT6ZJHuIyMx/OpOmsNKBxg7WWvK6UKLSXH3r8MBDudpqGc2k+c0uFkkGr2f7bFFhTT1v+gZ9q1Oj40GH6HqpV5nvJ0OIz3TjSjVuca7Ga6P6g6HCWUmH++AkQ//L6XkumVmmB7eaOze5BDNe4NjNbB3rVpHni9aefOP3977jQqABrJseiFfZ4wY4ZvHW4vWDvtRbq8SzWqlWcb7ffYkKQ5MR3Cm6IC3VdKDkRUyHcPbYDJDL2GUetSYixCtOXj5R1VsxuvmTZV8KwwY1bSXrmFW/sVZ5QLzrRSjOpOcIw4PtO3892ZfKytmlnIa2RaqwazqRoX+lxK67ryTmzHE/krO1NLYXlNDXUmJMO+Va3utWtbvWb1Dc3omEUbiWvkRyFGaoxKzpzaszLXBso3Sr5pWqiU5MeBikm7LJi3jzS907Z48bgN4Ky2zb9EVOyxTyeTyyvr7z++CPT0zM5FTWPbRWJhW4c2L27p99t2b19q3VtqeRlphqL7UZNUeJKPh8oiyZKco9bNY+1KkZy3LX1bQOIGwNeaU51XdQQH0/k8wnTwP25Vj3Iu46cFadJLtT54ratypCvRbSBoSfstspMj1GrUsRlrZfMe+NkEilGxjBr1azRHsbG4oaOft+A4mjNX8mUktWMHJ5ZX56Ih4OMKH1oBrMq01NLL6JUcI0n2TartYLJUZnwqcVJlovz3bYQAGWslzU3F7WTNKNp7aDpXK1l2N8zvPlA2N4JoZMzJa1qugxqmKeJeHimpiQclh9liMnSWeK0So/HF00I23TzwrWtssWDcWq0aDKAFKXZ9IFS1WTMrwfimgj9IDYliN6Qs5qb7YZuu1G6UkP+1FWrdqrWvPF8wtJy1d3X8AbB8fU9kP5UkZlmHHDeKZkpyentQqDf3+GHJoG4ECKqNK0lrqzLRDwcWrqS12s0bTIIUC3h7pGw3VOXSZ+taf+W9ZSYmF+fOfz8I/PzF7yTI78WQ+h7cqmkRXn1oQ/afPjwD6Y9wAkrZTtHf7fB970MQnEhloTrRkxcmA4HptcjaYmE7Subd2/FEbW1reYrMSfS6UBNioiVFbHJAZwjt++uyemqTXZd0HctruR5xXUeHxwu9LjOC+3k9WfSaYIiI1WadYiyzpDX1KaiLT7YO0pRClyK8cpyNbYS+g673dDvFWxxq1vd6la3+m3q281K8wpmJaUix+m6UmO6QuxLozhZZyBIq1ULgtS3B4Ax5jrpDPs9fhjlejc05iXg2xr3PDG/vnL8+JnTpyfiumrV3yaLJgTC0DPe37F7+0jYbhFaXCakahzViwlaU6ScD1deofFNV2namr4fxFw0wgqZy/Qlt7jJeCbOE3WdKfP8tRHoQkuJkV6uVLSmzaX5McxVnynUUcB3XlpH565IJHIzsxQZXfK6Npe3uSKQLuzLisH1QeiaTtMzxYh6bNAKPy9n1pdn0usrNa24XoxTUwp5jmqWc8E2Lqt6N9fczBWMIikvpqnrhNHai89E61nfJslOWekA1rXUHGOpuTYc0wa/vcd1Sm6qVDUdtbSEnkiejuR5USMAkiY0w1OtjTe7LloPl9J0x64xKhvj1Ng2nbPNjNa0wC2mNC4Ly+uROC1AVbOFErJq1fXotiNhM+K3G62KrRVoftXnSinUrDxyiprjihKmtAcQuxZjZE7ykgWYoBhc2v1vnafbbHFdh+2kPTamJVoBpVTW05F0PlJrJWw2wmPNi75o3kFncZs93XaPDR7iDFRMcNc1dHx95vz5M9PzF0pc8d7hnSPHjPMG4x1mTVftqgvdNW2InCSFcA4/KBzAd0GGRd8iVUumNHd+Ok0cPj+xTKs2CSlxziv57k7osK5X5GlaFCvrOsk1Cpp6F4H0l9cjZdGk29Duk6q0LmMsfvD0+1H66FzbpBppWJMwVHnNxPNMxeDbZiIvCspwXki4vK6SEeWLGa022YGnlELXd9x9+MCw2/2P/Za91a1udatb/VfrmxvReJ4oKZEWxXga0Ao+N4NJsFhQCotVfnmOtAerJob93Z5+f8ewv7uuQmlNC9aQ48LyfGB+eWF6fmY+nFjPC2mN2Jaj7fuezYPA3uN+p4ztxlepBnAdGNemSRGyHMzGerCBmiPFoLSm0GHD0B5okZKXq+Gi5ERpWeFxnsgxETpNiWqqVGs0QaxgayVP4jHWUpu20AhWbqQxtON41f3VLOwRRmgpg9bAKa7E10k4mxZXaJ0TJNx7fNdhul4rxpK5xFJeQPRlWcjrQjochJVyWmMbb6kxEeNKypkU1ez4EOh3G0WYNvew4N5KdFI0ZgDLdaWtmFWP22w1xTNKnyopY4IOCjUVSonYYUPYS6NrfNNwtvupJjmY8+lELVF6vxDASWtcS6YsMkmlaYHUYOUaAWqK6XVw4KIXtNJgXo1txmBDTzzPLK9HTcj/ITtc7MyM8w7X+2ag24oA0UxNeV3agLJo6l8br9Y7sWJzadPZpPtpHNoBRG5+2ybFNVdqlNTAd6M4m16ueyHDaK+5ktbl2oQaJznGJVKTWsBZ/H5Pt3/A9gOmJOoy/YNEJBDnmdPPPzF/+oU8n9uE32KdwgJsreSYyYuaN++DMuSroS6x6b5137mxI9zt1Cxb15BYhdJCIvK6sDy9ijE8L5Azvh9lUIqJ+fmZHFe63V6NvEG0hVovH5PW4YeJ+flAiQkfNO29pHOVZcJ5S3+/a3pQK220bZPnUilR8b7rNFEX/c6opiVWNWKCMZacL4ecciUmhIbHylRsF9jd3zPe7enGrUgBt7rVrW51q9+kvrkRXV8PmryVSzvRNJ8WbNCkrOQiQy316rz2/UD35g3Dwz3dZov34SugvmiVmtaF6eXA9PSF6eWF5Xhmmdem+1MDNNzt2L19w/bhjn67UROIelhcEP4GmSXKMkOKMnBofKc3YbTStsE3Q0JrWtaZWtN1rRrnWdO3NTYGaCUEoXyqsZhuoNTMOq1a2bfGXCk0Rko1I4apMsGDpnIXHmrlmtxyoQZYbwktnWZ5PYiNapV7f4nvdL7B3y8AcOfbA1gNc500qTbeYYcOYxx5zaRplYY3RbDSg7rQUXNhnRchuJohJkc1lbVWOaUlspCGtw+4YWg6Ui8IfzM6AdSUievaggMKrlRsv8UMW23qS6bkSFlX0usT6+nYMsrlilbakuQLOSXxPmvGZBm7ikHTWd1h12x7rJH0oTnTTalgnXSVX15ZX4+aorrWtNRmgjE6MPW7AX9Jm/KdGqCY1WDSJBMlNY3qRfebmv5Rk2K7vceFXpNJY6gxSULiNDWXQabHezWm1geZyGppXFdDrqUFCkzUkmV6K/WaWGUMmHEk7O8JuzsZnuazDlxG5jNsYj4eefn7j0wff8GSFZVb2ySwC9RaWM+JMieMEf/XX+QdOVGKkpZc7wmbXvegc4LQ16pwhvXShDZkGjRTmGMzDs1oKMpDGDRJNY3Lm7MoG+SMGwZKTqzPR9K04IJTk9+kC1hDzprM95uWFQ/UnHDWSapQMmlNpPP0dbodOnzwauBLUYxurcRl0Rq+oGve9O6h87oPnGf7+Mj24aEdSC4Rqre61a1udavfor59NR8z1ssF7ayhmsYCRVrQ2pq4HIWr6bdbTS3v7/Dj2DiH9sq6rCUTp5nz8xPn5yeW40Q8L6RlYY2RmIRQ2T/cc/f+LdvHR/r9TsaUuFJTwQ4DZtxSceT5rFSjosblYtSoFplDnMXUjPe1AcEvaU2SDZSUiacjZVmukxo1Qmj929bipWhiVWLU2tLa5qovlFKby9hjEaZKue32q1GpIZhsCMIAdWNzi2vKt333AdcPrKeTdKfWX/PRc8lY7/Sf0KsBLwWPpkFR3QbCJimVJy0LcZrJsQj673yLx1xb47Fep3klt3SnK5BcOkM/dI0X2wvDtEZqWqitQa1F8aoXjaVthi01Bwv9sjK8eaMp6OEFctLPb42AgPaSSpRSWKcWU5oyrgv4QQ2UrVBN/iqHMC2KVa6pq76y5MzcDjT50hA26UTJbbXvO/zY4fuO0Hf4YWy+sossQ0zYFKOkJJ1vGfP1+iOtC5jgsX2P6cd2vS4xoV54IsB2A27c4EL/dSbsHVgPaQEMaTqLaLDMuueCb5N8pwOZc4TdPd3dgwxc60RJa9PDSB9ZcuL173/h+PPPpGmiloLvnCQczrUmMrHOC3lKeB+u8oNKFTqtVHwXZH7rvLi9Tg5zHVREP0jTRJpmTX3R5NI2vJWp0v3aztHvtoTt2DTMiYxph9SMpTZd8FnhFM62aSuaWFqjmGBn8H2PG3ppl62VMQ/IaSEvkTgt5DVpYttCEkpOWCeZUK6FZVqIjR1cchEgvzGNM5Ww3bJ5+45hHBUgAEoqSxeO661udatb3erfur4d32SqBou1ElOSnq251i+Nj/OOcTeyfXxkuNvjxrHpCrWCN9ZSamF+eWZ6+sL56YXp5UhaU5t60B6EA3fvdzx8/x2b+/uG5tF6GGOxm734n7WQp4kal6uGEizVVCB/xRyh190ydKCZSjBQ1pX1fCSeTppMXdz6Rpgh03eAJZciJ27OmJL/IbO8JfVstvS7Hd5ZTBIQXzrLhnGqyGDRD2okro2UHOFiWypq0DhlwotPOevyByFlTJtuWeu57BWt82we3nL2jvnzM+U8U2sml0KJMiWFXivbmjNpjcLgWE2fbPv8LmtX2qrUeEe4fyDsGhNzXcV7vUwUraUUSSryGhudQA5tYxtcPS6sTx+xdcVUXcNS1eBTjdBAVU1sWgtlXjTVwly1fDovKBLW+NbkVa6TxIokIDUl8jyzHE+UJRKCJ3TjJUGSGqPeU9//QwKYnOI1S+pQW8xmnibi8azV/Tjqc2r3jfNe2krn9TlZ6SEJyk6nSpJhuh6/2TUzmSQNNIOe/k6kxMJ6fCW9fG73XeOwFmT0o2DCIKPXuJFLflFErhBeBmrh/PTCl3/+M/H19Uo78J0iSSti6uYYlXaWlOLVbTbkrNQz07S0rusIm0F59t6JtWo07a5AXqKa0GVWXKqV1tkFT3U6kEiK02mNHrqmES8C9rd1OsWynk7kRfeMadQEUmkT/YCxjjB0cu7ndl8ZdB9gKOtMPJ9Ja2MPF32pq5Ek4DIhX+PKfDjKLOlksnN9wBZN+2NMbB4f2b//jm4YtLGh6YxTVAzvrW51q1vd6jepb29EvaHWpF/6FYGlAVMNruvZvn3D9vFNYy3KBIJtjvSmuVyenzh//MR8fCXFxPm4UNZMXCOVym6/Y/vmnt27R8b9fWtknZqgUqR37AdB2Zcjta3YjG1mIAPk1pSOd/qzueW/15ZWhEwcOa6sh1fiSWaQEjPukovdDEwmeE1Q4iLzTM5a64cO5kXXwhg2339HP46k44Gyqjmy2GakkWHFd0EmpQuKqU0za0GT1qy1eM6atMpoo4evC46ynAnjI851mlgaaRgvk2Y7DGzGLcvzkfnwmWoq1jh8CLjBU3IlxQIW/NgrE92HK7apNO2eols9brvRatJYyrJcNYPGqBksRtOsEtsEOdMmYU1055R+5YdeCUJV6VK1ZjXRzbhWaiGdLqYRTclC32H7To1sKYLZB4/bbNTAZelYTYsGvSRBreeJnJQQZX3Q1MwYqjXkUvBDr8amsxgnk5AcdUqCwgIlq7mZZ2GKwqaFGGQ1XsF9BbJXNcCmyu1tUtIhqFTsuKPb7VvgALqPL8xQ3wOW6fPfiU9f5Ca/xKYa2xpWkSfC/pH+/p1ea1qVruUMdFutueeJ17//hac//5WyRnywxDXhe0+3HUhLpCbTnPoXU5LSq86nSWagmPDB0u93hKFvE96Aa5QGGhprPcpAWLNW3xgZC61zGCxpEi6p242E/R7jLCmmJqGo4HSQLDERzwq/qKnJOmhGxkZHuDTEtpne6kXMiSgWeVETGuemT24/ojbTn+/FJJ3PZ6bTieWCRnOWPEdcsIxDR14j++8/8Pj737fpsKJRc1Jja4LH7e/+B37F3upWt7rVrf7/1Tc3orUWUlFeu7lgl7xnfLhn8+4d3XajddYlvaVI75jnhfl0YPryhfj6qqi9lJnOi9AqxtDvNjz+7j13797Qb3dKtXGXl2Yw/YgLgyQAceIy4hIQH8Gx80K1go3bTk1kjRFSvP55MKS0Eg/PLC8v0t11DeGUlajjxgH6gZwT8XDQQ9cKkn7JLZ/PZ2zo6N7fEbpOE9v5TNj0xGlpaUmagIUQrg+4sq7UGsF3MvUYOdXjcianVXnrzqoxdRZTCmEz6iE9bPBh0ATaNFB9MJquWstyPvPylz+Tnp+hFJxzSndynlISpWQ1huOAs5oOkpNMVMZiUqU6i9uoiXCho66xpS9pklemWcaRVFgPr1dWpW3GqlpqMxVV/HZLGHqZidpKvEQ5sNXvG+bDmfX1SM1FkZvO4EeRDkqMpHXGOcuwGcF6Kp6aMul8bvIHS1pWlpcDcV7BBWzXSzto9JnHlmPutyN+6PChk6Tkku9eCyCcUl5nSlrIUbIQ5aDnq3bYDz1m6KVhPU945zCmk4kqR+qSMcNA//gOP4xqjoy5Nq61JKwLxNOR86efqYcX6T6NFeqsNVoWsF3PsL/Hj1utxlOUM9+0z7xWpi+fefnzPzN/+YJB36O8LJQc8aGXJNlKb2mNxfcbfOdIMbKkwnyeGILHdZ7xbke33TQMWVBUaxYVo6TEejwRlxU3jpqyFh3mjHPSnc4rlMx4t9GB66JfaNPZS8hBnmfSSRIOrKVWQ0x6794anLE4b/HbEYvW/nj79aMy6NASF+lbu55aNCEGqKbS7zZULPPhyHI6U2Ih50opibg2xJa3TKny4d/9gYc//UEHxEs6ld40thtg3LO8vvx3/lq91a1udatbfWt9cyNaYjNlGAh9z+bNGzZv3hCGQZNG46HKRWyqEE/npyfm12c5sJPWdutlhVsqw92Whx/ec//+nfBL3UjbC+shbi3VdY1ZOmFyliGj0BqySl0XTTAv7vcix3kb4Glqlmjcx4bDaTB4YZQ8WIN/swHfaQJ3PmvdX/NVr2aoLPNMBob7e7bv3kpw0PBDOCssEtKz+VENqulGjAttcmY08ULr7BTltKdURWxarXWt9/j9BmJqLme5hK/JMJcVujXMpyOHH39k/vIFYsT7jn4zCsdkDLkKWeN7JWLJPW0I221bBVtilJSg3+/xm10LKVghZWlf0wXnVInTmXw6N45luP6cmmU+sV1H97CXE38V/L4kIX6E3gosU2T+8oV6CRowFu9te/9yY5MS3UaxqpTSVsCJdHrBWk061/PKejxSM4rUbBO6kjOgla/txWzttmJfGu9IywqrwhdqEV4sT6siM63B9xs1xzE2Z7vBbbc6tOSIrRU7DkqewiiZyznC2zf0j29llMsZQteaUJnoKobp+Ynl088QF3FA66V5N1ftqd/f093d62DnGpLMotV/LpR14fjLT7z88z8TZ20Ahv0G5z1LLWy6HdY51uOMNa7JMi4SjIRzjpAj0VqGt49s7rYyBxVEfLAiIeQ1ktbE+elFk86hBSTErObbO6r3rNOM84bhh/eKqgWqdfqe14oxlZwz6bQ0CYoc6zIWGU1Fa6UOHWHT0e13MqQ1rTephRMMToak9azJ++W3lzWQ0WS2sXyn11fW89QMSQlHxTlDPwz6Pgwj7/7979m9e6vWv0JeZUzEOuxuS3Ud8fkzlsitbnWrW93qt6lvbkSNMfS7LZs3bxgf3hD6oTmJlURk2jQhzSvnp8/iWMZFLvJcmU8z67LgrGN82LP78Jbtu7eEXjpS/AWNJExPipk4n7EWwu6+TT4K1AwUxIYy2H6P6Ye2epfmqxYhdmiGk/XwSlpmDGDDQK4r2aSGTRJDtJQqPWbWvy3QesC6QqmZWC2b774nDEEO7hTVD1sL1TaYvJp0PwxqoOzFONR4nFhqSsRmNCkNiG+NvcYmlnXFOIN3HabbapXaGI/GBekGbWU9nzh/+sj09IV4PmMyGB+ESgqe9XSmFk32uqFr02qLcxYbpLuksV/9dkPYb8X5xFNzSwyqlWocJcN6OFEWrXKtd5qEueYQLwnXd/huEOQ+JUqNjbJQWtpOm6x9fmGdZxmIqjR9trPKNy/KMnd9IOy2bfKHkEwVSAnrOkrJLF+eiGvGWa9YTWNJKct8VSq26+jvdtKCdtLXUpKiSXOS674W6hrJc7xGO9ZadQhpE2vXDXKNtyYZ5+ScT1nygAp22NC9eUto+fKAIPjOtO9IIq+J5eWZMh/bYWkEWzA5URuI3QwD4e6RbrtXKpYx4GS+EU5sZT2fef2X/8L06ZN+zKADj+JiJQEpsVJjpQu6X3z3NZKXYkgxYrqet+/eSHeKmkXbjHclqQlfDtJOu8ZmLSlj20dy+bfKPNN1jm63xw1dk7lEbUTQfb/OK+vrUZNeb3WAjJlcIsY4QuexwdHd7em2myb1KA3PVRv6KrcIYW0cZPmqkDLegt2O+H5gOU+8fPqCNYbQeelCqc3Ar3CF3Yc33P/Tn+i3u6smuM5zoxuI9FCx5MMTusXDv/b3661udatb3eq/Ud/ciL79T/9eDvjQaSLZ8r5pU5bzyxPT4cT8+kpeFjUGOV/1WzZY7t+/Yfv4yPjwoAmo801/x9Usosbxhfh6oJYs9FHoCc5BnAWrrwYzbHGhbxO0+at+LGdNW6aJeHglzxOlCt9iWxKN7YL+vYpc0dMEVKyTExdrSUmNWLffYnvxMskZUiG3yEtoa7yGQ3JdwIZBWJ6Gkqo5N0Znbq5kpR/R+KnWGjUJ6L+7u0ehfWiQ9lplSAmBiiWlhfNPvzB9/KjUoVKxOEwnA02MijY0phI6Qf81eUO0g1yIUelBfrMh7PbYZhgSlD1BypTUzFM5EY9HqAXbd5IzNAxVWVYwlu5uq2x6I3qAqVXTXyuHdCmZeJ6Ip0sYgFP4kq0yC2H0+voON7amuTEfaQarskykdSXNi15nhdAPIhOAEEKlYENP13u6/UaszjaBLjnJKJUypSGnTG3mGmvVhFc0BW7A0tDL7a50rUZ7aNrBWmv7vO4Jdw/tdTRqgb1EQlryOhEPL8TT4TrZNX2n+2JVQ2xDj9/d0+3vsf6r+1+6SSVmxWnm/Mvfef3rX0ink/SvVnrSaizrNMsUZ8A2ZJIxbQLf0rRiFIvUDx3Dmwf80Cv6NKUG5oeSKzktxNOZw8cvOOfoeh1czOUAQjPrO0vYDITNRsZAZ6VDRaa6aivLeWZ9PUoPXCo5JVybfnduVGPqLf3Dvk3sZUhynYdSyDVTrcd2geHNIyWuTJ8/KS0s5gZ2EI/19PTC+fmoZDFrKdZgkRY6p0j1lv3vPvDwxz8ShlFT1Tbxx1hsMBB6cszU81PDfbmvaWe3utWtbnWrf/P65kZ0/+49IDMAGJlM1shyOjI/fWE9HACrSea6EtufGzYD+zf37N6/o7+7U4qMc1qng6ZgKRKnM/F0oEyT3LFdwNieWivTp4/U/YQzVXrRYSvdYlHk4iU6UOxB/VvpeBbexjlcL83p5aFbjKZCdV0lN3DCvXBxTSPdox9bxGOMzejBNRPbWKNc8BDwfa8M+BYvWVtcIDVTTaWUSMlRnEXrKOihbK1p6UZe8aLBY21osG3JCixO+tzzienwwvz0hTpNMil5h0mF3HiWJS5QCqEPdL0kAcaYS2IkpSoNyntPGDvcMH7FNJVybX4LhpQieZn1XqvMImWaKWvU6+wDYbtpphDbmJtGYHnXYPDLqmjX80ye59Z0B6yRscw2lBeAH3QNoTn2rW+Rsivr6UyaJskKrPSDxuq95VWfje8cftzimiHpgqAqMQm1VTM1ZyVfIakAxkrSYZQARpuzmdDh+g4bLglCbcreeKBq4neE7RY3dC0s4WKWawePlEjHA+vpID2jtYqeTVnmt6T1thu3dA9vCfv7NoX9qgGtJZHPE/PhyOGvf2N9/gim0o2SK4heUEhNx+wMWBzOe11jp0NiXmSGst4Stju6nfBEtjTeb3Oy15xZzw1NlhLe+yuJwm3CFQFlvcMPg7BeQe+90hKqikxfKa7MXw7E0ywVjUUT6KoUNusdfuzpdjtl3NNW9KVo4pqEmsI7+sd7ut1On87QE7Zb1uOB5fMn4uHIOq8sz0rMumxNbLAKu6CyTCsubLj/0+94/NMflKhlLKziABvjJMuxjjzP1OmIc0aNfAW4Ae1vdatb3eq3qm93zadMNdJBrvPC/PLMfHghTRMmJ0o2xLiwLtLLDfsd+7dv2L65p9/vcd1wNdbQfsGndSVNJ9LxtWk3m6P46jDWj3ZtomNaw4cVFkjaU6Fb8rq0/0RyvGjTLhgWGiexXJNggOuDRoYkdzUCOe+14saI82iFSKqptLWqxfWDIkqdu06dLg1Lvegq0yrkjwNcY11CSy8qWBdw3fgPDu82eWpsw1qK0FLHA+t0Ik5nSsxYwFwelMZQjKI5LQi9M24kcyhtkuO9dKtDj2tu4lqLmjHn1EhVS06JNM2aIq+R6+ir1rZl1etyfU93t8OPw/X66xq39zUMrMvE+vJKXXPLpW+NepVR6DJtss2lb0JQP5zkbq6pkOvMep5Yj2dqS9UKo6QHVKhJbnfbdXJqjw05ZKUrzMtKWVZqSQ1BlNQw16JpfLsOOUo3K92tbfpXJ/asNZrAWysAe9fjxxE/btTs6kZCBr0WCTtPrMcXyiyWp1pt0ya7qyQTw4Zw/4Df7mWKcfpeWNfJGBZn1ufPHH/6O+dff6W26bMbAiEor7429FdJCZer9MSNhAD6/+c1YqzBj75tIVq8bczkmiHmto5PrKeZvCRco1AMu237TiB82NBjnMV7J6Zs4wGXxlqtKYP15GVheX6lLIkutKAChCazRlKDsBkI2174K4R1u6ZZzTrU+M3I+O5d+y5WGd/QYWa4f8RaQ5xmlvmVNSVSTlij6FbfD1d99/Bwx/7779i9f6fDQG3xrzkrYa3baFp7OlCXk2KKvW+fGTKS3epWt7rVrX6T+vaIz1SYDi8sh4M0l+ssrieSzqWYhGB68yCU09tHuu1O4HVrr9OQ2nK703QmHl4o87lNZFpKSk7UWPDD2KYuPW7YqOG7rGtroRY98NMkGPZl5VqimkV7ccNfullapGMVsN02E0NtUYxY0yImnVzylzGiaQDyWuQ83m4V2dkF7MVQQYWcKVUpLaUIU0Rb32oy6fQf63BY7GjwYWgTYt+a80LLDGI9vLIeD8R11kMzFRmaLtGR3l8fqJaK8Q7nNvihv4yf5H7ugpBafae+MiVyw/hY7zBoapjaZ5Knub3uttIu+fpnw7DFBq/ppffXhppSWmKRAODr8UQ8T3rNTZt3abIvGfdu7HSd2wEgx0vTWGR6S5GcEzllfNfjB01erbOafGe9Rr8dvzaoToeB0vipNSeoSkQqOTWepdFn55U1XnJtpIVOuKJar7pUc/ns20HEDQN+sxWe7IKpMlaNmnOkeSa+vJBPL5S0NlkAV9d9rZr0++Ge/vENbtzqsFP0M2X8gjQdmD7/yvnvfyE+P+EMmFHGJz+Edg9U8hIpS2zNl29T/XqlJCgkwRHGXii0y31mmk6zWqorlDWyns7kNYuWgCbseIPrNAktFVwXcJ1voQy061d0YDGScaTjmXRWTK0P0u6Wqimn6zSptkPAN45tKRWD7pNSLtpQT3d3x3B3p2Y3xqa51aSYLK3o6edPTM+vWANdcJji22cVBN6vsHv3hvs//I5uv9PBo5SvTX03UEMgx0J8fYJlwjU8l/Ghfe+iruWtbnWrW93qN6lvbkS//MufictCbitSuOAFDT4E9h8e6Pc7hvsHwmYrziBwiUGsuUHL55nSIjRpWek0ZJEx4HqPDx1h3Chi0nCNzsTpIZmniXQ+kudZbMqUWm64flYYBtzQK9IyyrFvnBozN2g9WmNums6uMfkvbJhMhhb/2dbj3svU5AI29A2y3hpN7yg5k9Os9X3OLRveUovR1CoXnPUYbIvu9Jih/VvOylhVlcy0no+sL59lNqqC22tNmbHO4ke9luHukVoy08dfgax/y/jrpM8Gi3EG2w2a5i6aBErKoAlXtV5w8vMkVE/T89YiV3OpmmL5oaPbbXBekHFjkLZuWSgpYZwlN1i9eKuJGmUoMW2yVBo8PIxezY1tHM5ayIvWx5I/FKimmbMcXQi6Xl562moB43GOJhHocKHDXuIcY2qGo3SVROS5aYhNQ4thyGsip4rre/y4uQ41L7rKavTajBX/NQytmXctoMFY4cKso6SV+dOvrK8vmBxl6HKuMTLbOh+LG7eEuzsdrC7r4XJp5ColR9bnz0wffya+PlHmWcgo07BCMZKjgWpl2slZ3xnvlUoVU5v+yn4fNj1hCLpvnbtOXUv+GjWblpV4mqmpQemrpAUX+YUNQU042kwosrTo0JDSdXIcj2fS4azvVvsekgHUENvO43wgx5U4Zxg6gjetCbWauF+oC/s7AfVL0YTcOkATc0pmfX3l+a9/4/zpiZKiJB4GnHMUIK0R6z2Pv/uOu++/I2y3et8xqaltB0rCQDq8kF6f4MKlvfBcc2mkg4rdP/xrf7/e6la3utWt/hv1zY1oXpS9npYo97mz+HFg8+aR8f5ephfvxAC9ZLvX0rAthxafuX6dQLZhU64V6z1hHOWe9UEGFne15161aXk6CTY+na4cyBpzm3TWtmbzmKGjGocphUq66vo0kRV2yO92mJypJWsKWRoeCaMpFZoyuaB4S9uNLRGmXlfectpPYpA6JyC6U+55zTIj1Rz1QHYeY1tTYr2g7i6AFyw9Hg5Mnz6yHF7k2vYB5wMlZdK6UIvBbzds3jzS7e6wXlgr4zzx9QmDNKA4o4d+H6TdKzJumZbag1WMYsqZclQzX1sqTUkyf+SUMcHR7Ub6TjpAN/RXUxElk89KL8qlHQBoGtusabWkCih20VjCGHBB6VfGu6tJjRjlim7JWuKSShqh5iE3B3Y7rDgvlz0GF7zMOg16T27r6LhSlqVltldNsL2X3KC2g0lwmth3PbbdG1iPMbXxXit+3NDt9s0x3yallTZB9xjjiNOZ5fOv5NOrDhmosazGNpNawXY94f4NYbPF+ItEocphL9ePVuMvT0yffyUv56+mH2OZjhN5nYCCC4Ma86brdK5N/XPTLwO27+h2O7qh1/Tyshkoyqsny4wWpybByGglHlfJEZyFTnIJY107jDmZ+ayjxtbIdp5SCunLK+k86/7IhZKFPbuGG5Ax3pCisG6lVtZpot8mhrs7XKNL+L4jbHc4JwZwsXr/GKWV1VKYX5Ugdf7yJE5qrQRddeHTSqHbDLz5pz+yvds33bFiafMqioff76HfEp8+Us4vwrQZGhFBqUyVQjUOe/eA627JSre61a1u9VvVNzeiy6SoSb/p8f3A7u1bxocH/Haj6WdtGrympys5sb6+EI/PcjmXS6MhRNElBzpsRvrdXkzPhnEyxsogY+RejvOZ5fmlYWEuRh6tn6tGpoSxJ+x2WueuiZqFQTL9IBf4GrF9p9Wqs0LqtOlRNa7hfNQfW2sIXYcNvbSNofu6NkbNRU6RnCLiYDtNdFJWhrVVs2udJfTSYFZrpSl0DkpbSTvHOk3MXz6yfvlCnGZpML2mUDmtlJwJm5Hh/pHx8aFFUtpmGgmM77/DDSPLp1+xNeM2PS4oV72W2mIwqzRv1pHmhXw4KZigpV5Z7/XwbavRsNswvL2XNjdnLvnoNUd9fjVTqmFdlAl/eV8myDltq9Pwao1YW/GhIYS8B+Mwpjm1faB4Tz41LWWQYctYJ27pGmXeaX/XNPKBMa1ZQgcREReSIizXlbws5GUBYwjjAM61VCd9fn43KqUJGdWM91iqdJdZ+tFutyP0gyakJZPXhbhG3O4Oj6UsK/PTZ9Lp0DSwAZaVmqMauAq5FOww0r/5oKlrzW2bYNp9kKlZRrT506/NINRBLaQ1k0sW4sld0LkBUy0e05KNtA7PzSDlgrBXfrPBuhZ92qa3JUVMkXxmOS0sxxlyJISGPrO0yFN9hsZaTKnY0Ji1bfJfzrO+VyGQ5kU64CXiLtzadkDMOYsk4KzW3M4ST2cM0huXmFk5ktaV7Zu3jO/eEsat5D4tatdemkOkPz5/+cTzX//K9HwgxtIuo9b7uVRyKmwe9nz4T//EMA7Q9OZlmampxXtu7zH9jvjpF8p80Od72X4Y0wIYKoQef/egpjgt/0O/ZG91q1vd6lb/9frmRtQ5lKL09i3D3YOg302TR5bBxISOkhPzl19Yn5+o6yL9nfcCTc9yOBtvGfZ3Aqh3g6Df1qnxRI1giYk4n8jziXyeqEUPx0KbxrQHnus9ftgR7h+woaemyOvf/0ZNWUzFluDS7e/w40hNC3k+U5PcvdWYZmwyGFPxzisVJ/Qtz7xS0IqupERZznoN6ljbalb8SjDYpp/U1Di0FX/TqRbBO43xxPOJ08efWY4v2FrFNO08JjiZsKiEzYZ+v9cE1Ji2zq4oJlJOX5MlMQh3yjTHS/Np1qTVppFbO62J+HKAGNXkW6PGLCvasxqD24yKedyKm1mpTRqgfHNjDNUZ1uMivFZsoG9nRA3oHXVNlCWCqYShw2CvDWa9GHZy1v0wTSyvB5zz0oB6/Zk4z2KneocxigT13aBpt7NgPCWuAs63RJySsuJa49riPBXhWUuBtEgW4Z1kG9s9NId6bbzZUlrUZd+LifkPOKqKwbpepIKUiCmzPn2hzCelR1HJsTQphcIUcsmEhzcMD+8kKchRB6hugDBAO2TMnz+yPH/BVWlVa5E8whuLHQc5/dNZBhzXtUACRaNeJoDWWPzY0e+2+EEbCeM9VEXH1hQlvciZOEWW41mD3dBTEIkgjBvcOEgf2sIXrPNNQlCo00SJLSfeBpaXA8vLUdIN55Q2VSClhHXuqsO1vQdvqangN4OSsQ5z04xbSsn09/cM2zvdjzVTnblKF0yLOn35679w/vSrolzXQkq5TYMLS65gLY9/+MCbP/xObn8vvXdeZyhJG4b9G1IxrL/8BfIqTBj2akSrJen69xvc5k73e16py/Q//Iv2Vre61a1u9f+7vrkRff8f/wP941sxNSttHag1PV1PSZX5+Qvx6TNlWeXU3Wwx/WVykzGdox87us2A39+36RgyMzmHKZm8rrx++sjLjz9iKNx/+IAxnqIfqikbFjcMhH3DB/lOU4225tz98D2nX3+VXnS7aTihTD68qlm4rOqbmcRQ8aH76l5vKT7VusYRVNxkWee2wpVO0DamoqaYA4B4pa4l7rTGi+a6rU6r9unpZ04ff8G0KE6gtddFgO5+oH94YNjdtRV2xVxcxQ1qj4F8OpCXCazFb3dQUjMDOWovnVvJhfn5hbysiq3sgrSLqaF0rjzMHd1u21BWAOYKpMdWTL9hPpyYP/+iz7c1CS40PFaulJeJSsF0Xs1IaAaiIkMMzmH6Xnrh6UR6OeKHgTBKTxznSJwWTK34Psg4YqUpdcFi2rQ0xaQpnjHkdSLFWSv+VcSGbrOTEYpKqWiS6hxu2GB8J9lEc+2XJclURaXbbAibXdMAV2F9LDKbWUNeF5bDgTyfMDlJB5ziFRFFXCk47HbL9t17/LC5NlfGNo2zdVAiaT4z/fg36vmEC6FpaSssCzUX/DiqUT0fCPYSRtBRSmJu8HVTq6bu91uGx0dN93JuRj2jqXCbQKZ5VfxsTPjgKbXiO6u0Kes0CfVy05tawPh2yIq6O1szX4tlORxIp7MaPuOJqyQ3Jes61pzxm0GT3DVSV8kowFJrwfUecmK43/P47/8j/WZHubxW0L1lHdiO9fjMl3/5L8zPL5RUOR8mUs5YIyZprkpI++4//oGH338AZJCqxlLWNmnvN/jdW9ISiU8/Y2m8V2OuMcE6IBXoRjFlywo5UJdFuttb3epWt7rVb1Lf3IiO3/1O6UcpKbqxFvAdKUXWTx+FFloWnPf4zaj1XXO6gyEMI6HrMSVhxy2mH6WRa7rFPM8cfvqFp7/+jfV4whpNrNblJ959/6ENEwu+H+h2W+ntWhMnLSTUJA2YKdKbgVidWt9qpe4616ZWBvUGAe97NYvOt9VhUcNnIC0T6XAEUzGdlwGptDVeTuJidr0aLyMziHSnpjXahoo0gMvLF+bXZ+bTGd8FIYyskWM9rXTjhvHxgeHhURO5puu0xoLtGlKmkucz8fBMjQk3DhhryfPULoXHuI6cI8vrq1zwOeOMvYYG1FKhZFKt9Hc7hvttg8hrCS9pBKRpajQCy/TySnzRKtP1QexTK61vnFdAK3gXdC2MNa0ZWKnrLPyP9yxPz8TzBLUq8WnoyUtUU7GqkfZDIIxdm6S2NCnnKbmQD0fyErHeUuLCejwq+tWC6wdMP4hnGdWQ2b7T4SB0am6quWqUS5z18y5T0PCVY0q1GFOvqWHz6yuf/9f/N+vxwPbxnqHlmV8mqSUumBDo3v7AeH/fpqn5H7S5Xtc/Z5aXZ84//YSpBd+MW4onFZIJZyg5k85nTE5046jrUCvLccHJXYfrAsP9XvIDvjr4y7pq2puVmLQcj8yvJ/Ky0G9GragN+F7X/6JRrdOM3rLuaUrSISIrwjfHlel1IueMb4zSy4HLUAl9YJ0zrvfYzpCmFbKm76nJc2r7vt9//3vu//gnjPfkeb4e6K60ilo4f/qJL3/9K3Ge1UjPKzllcilUq2s/7nf87n/+T9y9f6fXa9Q8lziLULG9w+7eEk8n8vMvIhC4FnXr+yZfiZIBDFvJCeKk613K1Rx3q1vd6la3+m3qm3/D1gqcz01TKSD88vkT6+Eg40gXCBvFKYI0nGWNOO/ptjthYSpgB0zXCa2TEilGzk/PvP70C8vTizR6xl3xlcvrxEv3zNvf/0DYbPHj2NJdDNUaxAktWqvVSjwplhBbZHipyITkrEDf3mKddJbOB4xTg3DRbF4MPiWupFmmEetN0zeCKUZNq/bZGOM00bIC7NeSMMiQg7HkFJlfn5mePhMnmWdIBmyFIBOYwbB5eMP2/Xu6zUZu8mbeERdT6/0yT8TzKymtWGNx+93V1GVDp9eNYXl6Znl6xmKaE1hNA4mWxGNw25H9ww5nHSUVcsnYIHJBiZE8L6TzzDJNpHmV/nCUFtg6cSxjm3zb4PEbj2sUhVorBitZxbJgOg+5ED99pq4J13W4sWGBppWclBCFc/QbTUhtQ/0gqhX5PBPPZ2GY0oolU6u4pHh/PQyUVaxQ5y22gomVFuMkKUbJTTeLVtr393Sbsb1umlmqMWxbk3T69WcOP/9EPs8E78jTmbkWwqC/Vyp09+8Y3n3Adz2k9esXx/mriz+tK9PTJ+r5TBh6ShWb17QmkyS9pxi0CTKEcZTGsiTyMuOsFWpq7An7Hb5NmMFIctEOd8Y50rqynk7kdcVZS3WuLQ0kARFz1DcChNBN5pIulltEZ8lqFmNhOZwxGPrNiKmVOC/6rK3Yu8ZAGALGW9KyUopID9dpI9BtBvbff8/2w3tMNdT1Iu9QzO2F93v89JGXv/+VZZI2O8XWpFu58kuF3ds3/PAf/onNw700066jrAs1tiCLzR1m94Z0OpKff5W5zThKjjpUWws1QugwoceRYJ2x/SC7YgWokujc6la3utWtfpP65kZ0fnmh32yI5xPr6UCezpRVejA/DrjOf11pNq5m13f4fiNIfdM4Vip5nonLwunTZw6//ko8nsCIESkLEtcH9N2be4aHe4a3b5vesjmOqVoHt2SlUlvOuNFaENPMGkXTMuO0HnRdhw2DNGj10uzZphVFa/hlIq8L1ju6rZqNnDPk1NiXMjBdGlBjpVM09ZIyA2VZWOaJ5fhKPJ0Ejy8VbwPFV0rJlLXQbbZs3n/PeH+vlWKKlCrNm2n58DVnSlyJ51dKiTjTTE9csriFPoqTUoioCeedGtpmoKoVNQzB0u3U0NdSKEvGdAEb1HzlmMnzrDSjWavckgvWpKapQ5PJWnFDR7cdWzSjDha5VkwppBhb0g7kKWl9XiqhUzZ6LVUNdXufzllCf+GFuua2lmFpPc9NKxmvOr7q5NjGWVwXqEifaLD4occ7OfNzqVSjRCucRTghg++3hM0Ga11r5HR4qkWxnyVG1udnjj/9RDy+Yiz4cRBTwXtsCBRTMX5gfHxLv9koz76mhmNqU+FayesiLmyL+bQtR94aAdzT3BznKZNmxcf6vmsraq2gS5QMRlzYEb9VrOaFP1ovK3TUsMXTiflwxhpLP26asc7o/u+EvTIhSF6RwfReBwZjxOJNa2OSVuLriTSvSpoympqXIkmHdLqGai1xFbqqJsXsGnfR4eqg2u927D98YNjvr5uDC6/VtMz3HBcOv/zC6eMn1vNCPEvzm2OWhMAEhqFj++aB9//0R4b9HaCDW04Jax1u/4DpR0y/IR2eKMdnyXPad8banpIiNWpST5Ammlgw/UaNeCnNolfaVudWt7rVrW71W9Q3N6KHv/+VuN9rBWks1ndycFuDG7oGnK8ynjRHs7GhxXmqucxxZTmdOH164vTpE8tpappNcM6QU8YaQ7cZ6R/u2L59w/jQnKuXfPcLw7JkOYbXldJ0n6XkxiVtGd1ZkYG+63D9gOvUQH7lN2qtWEqS+SXHZqKo12YDZ6UpxIDvsMbhXBCHE65NsUFtQF4W4nxmenkWUqjmpkFsiVLW4Fs8ZrcVd9W0plgmpUYEaI1YjosazVUpTdJdemFmqtKD8ryS51kkAgSPzzFep1A4q585dISxF3Nyle7NONdY+jJjxdPM8vJKWeMVEO+7IAd9S7nEGLrtKLB9a5QxFoYNZl1IcabkopCDqACB0DA61ijStdQWYtDQUK4L18jPWitl1mSrtqYwpyjHuVEkqhqFgr2wTSnXmFVz+VzapE7xmzLAmNDhu83VdX5Ji2o0MXJcmZ9fOD8/sZ4OOCMwu+JLXaNCSP/aPTzQ7x81BS2a7JkWvVpbtvp6OrK8PlOWSc2Q9Zp2WquJYC7XGM4aFTPq2gQ5l/R1wmkMbhgxY4/vW/oYDY+UY0OPCWE0HQ6QC90ldhalT7neiGrgG5KpMXJth/SgWVsFTNGBcU2s5xbzCk2+URUg0VBnOWcITtsACilFTVXN188hjD2bxzds376T5KTFukqn6Zr3sBDPR46//Mz8/KQpaNGBh6pDhg+w3e/YvX/D3Yd3hHEDoQVLpCg5xTBihg3VWvLphbocm6yhfcIGHZpy1AFs2Mskts7gB+ljS6Za23LoE+l0/tZfk7e61a1udav/zvrmRtQ7YZcumrsKMlAE31Z6TlM4YzE5twmonPBpWTk/P3N6emJ+eaVMi5zqVHJrlqxzDPst490dm0fB8V3opQ8sRetUDBUZPUprQEEPURrex9hm+kgJZw2uG/T6QifTSYu+rG1yU9ZVjVGOcHGJ25YJHxMsGWPctYmxRrIAiVZre9ga4nxmPrwSTwfSugiqbWSSMtj2wA+E7ZZ+f0e32WptWU1DWzWGqbPNDFZaEzY3hOWlCW1w8yURp4n1cBI+p02zasl6eK6RiiVsBrr9iB87TQUvLExvmjwiUlIlF0M8nsjT1BoS01b+Ml7lXKW5G4Ia02aIIWnVLSORJeZKXGQ6q7XSDb2A67W0qWaDsPcdtu/pNhtpX5shqywrZV3Iab02xyXFayRqNYLjmxbtaa3HmMa5DJ1kHSnJcNWmoLo3O3wYFBfpfMOAmTaRA3IkThOnT584f/pEjVGGKe91ELEWUE662+wY339Pf0n+SYKkm6bdpEJeZpbjgXh8hSxTmrLuV6GJmkM+zQtxmsip4EPfpsuZFNdrs+e6gN+MQpwF3w4ITb5R0vXwlBYZkiimNccXpqtXLGwz6Rnvr027/gdLaY0zKVFqJU1LCwKgyU0MeV6vuknXdeScsMVpGmmq7tGmG9bBNBOGke37DzpQhtBkEl7yllIaGisyHY/ML1+Ir6+Yqu+AKV8PeK7v2L194O3vvmNzf4ftxFPFaUNiQos3DdIIkxe9jn5ocp+WyJYXHX6HXtsM2vS3adAVIyqdal4XZdq/vv4P/pq91a1udatb/dfqmxvRbr9rnlb9Xxu+wt6d72TswFyNF5VKXKT/PPz6keXlhZKUa42pSuJJGWsd48Md+3dv2D7cK8EoaFKiVkFNgJJjNLUscdHksJkzWryMJpXGYqiYvk03mpNeDz9NXpTElMirzCr8Y1xjlfWCWijzjOs6/LDR1NKA3Av64xWtVdfzkenpmfV8hFqaGaSlKDXIfrfd09/dE4ZRTMxSv2aYU6/a23qZjJYs7A6I+ek0kctrYn2VaznNCyUVTbiSDCMpCShu+45+v6PbjLjQWIwX3WkzmsTziTwvUI164dTSkIxr9AAlDGEMzjl8L8ORc/aqNc3LohXuGonzkeU0UVp+ufeaKmkyXBsyyOE3A36zwbjQppUIn7PM5GXWKrpJDmpujnNrpJOsLWhgGDShK+JNuob7KaXo87MO0wkJ5UK4UhFM10nzZxtH1UozOB9eOX38yPL8Ss0ZF3wzXVkuEZSm29DdPzI8vsePG72nBqU3Lca05Ew8KsAhrctXJqcx0n42o02eZ8q8kNeItZbQt9eHBr+liKPr+0A3dthhUAONaaghNXHUosSyRfeKG3tCRVnyRZsCGpPXtsOisGPSD5taqbWFEuSM63vCZovrz5w/fSKfz7rGGHKc8V3ADz25vRfbDpOltNW5uxx2CsP9I7v339FttpqylubGr3Lymwppnjl+/Mh8fBEUwntiXImLmMHWGWxwPH54z+Pvv6cbWixuGJoZrE3jXaC4IFxVPF8n5fWqszbCMFUwQ4PmtwnwtSEXrRVyJq2z6ADzdE1Zu9WtbnWrW/3b17fbQRvbs6QExrLZKrnFeJmTLg/jiiGuqyZLn5+YXw5Xs4R3rjU2lRACm0clBW3u9nSboaW4NKd9LVqFZiULlbT+QxyisuFpitLa9HbOu//t6jpnrS2b1q1maQxLjvrfSr1KTo1Rc2Uume/WEnb3iqP0XeNJ0t5vIU4n5uOB9XRoaU8ThsZedP6KiRruH+jv7vHDRqimKjNGNc1IpHcgwH7OrbERacDUep1YVQzL4cT63CbKRQB6LhPC1ODvfc+w39KPPbZlfSsTPl8xPSWtLIcT8XjAFNMaHPTzjKVaRTQ6awnbXi5qA5pIV6pzVxg+LpCWM+vpRFqlR3VWTXGOiVTBWovrZWYLm0FrcevaSlWOc1JUIlIzouSoJB1nDTklrVYNeO8IQ5uU59L0tA5babD4Js2wtGjOpgduDRhGhxrTwOXL6wunX39hef5CWlcK7Xp4p2lwLRhv6R/e0D++x292Vz2n0iAvTYxlPR1ZX550rzYO53ViZwyuKmlqeT2Ql6jr2/fXKNvrey8F0wX63SD6Q60NZ2Q1sSvSK9daiJfDSNfr34iNV+ot3nfCplmnMIdhaH/vYrbTNVMUKYS7e7r9g17yMGKHDfOnTyxfnsiruJulVpbDUSlclyjP1vDawZFzwvmO/YcPbJp5S6+5CIdWafetYz4cOP36C3memhJF8px1jawxYmtl3G3Yffee3Xff0XWS1Ziu0Q1ahr0JHevxRDy+4IKje3yLcZ1QViFQc6QsEyUl3O4R2w1wMSyBvu+0ex8dnNSEzrgWcXqrW93qVrf6beqbf8PGeaYsS5viGdZpIuz2Evs3HNA6Txx++pnTx0/UnEgpk9ao6M5m3PDjwHh/p1jQcVTzaOR8NhfdW4tqjPOJtK5Xs1Ebg2q92LAx4lV2TbPqIfRqLHPCVKGK8jJpJWq4Rn0CYM31AWsuRgzrW752g/Wbi16ThkXKzC9fmJ+/kOaz/t1SpIFsE0tq/Qrs3+6vk642TMa2B17NcouXEiURKG2FSKVW8M3Ush7PnD49UeYF5y4rRr23alBTMPRs3r0hbEekzqutMbZq5AyY4Imnifn5mTyvcve37PHL9Kw2bWUYOrrt0OQIBtoEWVnzVnGry8x6nqXhbIlS3kmrqylri2/dDPjN2IgHmg6SdBioKVMa3L0CKSfysgrq3vfSlLYUKRtkisoxUldNwi7a4FgrzluMM9h+VFRkQ/CoEbyYVbj+G8ePHzn9/DNpmq+yRWOMsFpIf+t3O7bffU/38FbxtetKTWtjuQZoKVHnp4+snz9hasGNSiu6TCHJGXIhzYuauGXVhNkHwMocVRK5IPbt2NNt+yZ/UCNrm+PdXBiy6yoKA+C3W6x1pPNZ18UZ7BCUtJstrkWcGrGL2q67ERIWHSz7x3d0d/dXtBFExvsH+mHg0HVMXz6zvryynM/YEK6HqlJp8HtLLYkwjtz/4Y9sHh6FYKu5SbH13TbIQPj66985ffpEe9P67FchvHLKBO/od3sefvcDw/4O23fgnRpMuOqSTfAsr89MP/0IpRKtIeXM8PBWRIEYKecTBYu/e9dSxKS3rpdgiJSbBKGwHl5ZjkdK+70jPa391/xuvdWtbnWrW31DfXvW/Glquk/pI9fXF/x2x7C/Ix5eOX/6yPnLZ+J5Er/Q65d3NwSstdgusH3zyPjmDX4YcE1zJzuymkDFf4oNmdaVmooeqhiZneHayFgnaYD14R+mslWmg6J1tpzmR0rJbbLRQdscrvOJ5ekVYyyb94/NuNGr2TC0CUkzOPhAwbI8f+b8+VfSrLQWrMV7D7WQU4Fk6Pd7Nm8flWPugx76mDbxqW1qXCglSnjQGq/LpNl4c4Wpr2ti+vSZ9fmgZsxetHylrfYLJjiGD+8Y7/eE0FaTVY2UsDojNReW85nl0xN1llPdNVQOgLcecianBTeO9Hd7TeKMvbrHa1owPuD7kTRPLC+v4oEarfLNBR+EJBfeO7qho7/b4Yam5zMWkwp5mZu5RRKOirzeZRWiqAJh3LTPwOMGxV6aChWr5sdId1uzpscVQ7Ge4eGR0A9q9o0EsdVIf2qKhZo5Pz3x5c9/Jk1nnHO4IAOP9R5rNdWzITA8vGPz7jvcdqf7oBnHsP66Jk/nmenTT+R5asatFk1qje7xVeSB6eXAfJgwpdD1Iy4EclobCUD0BxPCVU5hzOVeoclBaktVcsTzrHvXWkyvqW3Jul/t0ImyUDLeeUIv7TBxIU/SsrrttnFwI257R//mHb4fW9NbwBTxUyuK8/3wgen5C+fzSTKCoWsNpaQe1hqsMWzevOHuT/+OsNletavKmqV9zx05ZZ7/8mdOnz6KDIAjLisprpynFVOgHwL3H95x97sfCOOo692JJysSROOF1sr65TPx6ZO0006HxhIj06dfsN7jrZVyZ3ePaYc/vIN1hbxS80WeIPTb+voquYlFSW1tEn2rW93qVrf6berbd06lNp2enKQlF17/9jcOzpGOB03MGjieC3DbyZW7efOG3YcP9ONG/0bj82FoOfWaPsXTM2k6yyhziV8slVIcfpRD2zi51m1D/Cg+/KLzspgCldz0j20dF7ymM3GixgrWk04TLnSM79/jg9eEx3fCRtWLblSaw+nTr0xfPhGPRz3YKFeNaslqQvthYPf2Pf39g1aHzWgiQnjLRc8NaRTaa1+WlmzkcZf1fymUVFkPX1hfTiwnpTmFocM5S4qrBrXBM9zd09/t2+QvtxWnwXSBMi24cMc6r0xPB+Lrq8D2rk2drQwgpU1WvfN0D+JSWq8mRFrUE8ZW/GYLLUUnnk4CxrcpHUbRo7WRCHzn6bcD/X6nJC7bwP5pJZ9naloobepbu466Np2lDXSjhdDMREmmMkzGGMVnmqKsepnKmrTBQLi7o394IPg2BUWRrXReca3ekaeJL3/+My9//TumZEz7HHwXCH2glkJeF/zujt3v/0i3u8eEXp/lqsAAxdHq3lyePrM+fYZm0ilrVEKQly645JUcI/NxIq9qDF3fYzGkmDDGEnpPjJEw9vT3O5zX66jVXuK2oMVcljXpZx7PauKs1tNlXdsfbLecpRnKuiY4TS3hC8Hyp0kw+N//ieHhLXU5yZBkrEIajMw6VFiOBz7/r/8v4uuRcbPRpa1KURKKyuG7wO7777n73R+k+S2pSQAuKwCLcZ7peOTLn/8L6XT8qh9eI2laOB5PVOcZNhvufveeu999r+bYB0w3cjEQ1ZIxTszc+cvPxNcvELOIFl0HnYgKeV1ZXg/YENg83uFK1K874yGt1CgjFkUHp+Wo9LFS0aagFOqSG4Is/+t+u97qVre61a3+m/XNjWippQGzIUY5mct0usLL224L2zWAd4HN4wP73/2gqErQw02/6RuU3pJOJ6UypQueSavImpLmXM5hO6/Epr5v4PjKlQEa1IDW5ghPxyfyfMYEj+8DtdPULF0e1sZS5pV+t8dvNkLitFU25qsJp8bI/PSF06efidMJqtGqr0CNVa50mwnbHfff/8Dm/uEK2sc0ZqW6ZEAO3HJJkoqpmUXAxPI1QjInJRgdj5hUMAWgSNpoapt20qbLWv1b58irnNh+HMF50vEI1XD+8sT5yxcwDmstOWZSTLiho99tpMc7L3Tbgf7hTjrDKgNWej0oH3y7we/3lLgyfX4WgLxNeTHts65iLtrW0HXbETuOmgJbo4d6Ep3AUEipkA2E/VapRG3FiqmY6pumV025cVVK4AIZoGQ57q3T6r/v6B8fCEMv7WZOX9FBzmNa3vz502c+//M/Mz8904UARXrZ8W4LrpLmFWMMmx/+wPb7P+paUNSwYGSsagzSvEbOv/xIPr3KJFV0kEopXlOLaimczzPzywEfvDijQfGqaY0YqylsBbrdhrDbaBWPkYayIlNSi4ctq7BS8Tzh+x439IAOYNZ6KpUyR4w3dNutjGYxfnXyW4PznZrDbmT3+39PGDvqPIHXv1UvIP4KpMTxl595/fGvkNv3OiasgZz02fhg8cPA/R//HdsP3ysXfv6KZNO/ZajWcfryxOc//xfqMuM7j7GGskbympmnhRB0Tz78/nvufvhe17Xxh0nr9R4zLlAqnH/5kfTyRZ+zqRiriXF+naVDrxXf92zevbumlJWcMbVikmJMayMPzE+fG+XCNN0rOpCWSo0Lfrf57/29eqtb3epWt/rG+uZGNK1aRee4EpdZ2r62LjZGDmvfeVzfEcYNu/fvGqS9uXYrDeWnjiLHKIPLPH/9IZd4P2OwvdzOLihO8oJg0gMzgg0t811NY4kH0jRRS8aOLeM8Nc7mMmmV3w1gLeF+oynZtWFRcpEmT4bl+QunX34inU6AcugFDzfEdaEsK77v2H34wObNmxYf2ZpxY7han430cHk5q6nyajQuYtFqXNuGJpbTyvz0TDqfuEy3LIYueK3yk1a3m3d3DLvtNZUmpjMmBNzQy5BVK9kEpsMX8unUsD2QokgBzinve11mfAjsvn+roW3XY4xRUMHxhHGOsL8DZ4mnM/H5WU1Fbe7ny1zYSiPog6Pfi42KE/KJnKhxaajVSi2VdV60/bWOOEX6sWs6T5le9F8yi/mhF2MzZa3PDRD6Fp5gsGEQiaDvpTVs11uYoqBoyenE688/c/jbj9SU1YTWShg6+v0G4w3r6YTf7Nj+8HuGx/cY69WUtcOXMUbenpyJxyPzp1+pMcrEUhrAvZSW1CXz2fn5hTjNhDAQutY4x5W4JnwIlFLItdDfbwnDqIY+lWvmfE2NDVoyeZqIJ91D3WbE9Z0CGGghDeNAniZMn/UaEIZJ2fNFTb2cVYT7RzY//EFA/rhQQwdxbe5z4ZLSsvL644+cPv4M6bKVqG1Ca7DB4kLHcHfP3Q9/oH/zvk34T+Jz2osz31GK4fWXX3j+618wccF7izWmxblKkzvuR7CWuw8fuPvuw5WAIDeYUtOohRoGUorMn34lvTxBunzWnpqBmqg5kpaV8e1bNm/e6p+4pldlTEvwwjtYVuaXz9okYK+GzLSu+K5vLGF/xcTd6la3utWt/u3rmxvRdRWCJ6cqDBPgrKZXeCNo9cM9/f09492dOIUNR4RVgkyNC/F40DTRoDX+dXQCYKAlIPnmVr241i8mHmpRkkw1lGUlLZPGZc6Qi9BJ5MLzaeY///KZPC/su8B3797wGAJj44rKqSGdojFWQO3TkenLJ5anL9J8/oNzveREnBZcCOy+/47d27eEcasHvKlXzWCtbRVaZbIpWYBv2xBKtMlOLZBTJs4L85dn1tdjS+ZpislSSagJ8t1Avx3o9nu6saPERF7VqNh+UIJNKZRsOH35yPz5CefMVy1fFn7H9EN7rY5+u2Gz32N8IOdEnM+UeYE1YruA6QdqiuTzQoqZahx5bQzG1kxbq8l2t9sQxkGg+Qv14MJGNZZas+Im50XZ7k50ghozczwrTakWNbUX8kDosLVSrIVO2uBSzHVVHfb3dONWU2hrW6JVxdpwzbifPn/h9cefmF5fJEfWsQXfB7CwnE5YZxnffWD74XvcKC1oWSc1L64TdcFATonl4y+kppNkGJvjfxWRwMmNn9aF9XSmzJHgOrpBCVyKroRSEikbQt/RP9zhNgM1NhRT0zeWGCGJCJBOZ2qMuLHHe09pkZgy0Tj93JxwtUpGEDymZKoVU7ZmHRgJgeH99wzv3kumklbq2kgUOTcJBMzHA0//8hfOnz6381RtGlBaTK50qOObd+x/+ANhs6HWBGuLGQ0BXAAcKS68/vh3jj//iG/OfWmi41c2qzF0w8D23Vv2Hz5c//6FnnGJ7sVY4vHA+vRZ18d4vdd279dcMUa4p+333zHe3UOKUGzDdRUxetvvjryemT9/JJ2nxh7WZ5di1J8zFT925FqlGb3VrW51q1v9JvXtq/mUaJwavPNKwWkZ39u3b9jc3xE2m9Y0wgWyTb3oHpNy4OdJfm6nLPZLHyrtp8X6IJdvi2iENh+8uMWrXkua5ytw2wSnWMJSKW0N/WVJ/F//8/+Tv9RKv9vyp5T5n1Pl382R/9AN/OntI286z+At5Xxi/vKJ9fBMyZlSjWIhq6ZspSSMdWzfvmV8lBHJmLYatq3ZSoqelH6wUkvUv9Hy0oHrxLdUSNPC+fMXGbPmBecakL4xGStaLXa7LcN+ix96rVuL1vtu7AGtPSmZ5fXI8vxKXiOhoYpyLI0sJKSR7RzDdiQ0VFY1lppWYYtiaj8XbAEzzYAoB/SFNDml21hxIHPJxKQkqmAtxoXr5LONoai1kGMizis5rlrfW3cFzZMSNRVyjHSb4eoOF3MztYmrKAo5aaLs+p7h/g7fD1q9G9Myw6XfrDWzvLxw/PvfOfz8k3SxLYbVeFERFGhg6e/27L77geHxTTuYZGqMV2MNVTzX9XxmffksHFDXf81h5zLBR9djWojnE8Y4/DBijZOpJjd3tnOEcZQrfjNih1FNYkN9abIqkkCeV9Is7qUbBbK/pIEZJ7SUsWj9nmkNafmKVEpZ+tFa8Jsd/fsf6O4e1PDnAsuEyaVF24pScfz8mc9//gvL8UgXxAR1Ti70mDLBGPxmw+53f2D3Xqt4ctT1KNItY0WtWI9HXv7+V6Yvn3He4ruOtKwsUxTey+g409/fc//7Hxh2ewUbWCvJBwZB77U5WF6fWb981BGoGhmXGs6qUKm2Evqe4f5BEbIpgQ9YH2Qwo1KtGKxxmpifPlOXWdfSh9YcFwUKGEPtPLlRFvyFtnCrW93qVrf6N69vbkQvqTylKFax228YHx4YHx7pNhsuedOGpm+rhbIuwvIUTcRqybhhaBB5Gi5JD7yLY9mF8BXcfeEdtUSdmiN5mWVoyjKbGGO0OjMW493V0DQ6T18N55x5iZHDNPGXwyvn/8/f2K2R/+lPv+P/8OXMH4eO795u+MHCozVYXGugxScNQ0+/2dDv7vDDpjloW2dZpTsj1WvePVapNTTHvOD40lHWVInTmfnllXg4Nh2g3O01J0rMSqsaevxmZNhtCH2PDe3fNAbotWrNmRIT8TyTTifyNGNAD2FjyG2VWr3F9oFho+mctV4r9lKIhyO5NUnWOoqxlLRgKvp5Tp+F92ArmLqhxEg6T8SlGY6wnL+8UlOh3/QY3zdU0UyOC3FeSS26VeSCADSWKoqzdJ1XAMCFcVWbFjBHUlwBRxgGut2Wbtx8RWtV1NA6RXCmZeb8y8+8/vgT+XjUFNi3qTDShhir67358B373/1BusmLEQarJCY0TYwxkl6fSOeD9InGaxpX23SNQjWFdVpYJ63ynZOMw3UygpWam47TEsYeF4QpEz6oXkFbOmRlaU3nRZxS53G91sO1VGxQA3ox2ZAzIswKmq+FQdbauxSs93QPjwxv30mWktdrSMDF+EOprOvK848/cfjpZ9bzLIlG0qHPNRh82PZs7h/Y/+GPjO++k178kkhkPDjA6XWeP33k9PMvrOcT3iudigpxSTJreUkzdm/fs//uO/wgd7qxTk1jTi3owJKxTB9/IZ2edFgrTdZSkU49amIdhp7x7g7XkE10nSbaehMtZrgSDweWl9fr522a+x6je17yCIff7KBTQ1um20T0Vre61a1+q/rmRtSghJP+bsP4+CAO6GaLdb41nw1CjyaWOS7iGtbG+6tcTU2KGQxYZzStci2ezzR3eVsTXoH166zIx9ymjkbGmFqrpk0hyHWOaWlGHf1Y6Z3DxIgpYErFGYPZbzgZ+H+UyP/t//6fGSv86f/yf+J/effI/9FY/rhGvk+FfT8QNiP9bkcYNpgQ5BQ2Wu9eogBrkS5N+fRBjQJIspDVbFUDcVqZn1+Jh2fS+dxMFi09qk2PXd/TP9zT3d+JFxpl0sjrSk0t+71UcoW4LKTjJK1icLguqEkCgfmrUmrcZsD3Xg9x0IN1betf2x7EGco6a8XbBVzfaV2Za2PHlvaeEst0oixRzaLRIaKWzHI8Uil0xpLnRZD/dQGU8e5DwBoxXI3VQ9+ANIMOTedaQ6CpWMUaRxhG3DDSX7igxl5Xupc/m2Nk/vKF4y+/sDw/g0H4qVIaPL1yWcw7Z7Gdw9pKjlGNcbvXLoNrpU4diYcXqKvMR6loMu6DkpGiGsb1PJGWiMXgOwHkc0okoymasxYbPGE7aI2dM7XIZHSZ6AFKZDqdWU+zNIre0+02mvZn/RkTNDWusQUyWIO9RK1iMNVQUqGUitvuGR4f6XZijNa4NtmIrrOpkJeF+TSpCf31o7BeQZG6pWR9t4Dhcc/m/Tu2bz/Q7e+A8g/BC7TkK0ecZk6ffuH8yy9QCi6YdtVhPk2UkujbgWL7/j3j/ZsG/W/yihTVYLeJeZpnpo8/kw8v1w0K3mKdpawK1zDW0O939Ps7XNcrnnfsmlSDK/IqpZV0PpHOZy44gmtIQK76/K3F9DKPdfs7qnNKTmtyiFvd6la3utW/fX1zI7p595bx/o5uu8OPG2zoheWpSi/StDSRpjNpUT66aQijmjPVoKnnJevad2JZVr4mKpmLe71pHi+JSlWJQ5W2gjVaf8dpxlhL1w/40BKQUApNVwtDH6C5eGsR4F0rbejGgfX9A1NK/DgMvBj4z9bwfuj40xz5X6zl/3x3z91mowbKQGm4oFKaYerSgFunnHvaepemfy2FZV5YXl9ZD2fSsmJqlia1KCfcNLRNf7+jv7sj9OGrCcbrmsTXgyaXzhHXSMpC9piqHPLL7Ng6J35lm6L6vtdks02/aozkeVFz0CnrPM+T4hoxmn4ZR83t/V1g8fNMiUIRGdTk5TXrPZAJ7VCR54VYaBxTK+OM93gvM1eOmmL7sZMhpZYWOlDU7FZdWypYbwnjhrAZG4z9H+JAG6qLWpmenjj89BPT5y9KKwpOKKY2hcYJKm+cxTmLb1nteZqZf/47af/A8OaDdJMG4nQmvj5RGs+Uy/raOLB6z3lZWc9nUsyUVHBOmuZaIeeItUZKEmvxm4Fut2kud6TrtearFKAU4rKwPh+Ip1MjKzh9blZmI9Na5DQvWAqkBstvQHzxVZVkVaulf/+B4e17ESHySl1mpVddkGLWEueZlx9/4vDrF9bzucHnzddJMxbnLf3DAw//4d8x3D1ck7A0wVfCk/EBfMf0/2XvT2OuXdP0POi4x+d51lrv9E17rr1rV3XH7Xbb3e62ne4Yt2LLcXBMSCyb2A4RUixAJsayECAIgoj8iYWFiHAG/gQQRAEEQSj8CIMJhB9YjIkJHnqocY/f9I5rrWe4J35c11pftd12f1Vd1VXd9d6tUnXtb3/vsNZ633Xd53Wex3l9zd3HH5F2tzgvXu+SCxbZWIjVJLK6OGfz+DHx9Fyrd1Xd1kuXDYFmHMt+y/zyOXW/w1iv9IyolydDbQ1nI6GX9izf9/JziHpPncPkBAbG7Zbrb35Eywv92RkxBGrKmBjFa71IuYNfdcSTDT4GuSwbhxtWeL1c3p/7c3/uz/357p/XHkQv3v8A14lPEfNqaGxGhpY8j6RxohxUOSdDI1WQ5dLZ3ov6aSzWiApS5hEXD2lz9RVOM3UeVU3Vth9NWkM5hnWMMYRhJV3wQcJRAKYUfGuc9j3t+kadAhLS8V0gTTOGRnj3CY1G1/dgLLetsXWWrxj4Pzz9nC+Xhf/Y48f83tWGL/uIr4VUm0LIxU9mDmD4nKUe0gDGklNh/+Il0/U1NSWpILUOECi9MRK08JtIf7ohrNaacs6CaOo6rPHidbOGZZy1WtyoXxet65QVKs5hY8B3Ud5InfJQSxbf67JIlaN1NO/E3jBNsq429qg4icosIamSRPFL83xUC421xyGvtoqz0slurcHp89poVGdwcdCaTLV09JLut04VcmtoVYsNrJX5pwnfNPaDptCdrFa1ehXnZJBcFnbPnrL9/Clp3ENpeG9l9e0kCAXCNLWqolnvdcUuKmPTxqnJGsLmgrpM5P0tNS2aJity+TEeYxVdNk3UeaHmiqmVEGVIKUVasVwIOO9wnSeebRQDBWBkGNZWLEmzN6a7O/J2lIGoFqwzxNWAH6L+SDRVOWWz0KyFZrBeeuMFXl+pSGBuePNtwumFVlsqY1TVy0NAaLy94/KrX2e8uqG0qq1n0JpeSJzDBc/Jm29w9oX36dYr2VYUUf+pRsNcgYph/+IZdx99k+XmFh/lollSPa73AWmcCpF4/pCwPhXrinWyRl9mUWljlArRm5ekuzvyuJdLhBc/rHVWQo7KL40nJ+LfbFUUfO+0FaoJy9TA7uUVL375a4zXNzhnmbcj8eSEfujwiCpsEOtBf36uCC39vWWb1sfeK6L35/7cn/vzvTqvPYj6YS3A65olRGCgLBN5t9UOd8XYtHbcmhpnMdEphiliD1gfwIQoFr9O0C2HFXTab2Xd7HUwUU+YCdIdXcY9xhjiWgZQ268E31KrrPZAVpbOMih4/DA4WWvoVwNlTtRSiU8e4ENg6AearaSUZA3aBV62wvO7a37RVf6d3Q2/w0b+5IPHfJgTwRiqqjO0/Mpv5wOlwv75c5a7HaSCaxLEQj1tBoP1ET909CcdfpB6UpqwIo1BW6kaJRWm21vm2y3o+rC1RjOWEPxxKMQYfB/xQ48PnpoypCztUlnZo96DDyzTRLreYkrVAM+By/rqP7VV8jSSpok8az2oMzLAHT6eswxrYV9a5FJhDop2K7iuw4Ug5ICc8V3AxwAaFjqsyw9d7AcYfrceZFj1UZVAwQ5xeBxdZLq95frrX2O6upRu8SFimiS8QWZWFxzYhgsO03Wynm4cbQbUKl+7s+TdLWXay2vUytdUknowg6HVLCUD4540JkmlV1G2haogpIfaGqFb4YaAH3oJFGl4SxizFY2PkeeRZTeS54WckpAihiADZhRVvOREScuxPcwUqSq1q4izRgNyGkhanzC8+Q5+fSIXrzTT5kmG6VJleKxw9+wZL77xTfI4SejNiRJqlWsLMgifvvcuJ++8K9g0uQGBqvlyGfCUlLj++GP2L57BrIprq+SlUEqT6lJtYzPO4axjevEcamP11ruYtECahTXrIqUkxhfPSXd3GIMGFi1+iLRWsCEKM7cW4QB3g6q80s5lrKXmBasXs93LS579wldI2x3OWGqB5W5i3s1MQ2R1fkYMju5EbAzWu+NlthmDcZ42z8dh+v7cn/tzf+7Pd/+8frOS96JeaGJ63t1StndYo8gWfZOXWkknSB4nA6gx2qtpjDALewGvGyvKSh630oSkYHbrnPq2pKvceE+pmbzdEfqecHaGCQdvaRTFp4hK2Kxhd3XN829+TL25Oa41D//V9T1LP1JSZX12ivOOru/JNbFkAYi7AKvzU7bLyPU0MgNfLSN/bZn4gw8e83PW8lNUBixFAzGlZvbPr9g9e0rLGec7gvfgvHpmF6xp+JMNw6OHhM5BreKbrYa6LJRlwvURQ2XZ7tlfXgukHGVktoIJXriUzonKGDxhiNqYZDE2yOCUkqK1HH4YKCkx323Je+2r1welHfyH1tKqDKDLuKPkLKvaiuCrcsWahnFWuuO9E8yS84AV+4UOKqEfwFtyKQo+D/gg/x6IAkstEjJT24SLHXHVy7rZe7n0oJ+/CrIrN7j75je5++hjlv1eg05BktO5kueM7wP+GDoRlqVBe85LOhIb4skKgpMaWSMIr5Yzx+C/F4xQywvLbs+yG49EqsNkYr05+hCt9/jVgBs62RwYK9+uE2+s+Cml3nW6vSHPC2XK5LQQQlBricVGCeqlZSZNM2El4bOaK86A1+7zqsQBQqR79Jj+0WNpHCp6UVSiAa3K6zMt3Dz9hOtPPmHZj6piQ8NinSMEhzXg+4HTD95n8+ab4o1F+KJoBe1BnU77PTcff8p0fQ2pyNcCVLUKFL2UOi+p9Kj8V0ph/9mnLHdbVm++Qb9agZVV/PjyGWU/QpGVv9AB5Oef3ChJvNKxi/iD+9SJXcNgaPu9XGy85+ajj3nx1W9Ql6ThtoorTVjGxjJvZ5bxOY9/9ANWb74hFgjz6rk11ooyTtPn5P7cn/tzf+7P9+K8/m/YMtOwLPsd8+ULckr41XDEysgQavFdwGllpQmi9JkGxkf17MkAgzUCtb96SZn2CsAG0w5v4Pa4JjO14aojPHpDuaL2+AbU8gyaHd6/fMnlxx+x3G6pFroDTP+wsjfgdHhqLRNjYBjWDF1kXLQ32wX2ux37caJ5y5wqS90TQ+TZMvFvv/ic/3O/5idL5k9tTvixbsX+8o7ty0vy3Z34Za2j1EzLsmqtpWBjYHhwxvDgTNQnxRsdcDymZGyQ9eJ0c8t0dUNNhVY1bR5kBe46WbvnlPF9T1jL6tf5TlbieZY0s5H1vvGB6XZL2o+Shj/QCpwXldhIeCyXzHRzQ5pGDWRxBNbnJVEbDJsVYYhYY7BYISkgAzW1SUjKCei+5izWg9AdLRrYAkXsFsYaShLKwPDwXGkJTgVVae6SoVES9dvLl7z86tdo00ypjdh3hCFinCFnqZd1Q4/1hjJJ4YD1EUKQF2CT0IoNARs6WWWnIj5K5Y6WLOt86z0meso0Ml3fsOxmfR5kMDpYM1oVlbgZB9Hh19rXflD9bZTBukoKvEwT0801eZIGI+MdwXYYKqb3qtpW8rzQTMVHT50zvnOC1gqR5qThqKSCXa1ZvfcB8VSay1paIGtBhBGlnH5gmWZe/vJX2L14QUkZHwPey89PyZkQ5XG3w4rzDz9k9fChDmVFgPatHr8njGX/8gXX3/gaaTce7QPGGFwnZIecZEvgu47QRYKq49RKnpNsP3Z33H51S377PfzQMz/7lFqyqJIarMMaVUORoGCD/vRcPONOMGISbjLyc2fk+Xj2S1/lxVe+hrOCfDOmaqjuW5R/Z3n44btcvP2ObBvawUYgaKk2L/IzUirLbvsd/Gq9P/fn/tyf+/M657UH0en5M5bdjjpPYCSA0nKhOellNk78cRaHi4OsIfd7WdmuTkCxTNacKij9jvn6JXlaJLiCrDcb0uJiQxAvnJGB1KgSc1BRW2u0VGgVxttrLr/6VfaXL7HO4buIi47TPmJvDwGjSj2so2k4HxiGFSfrFd45Ul4Ecj6OXH3jU8Y8E55cQOiEs1krwcuA+ek08Q0af217zR9ZGv/IrvCm77SDUhLMDcgpYZtlON0wPDgjdJGWE9VafOywq15A7ctCo1JqY/78EpIMOrkUvI+4lSKcvKchYahus5FPlYUgkPYTZZnBVKxxuNiRUyFtr6m54IwTz62XgEjWRLQLnjSOjLstyySsT2OhWSil0HLDBU/fDwRvMc3hvfTRi6KZNWzmRU3MFTs4GXSKkVZMtQtLUbmqTbURTy/oNieCAnJWIfhZVTx5HeWUeP7Vr3D78TdxyisN0b1SYmvBWodfHzyVTnyhyhdtJVEXWW/bIOv+lhfxtva9BMB2o3iQnZPXV83k/Z7ldkteir7eLaEP5JwoWcJ51lrcEAmnawkj5Qql0VrBr3u5LKlSn3Yj882leGtzwQ8dLkKdF0zssFEGpTwnsBVbm9gibCNNk1S5Tnvm2x2+7xkePWT15juEzUbZownKIsNnKVL72Xfsnj/n2d/6Wyx3d5RShRpgxBPqnYSpWoHuwQMefOlLxGElITq1gEgZBXqDsWw/+4jLr32dPC6irFsD3uKio1nxP7sQCJ20m4WuOzJw8zjpZU9Qa61Wdp9+Q+gOBkzsZJjVnx/nJdFeU8KGSLc+kXBkc688w0onQAfNz/7G3+TqGx/TdZ2I6QUw4sdtWg3sguPNL3/A2VtvYtQSckDO4bwOqk7Dl3didbk/9+f+3J/78z05r9+sdHUlaJTQKUQcUTWLrF5diIRhrYnvTEuS8pb1b8LUIPV70zV13AFVGI4uq6cTbahxhK7X1aGu5YR1JAqrcbQ0U9PCvNtx+/Q5+xcvyMvE+mwDRtmiBlbeaRpaldED7NsY0iJr2KDKavSRWjK7Tz5n/ManLL0nUzl//12SCczLTFFfYGmVtCzc1srfnhf+6s3MfyGe8DOna5kDcsG4Jm1TD88YTjfyLdQKuUCT2kq/Meo9nJhv9+T9RMuSMDYY4rAS36L3pCVBSnSrjtB1KuwYmmmk3Va60rHYLoKzjHd7GYKMwXlPzeUY2mplwRhLyolpuyUvMyoGoSMjeRY1NnQ93abHWUOIPaEfqCVTcj6quTSp6DTBSMOSl8rUb6UH1CZJb2MdPnR0mw0u9hJ+U3/vgUtpY081jtunz7n+xtcgJ1abU/Hvaq0rNVNywwVBDlkarltJr7j6WOtB/bKeajxWsWDWRxkcjWW5vQWchN2soS0zy3bHst1RG5RmcdETY6CqB9l7GbqHBxecvP02JgbyNJO3W4y3+PUgw3cWfFXDsOy2tEUGQb/ZUIvgh9zQgTXCHM1FBNUmTV/NmcOTQkkLpRRCN9A/eczmvQ8EyZWSqIGaEEfDXcV47j75iOtf/or0yVcJSTVFboU+4gZHLoazt9/j7M0nsoqv0gRGLfL6cR5iR8Ow/fhjbj76iEbB9V5+BXgvl8ZaqVrg4BzYWgnDSi5PrVGmWRL3xonVo8hlo+t72iLcT2ljs3oRkstmyZl4ck5YrQVA7zv92oSzitI20rjn81/4Ja4//YwuRjVjQDONnIu8DGwjDANPvvQhm4tzeZ1oFak5XG7nCWIUtNXlS20avQfa35/7c3/uz/fqvP5q/gCbbg0TAiY4bBBlLAwDPvbyxtCaJLF90JFGUu95v6WOezBVf+mbox80pwTF4FYrwmajvj5hgkrDzauP05aR5e6W26dPuXv+EtMqXR/ohhNcCJTUKCWTSyY0ZBC1MozqaIS1Rnq/c6Y0cJoUzsvM3c0NJWVMDCwvbtm1T1m9+ybEnnmemNNMaRVTCiwZxon/3/UN/+L8nP/yG2/xBx4+Erj2xSndqsMprNs6AYNTGyhf88AWzdOMUS8kaIjGO6xxVBqlZsIQiH0vl4AmWB9youoK1gXhW+Y0k+8W3GFFbOU/zUCu0gZkamOetqRl1tS8PDZGlaGcGxhH7AU271wgBC9sTu3utkaG2zQt+L4jnqywzmiQp+qAqnWnRpuqYhREVS8FCAJl1+56C6YbMMYzzzMvvvIVpudP6WIQxdxaVcwNtVbh2IdwhMW76LBBVPqyJB3AA4dWKWONorIC+CCf+vZKBrMgymVepKFKWJMGfMAbg/cWrHgFTbHE9YruwQXDxYMjYN4pT9dYwRY1xWT5foUfBqz1LNsdZZqoeREvdejF2VAEZG+qeBi/NdxTS6ZMi7wu+oHNe+/L59XHVY68sskFciZXuPnol9h+/LF4SWvGGAgaghLFGJqLPPzSh6wfvSEoKR1mm3JtbewEpXR3y/bp56S7W4XKV9k6aAtRyYJnC8HTmhF2qpXLAa1qwK0dkVu1gV+v8F13REDZoK1KVVbwLSWwXpqSOmmzsl5ZuE5Db/rzPG13PP1bv8Du5QuiD8cK2ZrTsSfeAP3JCU9+5MusTjfymjv8iYGGBOhMiNLcNk/49VpRxvdppe/WsX3EDR3p6u77/aXcn/tzf35AzrfhEc0yPGhTj+sGfOiklcf547pcGUO02mQdnhaFSltsP0BNUt/YwLSG63pMlF/0cXOibETFyVAxGjCoi9Qnjre3bF+8ZLrdQm2EXjyTDcu0X6hFvHXrBxc86nrcsytABkDhYBoZ8Eoh5Sy4IOeoTXxkKTrKEAXt0wV2Hz1lWhIn7z3BISv+siRYFtiOcLcn7BfGlPk/3Vzz87/9R3n44EKwTgorF86jeA+pMigvtzvmW+E3mgOf0RhJWhtJilcritPqdI2LsmpstVKmSYJdCMKp1UbOmZRmbEWtDohvsxlRWYvwCvKyUKeJWgumibJtrZGUcxIagvceF+MrPisSLKrqyWtVnufWKqHr6NZrjJNV6bElKBfxiTaD1XKAsFrjgtIGEI4mtWJ9pHlPXhZ2T59y88nHlN2eGMRLbLxTsLsMD76X4dQ7xU7pWr9MUlXaahUl3VpsDNK2hQTZ8KL25dtbCWpFQ5oEn5TGmbKIl9QHqbGVZ04QSiZ44tkpw5NH+NVaXqconB5LXK3JKVFnAeXHXpR9UytRWZfjzTXTVXrlbzRQUqKUw1AuITPnPKUhSrczDA8fcPru+wKUT8I4NYfHusjjmKeZeXfH/tkz5ttbITE08aK+atVC2K5n55x/8X36k1N5To0VkoW2dhkvFIDp5iVXX/0qbZ5kIEReX87J41pKUStNFEsFTS5Jar8wtojdAURB954QvRQJWANBiAdGiweqadoMVejO1jgnIcnD8ykBP/TjZ8abW15+9evM1zd4F451nE1rU30MGAzdZsOD995hdboBNJgUvCivKcmFLARqyYIDM+jvs2/xx96fX9exfeTNf+SnWX/xTb75b/17zM9vvt9f0v25P/fnB+C89iBaasVtNnQnJ4q5keQzCmQHdCUqqKSSiyTkrbwRGutFHVEIuHEON6wxXYd3AsY3TobQwyqenEXdnCam6yvunj+nzDNlzvJ3OsE0pUVA3jYG1g/WrE9PCOsVZ589JarC1MaZsh3hoYLfW6PUSq6ZznictcTQYaIoi/bzS6x35Adr8tUtN01CHi1lWBLsZ+ztHr9kzrrA73vzMX/6J347j958gimZkhfxwlWo0yT8x9lJe852lCCTdQJ0RxPexorKFSyuC/i+Jw69vBnLk6DDVlGR2JCP2KxK8FG8fQ1VIZt0yJeqSfpZk8BgrfgeW2syBBmHDw4fZV3q1ILRagYMzkchSBWphXQhEFdRebCKbbI6dDe5hBjjcOs18fRMVubKitX9syTTQ0crlenyJXeffcL++TOsgdgJU9JEGUJba7RScF0gDD0+6vdaZUgsi1gTQIZ56z22ixKgOqivGNqcaPMkvsoYqLky3W4p8yJqnvPiWXQOMY7KEOKH/th65fteFT7BS7WDOt3EWhKHlSraouIba4VHaQ2r8wuMD4yXl5RpjykomqtJW1ix1JzIy0JaKrbvOH3vXU7feQ8XB2pJQoqoRZPsSE3nOHH76Sfsnz07Is9qa/joj1imBvih4+Stt1m/8ZYgrkoGd6hB5VjOkKeR/Yun7J4/pUwTzhgB6lv1bFvxwrZWsf5VxahpVX43WKvWAhnkMWBjR1ivlGtqtKRALzdGiyJKERU4JdrVNa1UwuYEH3tRLXPVi0Fm+/Il1x99Qh1Hwqpj2UuozisSzDuHiZ7h7IzTJ4+Jq0Fez4bja8XoZbFZaXJatncSmnJWWMiqEN+fX//pn5zz9j/+swC8+5/6eT7+X/5fmZ9df3+/qPtzf+7P9/28flhpXAh9Y3N6oUOorFTN0X8p4PRW8lG1MAp8p1ZaTvIfDG5Y4boeG3sJCBy6pXW130qSte9uS9rtKcsiDUvCk5EVsLW6crbYIEzA4ewE75QD2Cq9gf5QH7gs8sZNU7i5KCfzstDHABY26xOCcczTjH92C9NC9W9C5zGf7AVanguuyjLUG8PDIfB7Tk/5k2+9yU+dbSQwYq0wM0uV0E+tpN1IXiQEYqp2jOcMXlieRrFCNnp850VNi1G7sKskpZdZMDlWOr1rEn+tMUbVLvXASsUPNRXSIoMrKAuyyqreBmm0EcyRxzuLM1a6wUOQZD3oYOKOXlNjBNpvoyTCzUEFR4bCMieoGTesCSdnspZWXBPOw6EhqS40IO127D/7lP3zp+RpEtyPc6LWGgT5o7zObr3CRo+1Vis3D5WVGhL3MjyYIGGpI6S/ijQowSXBGlVrSeNC3k9SjmA9TlFG6FrXWIvrI/FEh+mhV5Zu06xMOyqSQkDQKtWA+DaRUI482fVIcBCQfxIVuRQMhtCLUlzmRktgQ2Tz6Jz12+8yPHgoH6JIs5XR5jEQdur+6orbTz5ivLqk5aY0AyPtVJ2UHpRS6c7POHvnLYbzB8fLQzso0xhwwu6drq/ZfvqR2GlSpqZGMzIAGq/3iENfRW5QwDnDAZNVSzmWpOneG9tJoYV4VRWJ5MViIvYBWbTXUqR+tjRqWxivXpKnkZAfENcbrI+k/R37Fy/YPv2cshf10lqD9fJ7wcUgpQ/Wsn78iNMnj+Xion5djCjjBsB3whC+uSJNMyVpct868dTWIraB+/PrOraPPPmDP3n83xc/9WWu/l+/eD+I3p/7c3++jdV8s+Ttjt3tHacPH+jaWQbBVopWCB78bfphjx42IxWd1uH6lfTTH1Kv2h2PcYrEyaTtHcvtLWWeZb3sLL7vWTnD3ZKOPrPYD6wenNOtN/i+k9aXVo8x7c55OifBmYNdwBoj6zvrKKUw5wVj1mAsJ6sTToc1+ysJU7VNpAYrVAB0xZ0rNQZ8sDwInh8vhp/YZvjskk+N4dGTh3Qx0p1sAMO0HUm7CVObqGQhKCqmyYBopa7QDz1x1eO8NABZ9eKVLL3iUnEq4YtDqYA5VEUa/edZ4OVF8UdpTHIxoEnbUDMSZtEmHWMOXeVOFcCmflFwTtbZ1ZrjhcLFDjUSyFB58M81oOhK1Xq68wu60wtsFK5lO7RtWScwdGPIU2L/4iX7A8AcfXw0uV6zIKGo4CI464VJ25oMKy3TysECazC99IvjnahZ8gkF6J6zfN/eU0YZPHNux1U/Tril9qDq6dcSNhv6i3MNHwmvtFlROFspEporMmBbL37V42B+qK8EoIL35Dmxf/Gc5ealKnOWRhMklzHUJLYVGzvWb73D+o238KuNvK7TrFsFGUhxgTxN3H76KdvPPyePuyO71FhD7KM0UJVEc56Tt55w8uQNwjC8et2gnkwnz2erle3Tp9x+4+vk/V5aqoxc/EoRjmxD2LUYS5kW2mEIPYDllR1rrGwDjDfYGKXcoIgqLcO+pOHrkqUBKmdqFVtFy0UVbLlczbe3zHe3+NUp4fSU+eaS6fqaVgrWW2ou0MAHaYRqtWJjZP3mG5y+8UR+3usB4+aknCEEvaxlDftNtFIlqa8ILdMaLupl+v78uo7rI49+/+/4Ff/syT/8u9h/4xnT55ffp6/q/tyf+/ODcF57EI0nK2wIzNdXjP2KvovUMsFyUIOsDFlF0882HH1WNY3kZcL4iLdWPZCqxjQ0oJBI80Ta7ynjJIqUMdjoBULdGt4HhtMTlv3E6vyc4eKc0OlwcugrP4ScVN0Lh7aUZjjElbCWXDK1NVLJlNIwthF84I233+Hmja8xTjPlfE0bFI6eM3WIVO9wzvDQWv6Bm4UHT3fcBM/fvpl4/uKOtx9f8sUP3mRdGrkU6pyxDVkXawiJwxDqGnbo6E5PCH2ny0J5XKp6LFteBOiPdI0bFH9jDDgja2EQFmYzLPNMGveCAUIHSu1Kr0Vak7wRxcc68KHTtbeUEVjvxHfqZb16aLdxUZqxAPWCokORDnoY4pkMCi72sjZPSQcuWcMb72jIGn73+aeM13fqHza6BVelW9f8zju8l4tDw1GXIjXzzmga3shQ1IC+k+Q7qNJboAlo3nWRZoSBm8aZnLIooF7aqfIiKfuixPoYA/2Dc7qHD3GxB6p6K93Rp9hKohQJ1Fjr5POmRNUwnCiYAoNvzjNe37D7/DPqMolntamPEfTnRC4X3ekpq7feoz9/gA2dILdK4oApamWhVVjGkcuvfZXxxTNayVi9IlhvCH2P9ZY0J2w/sHnzLdYPH8plQwVz0xq4g/vRUHLm9pOPuf3oI9qyyEDXZFg3CEy+eks3dOSUaKkBVupAnWC09HaDDV7QY8ETFe4vP5pGBrumBQ3TQl0EjVT18lRr1TCa1HU2RO3OKbPsn2FuXmodaj3iwNDL0wH0X5rl8RffY/PoodSC5syh2MJYZAjFUGZtckOJDkY82DXp96I4KlvuV/O/nmO840t/7o/9Xf988+V3+PA/90f5pb/yvyFd3bNa78/9+WE9r1/xeXoqIYaUmG5u8OdnsAjf0IQgaletlLRAM9Q8SZrWSjd7XRbMvGBdoDs549Cy1BBES95vyfOk6zAJP1iLwtJFQcR7Nk+eYF0gdBFAFLemZZBO1IuckQDKuKc3RtfJsp711oGTYaPVKmvzmgk2YAw8eftN8s/9Hv52/x+QTJVBdEnaXV6xGN6ojd9xOfPWi4mWGy/GiWmpzLMgaYbhmifVsTk7wXeRtCw0mTyoi9SLmuDpHz+gPz2RwcQgCpGueyXkBbjIvNsJSxGLUbaiCJGqYLYmCfztHWkeJbClfeGmWXKp1EW8cFh90zYC7885CejfB2HDgiZcZMXpvJdLhfr3ODyeNPUDg+0H4smJKKbWytBe8hGLgw6zebdl+/wp0+VLWYFag7GevGSdPV8pTyFq1aX1sv61OngjQ7eLXliPIhNLEUI1EkCZ9vr1R+1cLyx3W8arG/I8I1xQrytdDmky6S8fBoYHF8SzUwmXyc0F1PJx4E22qvSIg8+wyhoXawVwr+pzM4bds6fcffwRdZkxwUEXJSFfC9ZJLSVAf/GQ4fFb+NWp1tYukIs0Jh0g+k24uddf+zrLzQ3eGpoNeiFp+BBJS6KMheHinLMvvE9/eqrEBm1Hwgi2KGdwhrS74+7p56T9TgJHQQKAabej1kYumTj0dEOvIIQkXFYv33+pRSwnTi5ZOReMcleNMkttiKpUS+NSXQrNyN9tRQZTYyy0gnMW572EAluT0FbJtJyp06jBuqyINwMYXIhUGnleePLlL3L66KGo4LVCE2oEaCd9KeRpz3xzpxWpRS9A5sgattZgOylZeNVEdn++k2OsYfOlt3/VP1t94Qm/7b/6T/E3/8V/kzLOv8Ff2f25P/fnB+F8G6l5USm6TZS6xpywB2STkTe5ssiqMqeZskwSUmqiFoXVQGuNZX+L6wdcjFStlEz7rQy5cFyNUhI1qRLhHW61IR5S18ZCXkSJ08ENZzC+Z96PzPstlkZwlk1QxcqK19KYinMG5yy1VlKpXG3veHz+UNSYVnn83nuYkzXTMrMdt3z6la+xtD3WWt5N8FPPtjx6sSfPBe8cwyYwp8zdkvj8+R1vXZzgvCiRB8WylkoqkoDuzk8YLs7leykS6qoNSqnUcgC6W8oijw+1Sl3oQUDO8uaKMTQH827L/uqaZcr4TsoGZFBvLONCXhapoOxkGIh9T62NtCwE5+QN1zrViw3WB0LfSTiLQ85HVcijzUHWz/H8IXG90tCMKIe1vKqDNE28xPvLl+yefk7a70XNaga8oaYs6Cr1ZtrgcbZJK471NCyYKoNOKxirq1LvZGhH7QbOYbzB5EW66ocBSiXt9uxfXjHf7TDa/mXUH4wRCoKx4itdnZ2yevgAOww6FL1S3CgaEKuSCDf63EkQR1fdWiUp7M2eZdxx+81vML14Tp4F5+RUda2lyQobgz8ZWL/1NuvTM/l4TXruAbCH2k4Z/G8+/Zjbb3yDMs6vkFStie3FO+YlseTMxTtvc/HFDwiahJdhupPnWTFh0uJ1zc0nn2BrxWLp+p5aK9PtLctekvLrk41cqOYZ4wOhHyQIZqwUKeQsqKmUMNbgB6lrFYXUCqS+iae2WYuhisjcqgTqaqJZaWTzerGqWUJ2aUmUmrFGuuuXVKi5CBrKWkpp4CymFEyIvPXbPmB9caHPhYS2BCUnv1PaPMrGIGctxUiYKBeOmiWIZ5QMYpyR+0/svqNfrvdHzu/87/xn/75/3j0+4yf+0p/lr/+X/gfH35f35/7cnx+e89qDaOeF8ynqnfjt0DcNcqbME2kZxb9mLcZHyRY1o6qPhJmojf3LZ3Sn59T9jjTNAiMPQVSLnASCLvZAwnpNtzmTukrrZfhU36Mkkg34yDIvjC8/x7YqK27n8K2xslZaW7ylqnpijCHVCmkmtIG7/ciD0yxrUCxzyXTrgewN+7sblixvVu/nxs98dM3J8y2pNkLwDH3A0HBA7wOPL9ash06QSsuCj5HVakNtjdIaq4sz4jCI0rTfidLYkDV2k+7wkivL3R3uUE2qQZKi6CQXZEU+73aMNzdM+73YEg0aOBJM1DLN1NroVj3GO3yMhBBUoTUMpxuC97Kq9g6rQ51A6a2Ez5qujY08dvL1Vkwc6B8+kgBKzqpqGTVtygBqaibPM3fPn0m95JIk0QwymCSpZzRO1sq+01Yk52SGyBKyshzC9lKxibMaiPGYKAM3GtiywwbrxJM83W4ZX1yS55laC9ZasYYgAH5qwwdH6CLdg4fEk5NXKuhBJdNgUGtWeJxRVD5KliHQChO3ZblA2M6DM+yeP+Xqq1+hTZMMQYf2Hn1OWynkXBgePuTBFz8krje0eZREvHEaOjPQxCed5pmrX/oFds+fqx9TPb5OmJ01F0rJ2OB448sfcvrOu5LaX2ZFqkkYsLWGKIOWu+eXbD/7COcdZcpy8TONZVnISyF0Pf3JCkyjzDMxdFIzG2WwrNMMOYun1kLFEE7W+NjJq9YaCQ4t+UgPaPr6OTRMmdow9oAsQ9bhWbYGRfmyDihLppaGaRVvLSF4Si0SIDRgVgNPvvhF4tALbeHQwua8Dvby+py2W+b9pOQD9Q5XaFVCYya6Y1jJhk7avPz9IPqdHuMsbt3/mv+eX/f81F/58/x//vxfOVIf7s/9uT8/HOe1B9Fwciq/1IusFE2awQjLL+33spI/JK0VIN7QdfNO/sx6J56rBunmSuo7gzsOHjUtgmfxHrcaBJTfDWgqRvyE9hhABmfJpbDcXFOmSbyYqxUlZcp+pE0LUdfXEuQQr+gB8L7MC2sqU1643t2yGtbUmlnSwvXujpe3N7z4+GOsM3x5W/g9v/SS/m6mGIP3B29c48nJwOPzNZtVx9mm5+LhGf16kNW4deAj3WaND1IKkLY7ABr2iEiS7IhjvtuyjHtt7zGyDm+Q5yRqYR+ppbDc3bG/uWEZk4SLvMcHWWlSC6k28Jah6ySEowGenBNx6LA+CLqpNfxqOIbHrLW0kim44yAmARytOTQOf/6YcHJ2/HdBVCk1O4oXNGXGq2t2z5+x7EcJgmhgpWZRpTFgjdgNQhfwnQw6tWjvt0HCO8FLmt57GdZrwTrlfFppa7LDIOp8yZS5MN/cML28xnrH8PBMuLFjokwzthVMEK9vWK/oLi6kuQcdsnVnX1sT5b02sAHbDfK9lqS2CUtF1dJW5bKQK7ff/Ii7jz7WFq/DM60zqNpI4qpjdX7BxQcf4ro1dZkhdtCt0FooqNKatL+54dnf+FuQF7qhpyzSbGWdvK5LKczzTFhvePIjX6K/eEhLmYp4VM1Bsa1igaitcfWNr7P97FP6Yc10O2IQP3EaJ4yB9YMzCZUtM9Y5YjdgnWDFajPUeRHEkqrYDaQJzEUJI+lAn6cZivxM11q+5UJqNNQkjVdVyQuo11UU6UxNC60Ias0ZKTWgQSlShhGdJ16c8/hLH4qaah0mCgBfVOUs/mNlnqZlIQw9aZqPlcL6wpbXRPBAw/UDoRs4mnjvz3d0fuqv/Hl5/b3GsdHzk//yn+M//Av/2vf4q7o/9+f+/CCd11/N1yaVhTWLfw1LnnbMtzfUIkla4Qtaypw0+FFEiShVmJHWHRWpwyBpadRlkbWYMbjVmrg5wQ+DrvaQ9HFKqFQlSXM8890Neb+jVoHRG21hOuB0QnQMMWpqW5VEVZG6rmM33ZJSphnLV59+zpPzC/oY2e53vLi95fLlC0Kp/LaXE7/za1d0Y6ZYS3Cibj0YIj/63iPeefOCvo8MfU9U2H/cSL2hCUE8ZmlhmaXlxjkv4ZNaaEYS2rk0xqsr6pxwIWCNoHRyESZrcA7rDGm/Z7y+I88TKSVJXXuH80bwSSmJqhmjqJzGHpuTbAj4fhDFMCVM8LjYiS2iVa0yLNAM1spA0Q7qoXPSIX5yoYpYhsJR4TPGQm3UtFCWhbvPP2W6vhRmrLWieLdGK3IRyKXggsMFSxg6AaRrcls4kwAWt+qhWUrN8jo6PM9WYPauE7WlzpMQHFJi//KKPE64GCUlHiWJb+qO7W5H6IROEDcDw8NHihFT5BBOwy+i9LcqWCbrvdpBkqB/DoO3DuK261jGibtPvs5yeyPJ/ypYIWOaYpekfAAX2LzzNut33hX/5yIJfNOt5JalvuiSZi6//jWuvvY1gnPEzZpqRd2PQfy4aV6otbJ+4wkPvvABcRikplLVbbEOiBrYSiPNC5df/wrz5SXGO5Z5QW8EVAPxdIO1hpwKtUijk7FeiixUia9pkcvowW9sDaHXi5cxmEPQaUkK7ZcLSlWF3Cj+ykYv/NbyLQG9UmRg1fCTtaJ+e+uOI2MpUq5gXWB1ccH5F76A91GeQ29lBV80BIehpolaEmme8V0nVqG+E9ZuSVLqEAI+epoxOBuOZR2ilN4rdN/JiQ9Pvu0Z3hhDfHDCcnnfvHR/7s8Py3ntQbSlJOqKi5RSyPOdqKDOY4OoPGWeqUum1KZBF6cUFknXynpMVSxFvRQdgmzXEzYbwjBIS4u1r9a9CJy9GUNZMnkcyeNOQk3eY4x4yvJukrm1i9gYiKbjpOtgP9I4wN0Lq77TpLPh5dUl67MzUir88kcf4ZIovIuF1TTzE1+/5Ee+eU1A/YumMXjPO49O+OI7D3njyQXrk7V4Kq1gkJoP+PUJoYvUeaTs99L1Xosmqi3ViZLXrGV/c0ca91gc3kfxs5ZG0dV4iJHWGrvLK5ZxRy2CfMJYGUAN1Fpw3hM0oOOCwOab4rFi32t6XN8ZNDEuK9EiKXMvTU1G1UYV8HAxikK9Wh9MqjKIqWoprM5MGUfGyyvunn5OTcsRx3RQSg8qp9H0dNd7fIzCvWxVPcaayMdgncFad2Q5Cqg+SOrZWlHiaqXsR2pOlCWxXN9Sc8F3nQzMGMosiXRrLOvzM3CezcMHhPWg34D60orwMmVXK2xb0w1yCUuLeBv1+zkEbDCGimG+umT37HPqPMklwjVcZwWbVRplLtRS6c9POf/ih8TzhzIczpP6FHvFBBlaLUy3t1x/9HXGZ8+IztOMZd5P2ODo1wOmwjLN4Dyn77zJ6Vtv4byTwco0jHF64Tt4lBP76ztuP/uEMo74rqM0CBq4SsssAaTOS/K8Jqz6ha318potVRifpmIcGMQW4FeDIsesfNxSJNynKXpjDCUnSduXqpQFsLWSJxmarQ3UWpjHPZiG16FWiir0MUwJ5zRI5DyrBw85f/stbVNqoijrBeIQYqJBSok87uXpcq84sNYgvmK9QMuFKeJDd/S0yiblPqz0nZwf++f/zLfNYHVDx2/7r/9pfulf/l8zfvLie/SV3Z/7c39+kM7rD6KKSCnjllx0De+FM0it1HGWlKt38iZl0PYgK0qbvikd0sWtFME3uYA/PSWuT7QbXJLGlCwAbyOhopIzaZpId7fC9QxB1vQlSzpfhzbjHdYH4uaEgOG0v9TWl0qd5iOE31iL7SK72zuqlfpNi2G821HHkbOU+V1P73j/sy2uCaPwtAs8OV/z3hsXvPnGGSdnG2n56TqsERXIblaEzUaQM7sdabeTJLC+0RnnqVjZHC4jaZQwkg9RPLBVOKCycjbUVJjHiTQvtCqQdOulOUaqPXXQHCJxGGRQM1Y+nmm0JiEWjBFwu/OY4IXv6LwEXfRjmENTUFMouQ7UfhB+KClx4JZKsl6sDiUv5P2W/bNnjC+vRAU9tO0cXj/KBbXW4IIjdl5amdxBZcsC7m+KcDIC+rfOYqIEY6y3NIx+D1ptup8ESj9OFPVjuhCkd94aWl5kFdwqfjXQby7wvVgTfgXnVtPwtKyfI4gCWIu0aVlLs6q414wx8rrOOTPfXDFdX0nAToNFvhPvsATQKrYLrB8+4uTtd/GbU+lAT9LyZGIv3NimA+OLZ9x8/BF5t8U7ryE7AxZ850lLok4J6xxn773L5q23sdaoTQKENt+EBmCkvnV3ec3tp59ibSOse9KYxa9rZFi1wYGFvAjL1BmxecjDUskp6aVAHS7WqMLe6RAq/t2S0jH0A2C9Jy+TvM7Vu4lzlFxIe0lJe6+Vu4sEEJ23UgahBQM165+B/IzFwOrRQ04fvymg+hAxMajqW45kA4wVRuh+L793nFVOqVxwnXcY9diaELS6VFbzB+Yt8C2P6/153XP64+8LIeI7OPFiw5f+3B/ja//D/z27r372Xf7K7s/9uT8/aOf1m5VuryU1YI0Mm4iyUJdF3qgr2lZywCVJ4lTCHAonP+Q1nMX1PSZ0+NVKwg3G0TSw0HKipUVQMGli3u1EOSlFfHHOQRMYdTt0XcdADFr/GILMSinTOcuhBafMiwwHrdL1PdPVFf3QU6jq3dxj9nvevBv58cuRdy9HfGtsVj3vPjnjC29c8OTRGZvNCh+DWBF8wLiAix2+C/guUPZb8m6mzBJAEppPkyEbGQjzOMsbvtMENuLfFLVHhu9lnJm3O9IsdaGh9+JLbZI2b63hQ6Bb94TgAWGnWuvAy2q/ZQl06A4VZ8HosGcBahbvpXOCuFLrg+l7wmqDD1HWz8r6xL0aFFutpN2W+faSZXtL2u4BGVDkuTZqlajU2vDe4oOySbXOtOX6ildpxQdqnMVGT+g7zCFgU2U4MAd1NRdRQO925N1e/MPe4/uIUN3F81qLDNlhtSZuNviuV8uBHisNO+3ArLTuCKenFvWH6rq+6uODkednvyPt70j7rQzj86QUB0PJ0mzVGoTTDSfvvM3qwRNcvxbk2DLLz0i3Bu9prZB2I7unn7N7+hllWXR70HC9BKrykkijcES99/TrHlMW8m5LWJ/IY6VlDgd/7zLu2V++ZLm7wXeqPKd8ZJ9aZylNflZIFdOEVOWcPAa1VpopFGXQWmNpis/yIeJC96qlK2XqgfFpDM17clrI4ySXUiOVmbU2SioanGrknERFrVk9oI2aG8Y1csrUlNTSAG61YvPkCesHD/X3hlxYXqnuYnVpuVLmkWV7J0O5M6KGKh6umSaKrqKqvPMYF/TyN8ufG3267X2z0rd73v0TfwC/+rVDSn+v07/5gPf/mT/EN/9n/xe2v/jxd/Eruz/35/78oJ3X/g1bjXgMDYIiqrVISCOJn884qV60iHoq0Gqp1GsHBpB3uF4URB9lyDDWS+OP+uKOa/Z5Ju13lHGUdK1zmtiX1SVFVFDjI2HdE7ooQ5h3x2YXVxsrDIwzORdsyixzwq4K/dATomeaJloq1HGB55e8f73jt1/PPN4unIbAk8cr3n/7Me+8/YjN0OOdNPfYEHBdJ9WFnTBPTU0s13vyXnmozdCoOB9pLpBzpi6TrLaxopJywNiA6wLWGNI4sb/ZyjDSmuCmoj92zrdapSGq74jrgdD34rMtFec9NkSqrrpbQzq3rSo/+v+rmUJW7NbJcNsaLnjBa3UdDsRvaJ029hwUNMjTyHR1xXx9TV5GWdk2YXHK961EBR0MvJXnxiocvlXkYkMD7XfHaPAoBFwfj4pq0xVzy6JEUooOODN1XmSgC0EGEu9F2EwJo97huF4RNuvjgNmMWhLcIcSjpQD659KwpKghK6+3Q6UmCk0fb66Ybm+kXWkR4kKrTdbhVVBDLgTWjx6xfvMt4vkDjPXirxx3orgFD16Gw/HFC+4+/ZTp8kp8kqVhvaUbIr7zLOPCvBvBQDcMEoazhrK9ZUoz5ewB3cM3RFlVj/R4dc3N088hTfgQsBjS8qqxqBlRTa33MhzXgrPuiDuDgjEyQB42Cc5LYMjFcFzHNw2X1UX8nodsYZknyrIgdzClbGTpknfWUJslLbN8DcaIqguqnHJU/a0P1LrgVwPn777HcHr6KoDo5aIiVp+EcWJrybs7Sl44XKxaEUyUQS56zcpr1fogBQz6ecU+oh9T/bz3q/lv7zz++d9JON/8uj/O6r0nnP+uD+8H0ftzf36Ln9ceRO3Qy7CRxU/YalVjv4aUZKTSsIk2lRyYhdbguhV+NeBiL4xITSZLpY2oI8bLG1Pa7UjjRF2yNOloEwrtEGKRwTesVvjVRqofaZAlHGHUM2adZeMcblzYLwuMM9c3N1ycDDTg7PSE/bhnurwiPL/lw6sdP36XeKsanlxs+MJbD3j7rUc8eHBG8DK8mCZft9usiZs1zkpqOu/2lHkU4LcC+OUN3Qs0f7+X77UZ8W7qMG+txUWH8YGSC+NW6waz9tJbg/PC+SxFB6tBlCDrRYG1Xp5GZwyu0xXlXDAVXBfxneJnKsfeeJo2IlmrloaAHzay6rQSIpOUtShNcAjnVHbXV+yePRWrQ87HwApWRVNvDwI4FrT3PejmuyHRlKYXC6uNS/K1+RhFFbUc1e6DsnsMq0yiJhuDrOuNeTW0LpmShK4Qhp5usxb1XR/Dg7J7qKhFsvLY0EmgqZTjClnCVaJMGmdpWJbdHcvdDcu4o0wjdU5HtV+CNY1WGuFkw8lbb7F+/CZ2WB9T6y1NYoMIHuMDtWa2n33C3Tc/Iu1HLTRo+OiJfYehMW9H8lIkYNV5Yh91aJMBjlZJ11e0Uomn51gfuf7km1KDWQveG9oiWDUfA7VCmRaMQxXHjCkF5xwhyGurtCpY2KZrDAwueHyUUJn1AeO8KJm5qNK6YEMkaWDN6tBnvFAxirI7RRk10qakBASpsdW9vyqRwom15Arx4oIH771LvzlRZRqtq5WLCcskrxkM47PPaWk5tplVRWsdLkrGy8+bdQ4fB/ndZYzi2zxmWCkpQi4fZdx9e79Vf8jP+U99iXAyfHc+1k9+ibtf+Iib/+/Xvisf7/7cn/vzg3def+ekq0R0HV+bhli802Kadhy00M7uVismRsJqjQ+9vNFz2BJrwKBKI0xthXRzS9pKCMl4i++CVvnpVKMqlVsNhH6FjzJgHD6OvD01mjUSPCmVkBfCtFDSQmuN67sb7P6E1hrjOJJud7in1/zIp9f8dIIPNiveeXzBW0/OeHBxyub0RNbn3mGtp1lD2KyJqwGj6/48zlJLWl4NN27oqMCynxR8bgghKuIni0JrDX61xnrDeHfHdLv/luHN02zVdiIwHmLXS1rcOKyPWscpFZbmoDblRZpinCXE1XGIlxSxVktW4X6WWqTm82RDPDmVlX7ROkRjtazAHn2heZ7ZvxAmaCtV2oGaVrXiXqlK+jzYVsWfiqNmxX7pwNaMWhJ0jWuD9JFb5YzWWo+IH3l+RXHL0x6a0dQ68ngcXm+IEmmdoztb063Xkqp3h4uMDqC1SvVos6LSBwk1SWheV/XHUE3DdoFSG9PVJcvtFXmaKLNYL2oRlphgsyAvhdUbj7h4713i2QNM6LSVKtMO7NFDA1haePFLv8j47BllmQFR0UPXEYcO06BoKr5fSxnBoSa+ZkmtV29FxfSesuzZPd2Ri+HFN79JHHrWmxUtLfJ4N1HWa8q4Tri9dSn44DAHZqaGfGyB2oyCpxqh7/FRGraME4pAUa/3wV9sTWDejaL6o81TVjYlJR3KJxq1CWM35ywXjCJbAQxYzLGKFutJKbF64wmPvvAFYhePYTG5VMhLwIhXgWo948tnlCJqNFbYu0ZLEayVAdR1DmM8ftjIa2LcY4cVLSVqmfU5EoU93d6w3F5/W79Uf5jPm3/097L+8FdvUfpOTv/GBV/4p/8QX5//d9z9wr0yen/uz2/F8/phJfXklVyxzkvHuxHkCi1LOEXXtq3Jm1BcvfLkHU/RobLOokK4yLzfknZ3tCQreDfIl9VqBYVs11ag7+lPToirjXIG23H9L2D0qm/4kPZb8m5PyIWYs/RTG8Pt5y8pp2t8sFx+4xO6X/qUn7oc+T2h40fePeedNy94+OiC1WqQhK5B1J8uqgLbYVuljCN5ShT1sFGyNLH4SAuOeZxoi9R0Wl1pV6qEdaIT31/fM+9Gpstblr005cTgMThBHOVMLYmuj7heUuBWA12HxLskyZ2qh9LGI8OpkAFaqsfHybRDL32j0DChJz54QFyvsNq+07SPHO+0GUmGzfn6JdvPP2PZ7ySYhaVRwAsFwFgnPes08RlaizXi3RPua1b4lsFZGbZryvhVJ801xqnt4tAhbrT1CMqSmG+2OvRVHdb90T9aksDOodGdDKwfP8H1vVhGzCs7waGi9OBfdcNKeusVL0QD05qsxlPGKpZp2u0Yry9py0yeJ1FkNTUvhDFLToWwWvHwi19m8+AC2/cYI9ixhlbUGiPAehr76ytuvvZVlps74VumgjWNru8J3ksVbMpUIA49oZN1+sGDipGgH85Tq1y80jKxbHc0YL3uyDlzd7tlc7LSmkpDSVlfN4ZSCt0QZRD3XkNr8noxVdqtrDX4Lkr3e0MCKFZ62luTmk7nA5jG/m5LGme8lTV7TQVjK7koxq1BSYVci7Q0NVHx25KEyXrwCjvxDpe2cPqF93j4/hdw6jW3OiQ2fR2r74dUYHr6MXXc0XIlb9ZY63EUaEXoHl4QaDSLjysMhjLeYuNw/HNaE9+w9xRtfXsVars/v9bpHp3hV9/dAoDu4Skf/uf/GL/43/u3GT96/l392Pfn/tyf7/957UE07SdaM4rFCa/S1iCDEQj7sBbC+UOGkwt5z9dKw4Ym5lHsjfWkeSbdbqkliaIUolZHGlWRJFhQjSGeXdApRN0cFC6tw0TV2FaEQ7jsduRRqiQ75+jmDLtJoOsffcbu02ekznHy8RV/aDH83DtP+PD9N3j05ILNZsB78WPSGiZE/GZD2PT44CAX0nYk7SepGgwe5xwmOPx6zbzfM9/cYo3Fx06+lVIkxKtAbus9tSxMV1fs7va6nhcMlWCRLNM04b2RViSMeh3XOCcr+oo0CUkafjk+F77vcMEL4mnKqnDJKlyTQ2A93cOHooLSRPlzXgbPqtOV81AradwxXr5gvHzJvJ+lxadlZaQKYkeUM7A0vDkgtbwQD7IqgRpcq1RqM4S+I6xW4unLGYNYKlrKqDSGwbBst4yXV9IyZYO+dJzC8SUQVErFOMv68QNWjx5ibJTwDQ2c1GWK4KY1ps7j16fyeNdCs2pqTKIUt3kRX6F3bF8+Y7y5BixlmsnLInD+6LFV1u01Z4ZHj7j48MuCQ7IeXJRBrcnwjPoujTHcPf2U669+hXR3J73pVbyQrtfazHGkGYPvI0MnvNCWkwTLXKTqM2qtpMsPQPtSkqiT6rd01kCuLEshDoIes8FRF1HHQ/CisDpZ74tn1gk/lYbrRHVHW6jsIK/FlhcJ8zSjr4fGfHMH0yS2XyN2D3Ckeaa1igtR5+hMqwkrEXjhDZt29ODW2rD6ejr/4D0evPc+xugFxFhV6FUMtQ7SImzdly+o03QMtTHOckHse7lI1nxc+YcolbR1f0sdJ0wzNGuxsRP2qguUaSJvbwTyn+5T869z3vxHf4aHP/fbvycfO5yu+G3/tT/F3/hv/o/vGaP35/78FjuvPYi6ELHISlSCKfoLX1fsJS0s00yeF1I1DJuzw7JTThX1xATPMo7k/bVwARUkbYyjlKLBJHvkZIYHj+g2G0HG6Ir7MHQaI28gpIk6z6RpJC+L+vkMWEcHbKaM2U2ArABryrxdGv/Jiwf8zI+8yeNHJ3SdYRmvmWxlvTmF6LD9mv7BGR4deDPk/ciy3cuApenkeHpCM5bd5UvSbod3/jigYgRZhJG1Z2mNPE/kSYbZEKM+PE2CWlXA37GPhC5gncFHHdow6rOT/mvjLHkWS4CxHq8p8zLNYm+wBtBh/rCWdoHVwyeEtfrgFCZ+wOpgjQxnObO/esn4UnrSa674ID7WVpsgtNTPZw7LeWPU3ylKaC1SJGCc1bCKxXgjwbJ+EJV4njUMZajLIjD0WmhpIe0mfYw6mYWKVHIa76U9q1QahrgeGB5d0G1OZNbOrwZwqiixWFWSg6y4OXhEDTKo5iKv0SKqYM2F/eWlBL5yFv9mkmS+jZ48F4wyWk/f/wKnX/giNkuZAD6qVUWZpEZQWbUZxsvPyfsbGXSdo0wjxoLvLLUV5iTWiGE10G1WsqpOohDjPFUvcT4EoJLmmWk3YpG1O4gXc96PWCwhBubtlmVeWJ2dYNRGYA1ixbCvWtCMhsuqkXYsFwIty8+Z63t5nuoig2sRfm1pjfn6WnvmHR6EYeo8SxJ0lveC2krLQl3kd4Q1h3CadNOXfRJ1uzZMF3n04QecPHqEQbFs1hzbmkj6mnEdyzQxX1/CIl5dtxoEoYVaR1KmdsKqdd4RNmfye6sW8BG3lgsXiwzMpl/JtuPmEijY1gjxPjX/ax5jsFG2M9+r47rAT/ylP8t/8Bf+Neq0fM8+z/25P/fnN/Z8W81KxKA+SAnBQBO/4zJTswDVYz+Q88Lt0884f/Odo88O7ylpId3ckdWH6KKgU6iNaor69zINi1+d0J2cyNqwFFgWHWvFG2Z0jVYXYYuWWdtenIUib7bGWlZDz0kDezOBM3hv+NHNij/91mN+7I0H+M6S0g2Xt3usaSzjhPEdF48eMZxvsC1BlUFt2Y3Mt1vhpQK277DrFdvbOxj3WGPoh5UMK1q1CTKwF2BZpJnKOwnOuCh2Bus8ZUqkJUvLi3dCFlgNdH2PxZCnmUbFxkBTUH1VxJXzna7nG3UeReFR+oBVlJax9ogwkkEii7rkrAxmxik2K7HsdozXV9R5Ik2zDCPeyvdkMjnnY40rNIIDjFe/rgz7ooRLqAyg1Mo0bRkePMCvVkfvp+06amuUaXdMnZdlpk0LNRUlBTT8IcndinBla8U4z+p8Q39+husGDbtYTBelhjMlGZEP9PIY5TWUtU1IVTrSoqimLJW148h4d6OKq9SCttbwqyjD8yKDuht6Tt95i/WTt2SYDV7Wyq0cGfnGyNedxon5+gVl3uOM5/ThQ25rxToJ6NWcMU0GuLjqxC5xwFtZCzYKv9RKQMuYRtqPzHvxzDZjKCXjnGPeL+TU6AdHbo3QRdHElyQBKG0GM86qtCi2BEqhtiYUCOWamqHXDQWQ9fFUm0FpleXuTvFKVYKI3gmOKxe5mMRIrdp05Kw0XRmrVpQDp1M84TUXiJ7z99/j5NFDGYwPXM/QSbAuJf25ckwvXjC9eIbJsyimMVKUV9q81/IIGTJtPxBOzuX7qln8yV3AFEFWYax6ZjP59pJWkiip3mLbISZ3f/5e5+HP/hhv/+M/+z3/PMZa/GZguR9E78/9+S1zXj81j3gMhbsnWKI8pyPLEieBj5oWKJm8vWHanxL7tcCqb29I2zsRiGKUKj6Devt0fZ8rblgTT8+FBVobTKPwC30UoLhiYGpeKNNImUdZfWsD0+ENVliVEL1j5SyhFAZj+ZkHD/jjH77Nu+drUtqx2+4l4AI0Y7jb3tJPNzw0b2KbrHNLzpR5YtmP1FLljbqP1NqYXl5hWiWsBsVbGVHUigzVtUFu+Qg6d16A/TVXrAn4XtbItRZJgLeGD5Fhs5FASC6UkqlZEsXi42u0YlV1PdQpylBqrZMVa67SRmMNftWzOj3Fd70MnLqibw1lmDbaspDnmXl7w+7lC1qu8pgouN7Zg2fTaOuN+DydtRJKUUB8WZLijsSrWlsjp5mSZXjfP39G3m/ZPHkD5yOkmTruxHfZDG03iYfRebCifNsQsJ28vpqmsf0w0J2d0p1sZHVdkYKFAyO0FlkzYyFI25QpB6qC8jazDDWSjs/keWS+u2OeRrWFZOqiLUDGKBdWhsP+/IzT996lv7gQLzAWYzzkDMEfQ3mtwXJ9yXJ3qeqi2ACs95w+OOfu8opxSphqCcEynK6IgzQ+SWDHQi6CtYqi5tbcmHajBOEO8HoLzjmmJTGnhRg6CIHYachJQ1kWoQFoIyuAhs503a+1r8YJlcHqBbLkWb8jUdZLSqISLwu1VYHBBy+Xk+Pl0x1wrkiFqvBVS5bygporw1rS1cYY3DDw4P0vcPb4oSj1TmpcjfOigLYqJAcbWMaR5fIFJolVQtih+ZVvPCeIgdYyvlvTrTaQFuoyYbtefpfULNSHg3XIOPJ+K5fDYcXR/qPe6/vzqx8b/XcF1/S65yf+pX+Wv/Ev/E+YPn35G/Y578/9uT/fu/Pag6ih6srNkFOi5gQc0EISxKmqenjXUWplvLqknjbKNNKmUZS5GDSsJGtLeWuTN714uiGsNpKqTgqDR1puCEEtjpk8CSqpJnnjEeZgPTbxHJLeNc0wL5w4w1vna37fmw/4w+884KKzbHeXlLRIqttZllTF30bh6tkzzh48xDlZTZZvYVWGzYl0Zu9H6rzgnJHwVAiKDlrkTV7/L9cq61BFzRyQTCYEWsqUObGMkwR9vKfrIl0/CAooJQ4OT8EuIQOpafhBg0u1HlUi4wzGycDYKtiuI5yc0m1ONKQho4TxgYYn76W5h1pYdnfsXzwn7bZHL520zygaqUrCujaxEPhg8V58pc04CaE1HUA0TJVrIY1ykWhVPp4xjmm7x69GulXDLHvaPFNS1RCOtmDVRes8o/BGa6NlafSKpxu6szNcPxwFPRO8KHc5Y1qhGXQV32OclSG0Id5Nmgyh+souy0wed4zbW2paJHxljCjPmrYuLZOWjPOB1RsPOHnnHeLJhXwIWwUJFDqMXUkTT4OaFuaXz0jbaw2sef1izbGdaXN+RkN+plZDIA4DNUu9q7FqmTCCTsJCo7LMI/N+kj9DLwsVSpLLoQtOk+Hy973WvioMVjiaOdNSFs92Q2t4Bc8kM5nTfy+JYiy4A7EpzAKpl4fY4X0vBQW1qqqtffC56OMnVIUyLYJsKrIlCE6wWGlOxNWK8y9+wObxI/nZp756bpuGveaZ2hrLfk+6eqke8SZ2Dr5V4VVErXVY3xP7Qew7RZVQL2EnWecXTAjSdrbbQV7koqxkg5YdNd17Ev9+Z/3hW7z7x3//b9jnM8bw2/9b/2l+8b/7v2L7S5/8hn3e+3N/7s/35rx+at47Wa/nJMOmH2SVmyWNbryX8Ewu8mYXZICpaVIkEAocd6+GJ9Mw/Ya43kgK33lR6lISNeughFgjCsxuJ+01hyGiKK/TWVHpYlT1cqG1KjDtUvni+YZ3V56fenxCb2amvYQ6YvSU2si5ChLnsIIrCy8++hrTduL0/EI8mn3EhECeE2V3BzRcF8QC4KyAypOsIHNu1AMEvYGJHtcFGW6ShHfKvFBmeVycl8ag0HX0q14bbYqmfC15zjKUG0QpthZTK3WWnu7jc1SqWBy8F8TUyYmooA3FJImyB8LJdCEwXr0kL0mwN+OIs6oo6uBhDjGnKoERayEEJ6qZFQWXkqlVvaA+itdXV93GGmwLNPWKGmdxrTJeX5J3jhgDrTQVsg61oKLsinKcaOmguAXCekU42WB9p4xa4UI2Y2BZgKJ+XA/GyWpWBx+Mwtdz0gCRpeTEvLtjvruW4U/kVB0WK3UR9c54R39xxuriAevHj/GbE4yRSlbTq/LXRIWmSiPQcvWCvN/hQqdwf2SNXpVV6hyUxPpkoJXuWGcpjVvyusJZ7UKHZT+SloU0JxlMQdVIuULVVMQH6QPOWHz0eC8DaGt6mQHykmWI08ujC6LM22+hMVAbZZ4VdaVhwNbIKUlgq4qqLp7AJoq/tXjvyEsmp0XCYKADrAS3jJMSh+CsbFmodKennL//HpsHD4FGU6i+tEQ0DSWJqr5MieXmEnvgvSqmSZTLQxDSkqYF4zo2mzNh61qLzemo3DNNWrIRKNVQxi2U/KoYoTUNiGlI6v78QB3rHT/yF/5JvvZv/Ltc/4df+X5/Offn/tyfX8d5/WalUrE5Y6P4Ees8HxVJexiOgOIF2C4qiKz9jLW0eHjDkFWo6wd83+NWG5x1omIdVnrHX/yG0gr5dksaR2EtGhk6OawSjRHPnHPU2khzkjfQReHZNfE7Hg2EYohmIZeiNBZDro15LpTa8NYw9A7nLUtqfP75JcPNTPixjpPVSsDf2y2tFKn37IIqJrJ2r6lQSyXnTMkZNFltgtNBU9iPeZ5lDb0UsIJw8t6J+nVgYqLjpYGcKwJcd9Ln7dzRyydNRxLiaq3J4NgPxJNTwnqFs175jObIX2wHukBa2L18zv7qmrwIfsoCuQl+SQJhTUNjBmcqzglFwPpAM1aHLs1wOwmulZzJJWsFZI+xibwUbFTlXMM/LgbF+TR5vTg0vOIUzVXFe9iqDEqD+CbdsFLfqTIvFc1ESbRWvoXTKWvymrIA05GmoMNARS3kZWQed4IO08tSzVnUVGNF2ZQbFMOTN9g8fowf1hjF/VCSqHVoI0+Vrzntt6T9CGmRUocDdsno99gk6FNzEtVbf4aqclmtc1of68A76pJYplGalZr4ZTVXhI8SDCupUKpwSJ3zdH0vFZgoK9V7UdRTFoYqEtZyXST2nf4Mv0Jo1ZyPz20rhZx0KKNiG6QDJN6KX9Uq17OWwjJNEhpUrrCxSDWvhqKsBqSsd/Rn52zefodutRbLwEGJlXQah3rNPO2Zbnfk3U6Kjqyo64f1+SFAiTHkJTHvFpjB+GvWbzwm9MOr0oNxlA1KCORcqfOIrQVCkMsQrxqe4FVZwv35u4/fDDz82e9NUv7XOm6IvPPHf//9IHp/7s9v8vP6iigCt5YuZg0GWSMDiYLuAazREFE6KDsON/TKfATbBXw3EELE6kqt5aQqlqhhrUodX50zeb9nurmRFeDQwSF80lRJ9E4GwDmJCpelR3tadtxdvWR7d82GiWbrsXO9NUi5UlrDWcPQObx3LLmw32VSKnhnGEJiun0GudH3A90QcMP6WCPaNOWfl0ROgrxpOYvXNTgBzQPURkoLdZbGmVobXgHh3kesk8FE3vjk+y9FVpPGWlzXYYoOlAbwHotTf6OyQ/ueuDklbk4UCm+OiiGK+WlNHuu0vSMvM/N+T9IQmMFQC5KKB7w5PM4F56SO1IWI8V6GBKUWoAgn6VafaRihIDinNgKLja+CZQakD97KcGQOPkUNThnndKATT2zoBrrNGt8PGpY6WC80+VwldFVrwcZOof0VkgxSR9U2aZLeOVrJjNcvyWmilCKvXRfkdeiUyqCDWHd+SnfxiOHBY1zfKx+g0uaRmpNcIJyorWmaWK4vqdMedL1/9FUao48zup4WL60M0gJxb0haHWswnQTelnFi2e7JixYVGCew/yYNVhbIS6LMCayhHwbi0ImPWcsMbAj6WpVh3TrpWTc+EgZZqx+qX2vKQg7QJiJZhU/ys+wdxshgeggDggzPtVXZWsyThI+KlAscEu++08upbjBMjGzefJv1xTmuH/R1emj9krBbU+/yvNsyb2+ocxJOLeIBryULg/RwuTCGZUks+1na22plubyk1czq8SPiasCqME2IlNoo415sR6GTx75WubwpdcMYKMv4Hf56/a17/rk/8mMYA+PJhr/+D/349+3rCGdr3vjDP83T/+P/+/v2Ndyf+3N/fn3n9T2izgCFtsyA2PmaEYM/1on6gQQZRKHTLmhrBdO0WtNtToRNCJiiCqgxx/V7a42Wknj2UqLo8GaNQLUPipX1HhtlmMkpkacJ0w7vYYWby2tefvYRy7jFOUhJV/gG5qWyLBnvLScrT4ie/Zi52SZqrXTBcnrR0UXptt9eXnJzOfLul35EOtCDDGKtFEquLPuRRVfkzrtf8R8D2r4j/24tFR8isY/ErqMW9dXiVPlpZF3NGh8IXSfD6aF1xppjWIucaUZwQmFYE9Zr9euqD7EZ7V3XIQxDyYl0e02Z9mAs/eaUmjJ5nnDBk/Ii84eBaqHzBmfjEQqPKnHygrDqDzUsyyyqnnvlSzTOCXrIWFEmSxargRVKAKiiqv5Ho13z1Eql4WLA9x1x6GWgalKxeVBepadShznnBSBvHaZkoSyAoolUXWsyiOftHePVc0qeJX2vzUjWugO+lpplHds/eczq0ZuErsO4KPW2afqWgalgsNQC8/UL8vZWPq8O0+1gm1CsFU3Ut7LMkiK3MnyjXlArHazyWFhLmmd2l9fkVPHeammEpUxJQm/Imr3mItWq1hGCF9ZvJ4lv46NYBrL+XJaCDZaw3mAVrn+4BNYsymIrspkwzrKMgjUKnVgoai5YJz8HtWZKEpzYeLuVYTVYHWCFS2oOFbEiMeKCw/Y9J2+/w+r8QnrsDy+qxjE4RpLfM2mama4uAel4OqietQkVglLkY1vDMs/MuxljHDY6jLc0hAYxX1+TxpHu7ILYb0jTFuY9jgZe1/EGYaTWJs+D8+RlJi3Tt/M79bf0+Yt/9Mc5X0d+9xcfMjvHv/X2B7/hX8Mv/6v/zjFECJB39xeF+3N/fjOf1+eIeqdg9qod0Abrgigr6NoRS11mME5UmFrAW+LpOWG9kYQ1TQHjTRQwXUe3nEi7vQ5J6ktMWdbRq56mq2+nPtNSq/IyBZFUS+Hu5ooXn3zMvLvDIGD0ZVElsDXmpWJonJ11eG9JqfLiaqKVShcd65NI33lyaez2lbv9wna3kMsNc3N8+cP3GVY9NogPctruyNOsoR537NC2Rio18yhYK82SEIeeOGiK2TkJIYE8lgaKrsJdP+C7SMvSMmSjoJFaFm+fsYZmwYSBuD6RtaPTVhgDGPdKpW6yNl72W/L+7ojRMUaGymG9Zk+jpiSVqrOsm4MXVuWhlFXGAH/8HMY6ci4s4yh+26E/Ip2ME56g6SJlWcA2+d+lilKFtC0Z5+SfRwXjz0mGmS6qCtpz6AHnsG6vlZZnTcUDIWC7HmiYnMQPCoo8kv8YJxeY+faa+UbZoCCp+FzVPyoKXkkZtxpYv/Em/eZUQkYakpOfmHi0DpggMP755gV1GgVy75yo3s1oSh5QrFWZJ9oyc8D/U+RnoKHPszZwAaT9KGikOUmdqo8Y60lTpqRGa4WSpCbWBSe1oLGTsFGramGJ4udsCKTdiGrqVxusDbSURJ0MXvm6s2CvSgXnSZP4seOqx9RKLkm8u1Yeq5ozOSXG/UxZZvzBKmLk9U1DkGStSfuTNbjYc/7uFxjOzsEIwUDYwN8Cts8LWM8yLsxXl6IsN3RVL89pa42WxT5inGWeFlpuxE62JsYaRbypYm0teRrJKcPFI8wyYmhCWghBclxGMFi1VQyFZbun5FmJDT/c58/+wR/ld73/gPcervFar1uM4aNh/T3/3J/9u/9PLv/vf+v4v8dPXvLqRnx/7s/9+c1+Xh/f1HWUaaKlAk1TvIcecNskFW0bpuuwLtAwhNUZvXa1y0AkTESjaW+a9I/XeSTtdvIGYM2xv9taC85RU8V6S+g6SpX+dqMtMWXO7C6vefnZZ+xuX2KNJO1LaVgNS8xJ1MhV7+h6z34uXN/OeAuDN6zOeqwzjFPh5uXEvFRaraRcqBhyg6effc4meh4+eYyxljTOoGl4ayzGSUDFJeEryuhpKE28cEFrD6330jKTRA023tFKFRIBlm61EctCToDgsnBBV7hV1+2RuF4TVxtVIa2yPsUviFH/KKJGT1cvaMv4apWqb/zGOnyMrOwZ2+tL8rwnBof3HSbI4IP20ougJaGdWoVhmeYZ5xy+C6KmLUWGn3mPjYHu4lTUcpQc4CO1CorIBa/fU6OO6ic0hrAaiKcbDUPpKv4wDNcij6tpECJGBz9hZEmHvIDKD0Ef+ft5nhhfPiVtb4/4oFbFv9yKKHc5FWqqhLMTTt55lxgjLApODwb6XhLWNYudwDnyNLO8fA4UsZ4csQROU/Fw8DDmOVGXWcJixmgIx0KuGH/YCsiAu+z3LNvtsZ7VYKEZ0nZhnpZjot4HjwtB/KBdp4FBsXK46CgHHzdGQPHGENdruSi1gu2lirHWSh33upKHahpl2mMaxBBpqUooKnjxtS7ina2tsMwzhkrsIqVkSmn4IMUXaUpatiDWg7hec/7eB/Rnp698l9qURBNGrAkR26/YPnvG/Ok3scEdWbSH3xdtkQuWsYZiJMR1qNI9+IZrqXgCfogy7NeKaQZvwSw7GVB91ACdOz5nAi0rpGmUlXwMiJ/2h+/83i8/4p/7I+L/3PSe+C2w+ozhX//Cj37XP2cZZ/6j/8b/6Ff8szotv0IBvT/35/781jqvPYiWnKDK+u9oHzTqlcyiLDVjMbHDXpwznJziHBpAEm+epHGr4GAQ9SNt70jTqCEOXfdbi/FO3rQPnecuMO/3lHGHDxHjHPN2y+WnH3P5+afQEobGbqxED95J6KjWxioafAgsqfH85YQx0HeWs428EV/fLexG+R6iM0Qnysim70i1cbVNPNgEarrmxacJb1fSfBQFqYNFBhqgVGl/at5Sq/j4JKNiCesV1nvyvOiAIUNAaeC7jr4fZEiowi403ssQCjRtKXLDinhyRuh6fRLUH+eDpJKtkTW/cSzbO+brlxjTxGcKlOVbWIvNyLp1mQmAc54Qo1QdqgIr9YeG5jzGS73oeCdr2G7V46Mn62DnQ4fve4GZB0+dE2k/Y1SdwxqsPzQbaYvUstCWBdf39BdnxM2J1o0ePJbfkogGsQcoKN0AZEnty+NjMEFW0eREy5llv2N3+UzU6SVTUjpyM2lGCgSMVKj2bzzi5M23CU4sAtIE1kG3kRVwLar0N5bbW+aXz0RVs0YZt6ISi7qpHt5axN9ZpOmnaKjMGWlCqsoIRdvA5u2O5XYrK+9cwFn6zZrxds88zlImYCrRd8ShY32yEYyX82rT6DBGUuxNV/8lJYxxhG6Qub41bD+IE6JUuWBWsUPUWsl3ozy/6w2mVFoRVfXgW8Z55klg+qZWQvCYptp5bZRcsRVKrmrpboTNigdf/CLDxYVYRkqG2jBG7TnGYHwHPrJ//pz5029IHa4SKahNfhcgyiXqT8/7kZaFZWz7IEppFf2+5QxZCgXqvBBioB8GHfgRS4KLEkzLQqagNcoyU6so4zkl6vLDo74Z4I3zgX/ln/1ZrDUE96sHtZqBnf8OG6f+DjXzb/63/6eMT69e/XH64Rz878/9+WE9r/+bZKl4xb9oqFoh7dJM0kIgnJwwXDzErQUeTU4ylB3S4LWKomFgubtjubuTgcvKG5PVtZs1MoSYIG+wyzix7G/wNFz05Gnm6vkzLj//hDJtMTShRnnYrBzzXJkW6KOR5prcuNlmWm2cDI5hFUit8fxyYlkKtTaiN+AMzhl8kPBSKpX9PvPoLPLwYUdrhrvdlmAt/bqjXwlyJy+LwN4dGO8leFKa/lmmX68YTjc0DEV7q2uplJqxPjCcnmKDl4BNTuLHjeoPrVJdyNDRDefEYX302wlo26pHtx7XlrVW9p9/TF1GUUy9KJZtXrBBVpFCY6os+x11GXE+4A/8RGMUx2PAyiBsnCOPI2m/xzlL6FfYICqtDQFvxS+a54lwsqYiSpX34egdtYcmnZSEMVkrrVTC6UYal4Y1xnp9zTRRelOilUXrR4Vx6bzWgGpHu3hCjXBHERtGLYX91RX76xfCVU2CYjIIB7XVqnYD4Xuu33mb1cVjXcXLG6GJG7CeNt1h4oBxlpIL+6efsrx4KoD4YRDGbUVW7doE36ok9ktKMmQZSy3SBmNtkNBU1aasKmG7Zdwz327VEqzqeReYbu+EbGDkYuNDZHWyZrXZiBrdjHBAvQSxmsLjq2KVnPNY4zSRH3GxA29p80TZ7aE2Df8U8jxCLXLRqYLhqrVJm5h3NGtJ80ReZpyzwrtd9PHyTi4ExiqMv+KMpT8/49EHooRi7XHFbqxV24JsTPIys//0Y+ZnT/FDVIXfYnw7IqSsVVZua0y3W8ok7WG0Rpul8asVUbqts/JszJnQdXRnZ3LRC16GYAxFFd1jVfEi31sD6n5Rq8lv7dR81MuytYb/xV/8hwGOjNpf7TTgX/rSawaUWiP8HYPnT91e8o8+/+zVP/gzP8k//d//97mbEvfn/tyfH77zbVR8VtphEFWvaKuq7mw2DI8eEVcbUaLmSdPd+iaDdD7TCmm/Z7p8IUOBkzda6xyteUoSddWEgI0DKSemF8+xVZBJJWfurq948eln3F09w9uGBMMtobeMU2ZZCt7CZvDkCrdbwTgNnaOPMlxe3iwsSyE4w3rlicFSKoxTYakNZ2S1n1Ll0UXHah0Yp8I4FqwzhGGmlIVSozLYreJpZDUegiEtmWVa6FYd3XrQYNK38ClrxXcd8WQjg/w0Hh8z46w8XjmB87jViv7iAc7HV4nmWnRt3aTz3Etye9ntmV88gzzjV2tZU2pQRWD6npYl4bzst9R5lFCUDxyYQFWbag4s0ZIL880NrRbi0EvXey2kWVQt68H0XvE82jM/L8ReE9kgHtdS5PtygsgxzhMfnNJtTnFdr8Om+oYPBIJv8ViaGNVjnCEf1tZNVvHWQp7FylErd59/ynh3I0NRKtQ5q6JplMoAJlhMiJx96UsMJxutJVXlNfYShsqjehilB3189gnp5op4doYb1q/CNU7IBDVn2jIL7qtIKt4chq9mZNCtVdJgQVqx8jwzbfek3SjPp/VCmwiWvEj1qwti4fA+sDk/oxsGCWfFgHeWlhtlmrCm0qJcPDBWOLJFBm8XnIa3MkwHXBqY4CmlkHaKJ+t6LEIBsK2CC2LNKRmT5WLgjIScWpV6TqnflPpVkBQ9QH/xgMcffpH+7ER9y4LQwgdM7NS/6qkNxpcvmV8+l2CilUG5ebl8SP1vAxzNFNI405YsKCdjj7ilVsXPa6zD9WJXcM6LRShG3cgksJ6SJsizeowtedqx3N3K96RtVDb6V2Gq32LnsG7/S3/mZ3jrYvXaf2/r/v5vG0PJeH3MTGv8xa//An/vsRYwhotNvB9E78/9+SE9rz+IOmWAlvxqAF2tCOcPiCcbnLE07T43Poiapj5QciJPe9J2y3x7pxzJTtmZorLURQD3frPBhMgyzuTdVqs3LXfXl2xfvuD26qWk1JshvZq/2O6kOWez9tQK41RZSiVGQ4zCC7zZJlkvtsbJynNyEgmdpKVbNUxjYT9l5jlRWuNkE+iiZ9xnliUTe1kVTtNIyYaGYXOywYUgYaQQcbrWN87RrzvCMEgzTxG8U03SgNSfrLA+vmqHOjIxK3WW5K7teuLZBbEfpFbVGijyZt40YW6MpVlDyZm0vaZsb+UN2UVhVBrx5Bovnt40z+T9XpisoJWYXipBWzl+zFobzRpyLSy7PT46/Fpq/PK8yFpTk/jGy3+H2OEwtLlKN3xFaks1vCV+YqNr4Eh/fkpYnRzT49KMI/7VpqvxAyXAWIep+QhYb1WUTaP8S0qmWs+83bF9+hlpeyd/v2UJtOhjXDMSpnPy393pGfHkXNT3Q4UkWhHZmoa6Csv2lrK/g5KJZxfqKzRKfrCvnrss3fQ5azWpU46oscdaW68M2jyOzLs9825UqoPEmFyQ9qOiA9HqbC098s3Sn2wYTjeAFXpEJ+v0VmaMBxM6Wis0DM56tTfK2l0uBU04trNUqRICeVmYbu6giRLaciUVsTAQAzllrK5BlkXCUzTltxqpBaU2imnanSBe4s3jRzz88EvE1eqVEtpQ6oCm3jHUZWG8umR68ZQQFDhfyrGtS9rY5PEtKZO2i6DBaqU2sF7Ck7U1WPJx+G+tEbynPz/HxV5+j2mYjzTDMsnz7nvytGeZJ6ppKEhXLmHLQvktlso+HQKPTnr+mT/wZX7mS4++7b//r3zwo1qpDL5WHunvksP5o88/5b1p/219zH/1z/4c/8Rf/quU+ltz6L8/9+f+/L3P6wPts7wxGGewqzXh9Ix4cip+v3ZoTfFHlEpDlIkyTaTtHWW3ExxTrq+S2EV8ZNYY8SWGSEmJfH2pg1FjHHfcXb7k7uo5JU1HXqDkQAy5gqXS98IpneZKyYUYDOvOk3Lj7k5YmZuVp+87gpc3whBFfStLZVwy45TIS8Z7w9BLUna3F0U19oFSKvOciNFT68Q07nA+sA6RfhD/XasZgxXovZfO8ZKTwLoNdOsBF8IxrHJQCpoR9aDJJEI4WdNtNkImUDA4B1wNmoi3llKrpIHvbuXNVdffJmeITlS32ijzQs1SzVjT8qpyVD2/NZejGihDsyyZa8nEThiLrwZAiwuB5jw+ehpiz6CqIqUe0cMw0HLS9LrD+oD3nnh2gutXMsTZb8EyFWmnqs0cFVljDabMwi5VNcYEpz5SR6sSLtk/e8pyey3b9ijKr4DRlR6AUXuseI9jv8LWyu03vsrwxtv0q5UGtF616dSSKcskqfjgqdZKvW2ugqZCnsqWs/Bkxxlqw8d4HJ4EkN6Oz1lNlbokbp+9YBkX8Q/HiA2yHjYY0iL1rof+dtf1hL4XFqYTaD9GrB55mqWvwBkNlzdcEKIFBqwL4q2tVQoFagUbaKZSxpFlt6PmpENzpaZDq1cgL3LxzLWS51G90Pr9gCC41HfKQeUeAqvHj7n4wnsC1T/QC1qjOXN8jbbapFjh+TPy3Q1xrdW2OVMnVWsPYTxrqW1hfzNSCzhrBSFXqth4vMUa4LDON4bQRfl5+5awEw3qMtHSjA0dxsuFLU17aina6GSwXYBSybtRLsm/yU9wlp/84AEAP/3hI/6x3/3ed/Rxvjas+XC/peggepYS/9jzT78rX+NPf/iI/8cvP/+ufKz7c3/uz2+e8/qDaG34oSecnhNPTmXNVbQq0HkJTGgaV/rgZ9LdrShTSxLVynqsE/9a00HDdcKJrCmRbm6peQYMaZ65u3zBzeVzpt1OYPXHlhYr6kdrBC+DSs6VUmStfmAZTpPgbTYrTxcdIci/a614QcW3J//e7VZUyL73OC+r+lTBOIPXFD4YYvSioLbKPG/xsWdVTzg0FgHCjLSWUuoRl+S8F4bqIdluD8ga0AlW1LBhIAwrwjDIAFObrKezhHEOSg3WkueZtLuljONRxBHPrYUo9ahlSaRp0mrUjAOCMjtrk6FRckAyWOQiDT2SH5EQjwmBRlWclIDX0zxjfZACg2qkgtN7aq5UiyqaMii01nDW4btOmqRiL0qUEVVRhktzDBjJBlZX9DVBkuCNoDvLq7/jJBme7q5lmNntBJZvoCVJtzdF+YCTNionYP64XsnQkzJ1mbmbvkJ76236swtFFEEe95R5D1SsD8f6TdkGW2opR8uFDKyL2jR0oHTC+qxLUsVTwPvLNJHG6bhy9yEcB6CmyCPjDKHv9GJn6TYbfC90B6MlEnWRVLzVWlbrHC50GJs1kKPweCvtTFVDgjZESi2UeRFEVNUQUhWV0Xupvk16KShZmb4505oiyqx4UFupEhhDvJTdumPz5lucvPHG0fMN8npAkU7CUPVUGuP1Nfn2irhZY6PSNPQiC/L6a6WSxolpO2qZkz30Zxwfb9cdQn3yWu5O1vSnG2yIcnlqosi3kqBlsXs4T1lm0rwnp0UG0APTFgQ9BloM8Jv3/Md/8l3Wvec/8/M/8uv+WF9bbfjjn3/0d/k+vxvnn/8nfxf/xF/+q9/1j3t/7s/9+cE+rz2Irp48ERZov9J0rPIXbTgGXEpeyPsdabtjubujZUmyN0XwGGTN3qzBRQkjlFJJ0x0sM7UUpmlkf3fDtL1md3vLOM6CPbJCLD0k9q03YvfKouIdEsAN+XdjsEQLzllyaeLxnApddKxWBowlLRJG2mn3fNdL00+t2shoVEHB4L2hlIq38smWJAriuL8hBAGDu+AIMYryphB166y0Ah3ekBXo3nKipQQuindQE+eh64/Ad2jHZPzRa2ssJS3kaaTMI6R09DBKTF+5lyAg73FPmWesJvhlaDEyVADGSfVmazLIl6KrbzQY4gPWW/JSdJUqbTvWeekmb+a4gsYcMEuCWKpaL+o6wU2FjdgRTJNmJFnFi2pqiqjqFcBZrGnCk2zKCwXaof5TB+m027J/8Zy8u4VWCateRS9Na+trphkoTZTksBoI/aBeWGkRMsZgc2H/ycfUVOgvHlAnITQY98pja61cuKxybymFlhOlFAmnaeDFqL0ARCmVwctRW2Xc7snzjMGI0mzMsdKy5ALOEIZOLi59h8XgnCOsBuFiYo6DWUuLBmkq3gV8t8J5r5izQimS3m8li2/SIFaYWijTSN6PwgZuTVFQ0jdfcxaiQSmUsgjIv1RKVQXSGlnNI0i2WpvUip5u2Dx5g/Xjx/J16cVIUlZWHgcMNkRSyiw3Lynba8Kql4BeETg/i1xIjLFy0ZgXpt1Ma4bgpBQhFxmEnDeKeBLF3nroNiu6kw3Ghl9hmxC1PUsgzkfyNMpFLidwTsgSQS4cQgIRTNVv1rDSn/wHP2DoPH/i933w9w0ffTvnD758+l35OL/aMQb+1M99yP/8//bV79nnuD/35/784J3XHkSHi4caThDvnj2sUvUX3LK7Y7p8SdrupX2mqefPHlA9Gessbuiw/UDNhbS7U4SLYRkntrdXbG8umcctJSXxC1lJvoKhj7JqTFnlP23xqUUCEtFbfJA3jSU15n0ha7Wld5a+F1XUWsMyF65uFn0TFoU1FQ3rVGWYtkY5BGpTxVkDGB1+RWkrdWF79xKMZX22wSFqnA0BHztdrbrj6lLWkbMooPomGfoVoe9eMUHhVVNVER+d9V56vHdb0t0NVHmjNgZRKVVdlaIAwTSlaaSWhLdO3qybevjUs+i7gHWBkgt5kopUSZ3LutPFKLimm1vQEAvW4p0X/6EQSeXjaiCGJqGYpuvtsB4IBzXPHwYDq7giTf4XqXM8YLtMLYINQlbzMgwookjZo7sXzxlfPKcmuai0Q9NOlefFOUFrlZSRBllBU/nYibMhH7yj6MpWkvXp+iXOaGipFEqWqd7FqL5QVXlLUWqEsGRLq5rAFuoChgOxFWMkdLTMM3nJgITbrJfXRdayBkyj6zpc9LjQH1m9ru9wXVQvaBVg/jzr2t3jO0/sBqR7vWKMJ/Q9rsrrJc8Tzhr9ljJ1nsnjpFgng49R1FdjjxeU1mQINQgmqZRCqwaM2EdSKoIFszJIDxennL37Nt1qIxcj6/QxLUJ1qPo4Oy9FEOMtZdodeaLSFc8RB2eaodXCPM4sS8E0i1OVvCI+Tue9JOZx1CwXwbju6Ia12kLkRmkOX0s9kCU8eRpZtneUZZESsvWAiZ6aEnUWrq2h0awwen+znD/8O9/md35BVvA/+6NP6IL7Nf7GD86xxvBP/dwXWfeef+Pf+8Xv95dzf+7P/fkNOt8GCE5RNxYJyyC/OPK0Z7m9Yr6+IY2zYnokSNEOKl2tuC7ihxW5FPJ+1C5wGSZ3N5fcvnjKfnvHNM+AvMEtRYbCoXeE4EhZOsgPa/Wcm755i/qScuN2myi5seRKyo2lVE4HT79ynKw9Plj2Y2G3XWimEbyTADZAk3Yjp7WQxkCwRgZhaygNapbB2TtzxAQlRrbba5oxeO8YNht87HVQRkMV+lgkTa5bi+s7+s0JTgcs4CD3UmuRMIX3ECLLuCfdXtOSeiX1Kam6ozTBy5BQDPO4pc4yZITgsTo0SvWq+O5sEOh7zpllkspJp2Eho6GZNI7MuxFjYHV+gvWO2qx8vKYad6u6Tm3foh4ZXAyE1YqwOdE61sPrx7xSeXPWRLKV0JEzooLWg8p9GFrdq4FlyexfPmP39CnUghsUyj6LeuWiEwuHk2ajmivWRXyIomSq4istlhpiqpVSMmE9ENc9pIUyjRLyClHS187J8KkVtC0tqjJaapaWL2iCkPIeG0Shy6WSloVlHClZh2sjgHmrn3faTzjvlcsq1bXGytfvvJeCg1JkAF3SMSxorSX2ndbf6qVPcV3izS3YJsSKKYvntOZMmUYFzVtCP+C77khyqOoHLTljjVzapinpOl48wLU1aq2ynjeGzcOHnL/zFmFzIq9jp8otHsKh7lR+nsabS+aXz+V+EaNsSLTXnlJESa8Sapv3i/YTHF5vvCp1aJVWDMVYrG34wdOfnuKj11pRqUu1QR+LVDHGUWsmTzvyvNc9fsOfnEjoK2fKOAvvVcN1Jnj0JvwDfX73Fx/yJ/7BD3jnwZoHykf+zXi8s/y+Lz++H0Tvz/35ITqvP4iqL7LlDClRaczznunqijSJcuK9BmDUY2iDF1ZiP0CQVdhyt8MZCafstnfcPP+UaXfDfpQWFu8spcE4Zfpg6QZPKjDuMyEa+uhkQC2V4KS5aLsvpKUIA9Q5uh5CceynTIyWi9PIeh0w1nJ1myi54L34VEvVoXeWN9bg7bFqsxaIXi0FTbyppkJwRjmUDe+lpnJZbnF7i3vjkTRLaQuMNVKP2Uo7wubtMBA3a+kwP0yUAvIT1TknCcx0PaUUlssXlJsbSV0f3hWdE0g6yODTRfI0Md9cyfrTSi+5sXIhaIpuMk6GHCrM+52k46v6Wo2RJLqxbBWq7r2nXw+0IrYCYVU2bPDYw+OgK3iKqKCuFyyV71bHoeroqWjIkJCLKMO+ww4DthXIiw4Z+po7hJgAGiy7W7bPPifv96KIRY9BfZ/rXlbKRTBJZYaSCzb0OOdFSdT1dKmiVYbgJHjkLN3Jhu70FJoEeDAW1/fSMAXUvNCSdKvXZRZkVm2UkkTNrDq0KHeylkrazyz7PXlZKLkKXxaZrUP0pGlkWWZKbfTdirgaZOA2oow75/ErGSrSNIs6rpcfGySI42MQJfTA5bRS3dqWmTpNUBvOC+uzzAvLJA1bPvZCdPCWPI7UJspmzpllngiCFRB+qfAeJJSmMHiHxTjDyZtPOH/rLfwwvLpMNcB4sT4fkGAHL+bNFeRFtg76XB2tFw0JKdbKPC+KG1V13dlj+1ZrqsI3qY71Q8dwdi4/Twc8FhWrkP/DZbjOC2nak9NEM4ZSC+F0LZ7UaaKlJL5k57B1kovHuOBXw3f0y/U34rx5PvAv/MmfYh09F7+JB9BvPY9Pe/4r/4mf4C//b/+j7/eXcn/uz/35DTivPYiKAiQg8sMv9LTbUZaEdV44kAcQuPdY73Ax0mIk7fakm7tjheCcJ3Y3L7i9esZ2O1FKJajXa5myckAduRp2Y6HvHLETT2dumT46qrPsJ/Gy9b1jswp4J4PlOBUqhRgsp5vAehVIqTHOM9ZJUCgX6MIhUNQI0ZHVb2qtJRcB7+dWBbBvjYaeRQ0yqkgZXoVRxvGG509f8u57UstpDIIuUgW52UA8O2N1eqoA+sM7cH1lc1Dlijgwb7ekm5cwj4oiaqoSOsHXOCsrY2tZtjvybotpTUIf5ZVH0Vgnfk61AuScSfNMnbNWjgb1/WVpuxpnTCuEPtKv1hjn5PJgJSRkvKpe7WCakIHUBk93eko8ORWE1yHQ0Dj6UA/KV00LxBWuH3QwTRxSzYA8fs4DYq3YXz5n+/xzyrwcPbHGRXxwR/WvKrpHGJ7QrzYyXC2LprzlY9kgoZi032P7QDzbENZr2pIo44hdrWQINeptTAs1LdSitooiyiGq/lnrqEhAqFlZw+dpYZmmY+hL7hniV7XektPMMi+UCqv1itBHDTkJCcC5oFikQplnUUC7njxNGGOIQyfkg8YrhpmRIbEue2Fw5kypjTLP4ivWrvhutcJvNtQlkaeRWtXCQCOnGW8k4FTmmVoapRxNBvp8i6p+8vYbnL/73rHCV1YIURulkkL+E2WZWPZ7yn5HK1mICzmrJYNj0AqkvWnaTZRcFe0mgatSxBrTOFhn5CLkomM4PSV2nbx0rPi/D8N5mfaAFD5UW8k1gbeU3YTbrKBCm2fKnLBdwAa5CNZaqKVJaPC75K/8bp5/87/483LZN4ZN/5s7TPV3Hu8sj0/77/eXcX/uz/35DTqvr4j6QEuJtN+SdnvykrDG4FcrUYaSpqgP6pcPpFrJ1zeiNFCpLbO/veLm5VP2+x3jlPHWsFkFdlOm5cRm5WkYxlkUztXg2I2FnCun60ADpiSe0LNTGTJ9cNTSWJbK1d3CvBSshYcXHTF6pikf38hSqmIdMLDfJUJ0ijrNDEMUpTBlnEHVKeUlFrEBVCMBKAmNiHIqlYqN3U3ir/37f50f++lrft8/9A8QYtR1YMF2PatHj4j98KquUgevBrRFE80uUpphvnxJ2d3IYHpQeYyn+UjLGT/0YhdIC/luR0tJ0706PLWsg5TXoVmGprQsFEUD2RhwUSo3bbDkqTHf7THGsDq9EL8mUj/aSjuG0rAccUXiu3N0ZxtpiNIw2zGk0mTUaEgFZiuJUgt2WAveqiiD0Fp9nPVxdwfWZGH34hm7ly/IOx3svMPGgPGBnBotL9IgFKIQGoxjpX3mh5BOawfYusGo8ho2K/xmJV7Y7Q6yqPc+dsdAHrVScyHPC20acc6Ti1RvWq9orEUaqygyyJdSmfejMFRL0XuGlAB4a5h3O5o1mOBY9b0Ek0JUC4UEcFwAjKiYtTV8GNRHaukfnOO9VcyUkZW2tWDqcWhupQnaa55Jc9KP67He44eVAOKtPKetLGAqNSWclcE+TZP+4Ev/VNFaVOtFFT95601O33pLglbt4Jl24ldWz3ZrlbZMzPuRvBcmsPGRtkhl6GHVjvcc/kGpRTFSQjSwfZT7mv4c1iqDinH/f/b+7dfWNc/vgz7P8T2MMeZhzXXYu85d1e2u7rbdAcfYwXFCokQkKMZgyA0yEAmhXISAhEBCCPgHSCIuAlwgEBcBQbhBwEVC4jixUWwwbQfsbjttV3edax/WWnPOcXgPz5GL3zPGqg6OvevUu7p6PlKpqvZea85xmvP9vd/f9/v5amxnGe5uL4n7moXUQAuo1bAKzL9GCokURf2uYcVtB1RVxEmGdKXaJidUyrKScsF2PUpZfhrGUNWE4//lf/NP8PKqx2j1Uzkg/7jOVz97zX/vT/1B/qX/69/4tB/K03k6T+cnfD7xIBr2bwmHo7S/1Cow7XNndC2yllfyzzMSPiInahWO5nR4ZP/2I06HR2LIKAWbwRJC4TQHxsFijWVeMtpA31nmNZHaKnw3epZVfFvXVw7fOYxG1sMKUq3cPwamObIZDDc3PTFWHvcSZpGBr+KcYTolvNOMG888B6zT7IaelAupJKDinRVGJeIXqyhZs1ckmIMoNQCpVFzn+N7fPPLt7+55/fpvUU+VP/qf+QP01yPu+pZht8NYTU1BNpfiXUDRVGTnQRnidCTsHylBPIdKIett17cLYsX0MpDH6USZZ5TSaC8J7FpEHVRaete1EvUqlUqapgZgV2ilqUU8lXYj4TEdE/1upCp5b5VSqJQhZpS3bTUqPkMalkkZi7/aMdzeSGr8PC0oGoy+vBu2c6ZicOMoivC5ZUcbUdMbCF2+SWGdjkxvPybPgp7SbfgzrpUg5CRWAqNQSoJV3UbYqzXLjU/NZ0+lQSnT1EVFtxtxmw2gqKdJ6AC7jZRVlUwp4jMsjVFKXMUPCqjON3tDWwFbA7k29TCSUmjJ+hbCUhKK8p2TMgDE9+gan9X1wro0Vny7Z7JXLbENf4a0TGjrGa6uMe0GQZn2iVCSjC+prdFLJoaVWqXnPgUJK1nXYbpOng+Kqgop5OZLVriuk675ENGNFoDR6KrRqlCMxnQd1+9/hu2Ll/I25SxDXGOQkmJjlgppYF0j+XRAxURRmkps4TqgCEOYWGRojjKgWutQqpCpzdMslpiU2k2kBtM7+psb/HZ3wZmdV/DUesHFURM5ruQSZTCuoPteUFprJi2rFCxsHBgJZWWtcc4L/itHxBj/u3+MVvQtbPTf/Wf+IH/0K89/pofP7z9KKbw1eKsJ6feASffpPJ2n80OfTzyIrvf3rHNEpSQJb0VbsxnBpFipCUzrSs0FYw0xJqbHPcfHNxwP98zzSimFrpPu6xASWleGQfybKVepNUwSRhgH2y5QlTXIql0bxTQX1mVl3Dq8MsRYOBwCISRurjz94JjmTIq5Jd3rpXN+XTLDaGULnjKbTQdKEdZEzAVthBUKUEsSbJSVX/6lto1320LmBpc3VvP2g8BvfX2PNZqrfsM3f2NPp7/Lf/I/+1WuXu3eeR2RLyJczNS+TyWFQDgeqevclC7JpFflUJ2HlGXtqCEuC3Ga0UVUQNWg77XU1nSuoGppOaqwHibiMouX0oinNcWK9a4xXFNLg7d6yc43mr1qgyHi3dOKEmobPsB0Hd31jm531eBcbW2r9aV5paLbVJXR1qOtE5yQQKQA3bx5rQqzVmFtTgfWw6MMClHUXdNZwUYZCWblZokAhSoVv9uKKhzbUFZVUyNlTVtChE4GZzduxB6QVpRzYhFQYlnMBWoR+0Be5/acXAP2VzDy/c5Df0nSex+DsDaVMaQgpQFGa2LOkrlqfErtGpRfaYztcF2P7dzFo1sbLko+G5Bm6UrvN1vx/Lb2J0mHQQ1LIyHIDVfJWRijJVNTwPlOiAUgdgFUC/1UsZuo0pBhXJBrBbC9k7V8LpjB4TYjV+99huH6Vj6jWgseq2Sk1qnJnMhN1nKcCW/foHKSzzL5HfateUdjkrR8bsOG8Q6qkiancyFEFtatYNzAjp7+eofb7eRmh0pdG+c0r2g/Cmi/FtK6EMJEbT8fKBmm8xKI89y2HtI8hTXklEWdrlDCiu78O4vJ79IxWvHiqucf/PJz/vl/8qu/q9/7p+n8Q3/gJX/2T36F/82f/9uf9kN5Ok/n6fwEzyceRNO0ShmQ1bLS6xzW+4YDkorHMs2ytq2ZZX/gcP+Wh/vXLMuCqoJXKkUTQsHoius0pXBpRxKST5HubBTLIopX5w0xVY5TlguF0dzcdDhnWNYiCfgKN9eiGh4P4WIRUEgLS4hZrASdlhWtPqs4bQWrwSpRo6yGoqBqDaVVFipZPeqSL+1OZ8TTOhV+8zcPzHPiut8ydCO96zh+J/Ltv3yP1R2797cyDFSpOqw1t872wro/EA/3zTKq2hqyKR9KghkC+S6k00I4HuW9aK8/rXnp3IkttZ6GtTEYVW1pbqMpKaM6g900RRsgF+I0k9eEHQZ0CzjJLlX4rKpW8hwEdq8Vw/UV3fUNtvNQ23BhBaLPuQYW2hBa0X6QYbmtrxW1eWTrJaUPwqINpwMlrpQ1kJcVY8UzWUDS9RVKszKUXDHa4oZOBqwkffb1nFBvr2HNmWoV/e4aMwzUIC1Vph+betaaekqFnMhxoaRIbS098viqoMsaFqimTE1SM5nC+jv+v21BvRQEzeSs3GwZ5yAL3ss0JqlA6ttrHZIovZpWHgD91QY/bC+vZ825WRfk+YpftjVMNW9ozVKHaazHOE9OidwqNaWBSZNywDiNqkp+JtrzKkk2AKndMGhnMH3P7r3PMj57LiUWWkviXZ35ZhloSDdnWe/fkvZvxcdqTWtPbQ1juYDVDfmVL+UWqtkzaqnkmMTPrRTk9npSsZ1juL2RhL42F0RWpVLT2sJ5rSEsLCzHPdXo1qKkW3BO0GFn7zNOU40o2EZZjNYNjyW+25LTD/I79Uc6X/3sNXfbnv/Bf+EP/659z5/m82zbcbvx3J/Cp/1Qns7TeTo/ofOJB1GlpWFI++bPc9KMUnIlT3PjgVbCPLMcHtk/vOF0OhJCagqiEja5qnh3Ds1UnBMM0xoqxiiM0S2MINimmCv7fWBeE0uEm42VDvjOMk25Dasa66RdqVYBsVdoG95KSbWlyM/5ktbMUot40Uq9gO9LhdQ8nKXU1s7Twr1FLki6dYbnXCip8vWvz3zw4cxgOzbdyOh6dv2G6/6at984cT/9bX7hP/053vvKK1mrWrlgx3lheXxLPp0ae/J3Mv/OqmGpReoG54kSQqssbE+GNli3alGlNVWLOhcmWcFq13iLxjT/JtSQqFWJby7LIOm3vayZlUI7TV7jZbgtyIq/Gzr8ZsRfXWOsDKEoIyGVWiQRnZsypqxQAoxpSp/otVqpC2ro3C5VqaR1IZ72lLiSl0VS+0OH8FyTfK1apAY2isLqeodpMPMas5AFtKyaVXnXfa57TzeOaAVlXkT57YfLUEIt1JTJMTTLQJYGr+Y7VG1NXL/vJkYpYeTmaSZHuUnSSuGaoq61I58mUVerJWV5j3w//o72JajklBpLsyXrq5QPdJtRAPznUbgIHP+sHtfzQF8LKa5UhDOaYsR0wqYtKTV2LSgtJRKpZKyqqNiCdEWsEimmJgAWeYxGUTBsP/clhutrpMIWzpOzOnuozzdQ2hAeH0j7tzKwn0kQWXyq2hghwJUiN6+5oKzHqHdtaW2slJsMYyT9rsD1HcOL5/izpaJWQTUZQ11nqmom46ooOcqgvR3lcTqL7sdW7xmk7MBL6E9bGYC1MihTIUX5OSiVuq6XINVP6vyRn7tj6OQ5/vf/1B/6fbN+/yTnH/3l9/nN7+75v/zaNz/th/J0ns7T+QmdTzyIms6jlUJ1viVXG7IGaTJal4nD41tODw/MpwOhwbLNmb9ZKrahbXKDWysl1ZnCu1QyP7RVeEqFZU5MU6RUUUlvesvNzonPc4qkKOqc1LALXzSf6waVMEHVeZ2nBTeTUks8N/9lVQ2rhMxOpaVyL6F21VS7S5xbTsmFnApv3yS+8Y0JVQy7zYahG9j2I1ejhGXenO6ZH2ZKzDg6Xnz1FalEwv1b0vERigw8wn+0KHRblddLUlpZy/zmDaT8fR3mXFar59VhbXaJnKShxlor0PxaKRRUFl8ooa3iOQeyZOjR1r9TLfP3KW21YpTGbUfcZttQPeadv/McUkmJkiX4gXEXnymlvFNIkXao8yBFlcaqcHokHB8FMH5WoM53DgqkIMHK4FwVbrvFWNf8EvkSLMIoWaeiJACmwW02uGGgfRAvYP56ftEQhbXEQC2xvdfndqwq62fOw21GIeppphLWQFgCAvLXotzlghsGqgZmjWo3btparHFICYMMrZU2kBXppBf8k8H2Ha6XIJVQCdog59pzk7s6SlpJYZGAT4xCcEgJ0zUI/hqFNHCuhU2ZQsEahWpqf1WtWStKQxSm+TS9NDQZtHTSO4sfR/HzYoTVWjSQQDtSKaxvP6SuR84g/BKTEB5qkaHbKGqOUgGcKxqDrrIJkQ2G3PnphonSjZxgOsv44g632V4+F6pyKV9Q1gkzNUXyugohwNpLfaz2DW3U1PoShDErnmdpQFNNYa6lvqM8AKSfjCL6D375OZ+72/Bf/uNf4nr0P5Hv8bNw/tAXb/krv/Wa791Pn/ZDeTpP5+n8BM4nHkTtOFKVrNdKSm1O0uQUeXj9EQ8ff8ByOsg6MssgpywN/dKGTmS+gvPs1ODxrc0oVghBBrySsiTXW8BoHMX7mXPhNMt6V7emI833DZNGOKDkirWSFj+rNqVUYlNNvTurIA3NlAvmvBpHybaxwWUUrWteyZqfWjiHlb/5zYnpmNl1GzbdSOccm25D7zreTg+cwoneduR7+Ob/62PWELh+pahJPIS0LnDlvcDgc6GsiaoNfntNt9lKiKXC8aMPLx3sAmYv4ulTDbqvJPAjbUAa2nNQ7cKdU2rcUrEZGC2DgVzsRS2t8V0dJC3oZIzGD1KNqRusvPGI2ur9fKFWoIywN60T5aypXLXdeJw9eWJPQFiahyNhOpDXcLFJXDb3pVJVaenuAhhpDXLSNCV+yvahaoNEzsI2tWOHa53y55pN7btLO0/J0lRUUiIF4Ubqtp6vtaAQdVjS6tKEpJwM82kR1THFiHEWrZqqmbMk5NdIVQV3bpSiDZoVSfjbNpCe19Ba/LjaGtx2K4xPrSXQ1gZxKZJQqPPnL0QJBRYJDJZ1oaIw4whUyhpE7TaG0rBdOQU07TlVRL1uP8f5bF+xFmUNOSWMsbi+o04nopLXzI+j3Dy1RiplHCkElrcfQxQKguDGFA36Kd8rJahZXres0Ma1mz1a8KtSms/1zMEtJWMHx3h3h+03l99H9TystqIN7S0lF8K8pyBoM5ASB+V7uemIZx9pC9M1y4VxHqWQ1+t8Y5Jk8C+liLL7Yzy/9Nlr/sRXX/FHfk4G0afz9z5//Bde8u/8je89DaJP5+n8jJ5PPIjmXGS9V0Q9SDGwf3hgf/+G4/6elIIMGkqhNKRcWNdC56QSMrWUNVkuHcbKFWgNmRBzSxwXQhRIu7eaDHS9Y7vtpMUpFdaL505jTBsYm6JSKhhj8E6UUa3frdCld1vUUVFMZVUvAYa2EmzK0Dlmo7SoJDHKoOu9qIAhiBD30YeB1x8Get2x6zd419F7z9j1PK4HHtdHnLZcD1s653n97Y94+9EHfOZXr/nif+KzslKu8n1KlOrFUgqqH+iun9HtrlElUVOiv76jKs36+BaVZK0u8maRylGlZVBCPKWFKqtGLSvPmnPz3EnARNsW/Om9eASzDLXnVL1qbUZu6HHDKN7GxiFtL2IbQhFVSeLOaJx8H2obLtoK94z1Ql7rnCLzYU8+TaR1Ia3hMqjmNTaGY1Noi7BatXG4bsQ4oTWUmCRE1Zp+RMGSda6/2uDGQdbiaxTFrDFX5QNdWiApXoZQ1Z7SeQqvzXOKER+qap+lOM3kIMUIuqGx4rwQ1oXxeis3Y+sKqqK7XkqnalPgK2JpUMiqXqlWUyl80+76GjduUErUYrRgr1SMVMTXWhXklAinYwtlCbaJdkNTSqUsQQYuDdUYqtGQEzEknJafnRgEkK+slCPUCsqKPzvnIm1UxrUQXKGeToJeigF/eydFAUpJ0O7hDTWuuN5TcpHwuqoXhm1JiRqjMF6rlhpTIzeDeRU+sWobE9NCSjUljDeMtzcY70Slt8JWlc+hkR/dltAPhwdSXNDdgHJWsEzGib0ltMauVuOrjKGuq/BaUUKpyBKeK5fPbfu48qOv5re95V/8p34ZEAj9l19d/chf8/fT+TN/7It84+Mj330aRp/O0/mZO58c33R4vKyqT48nHj/+iNP+LSVHSoWSFd4L/iSsGWM1vdEX5eSsNmqjWxK2CtqlNemkVEmlYo2+DJl9b/GtKjGUQsoFraAfnKzhiwygufXVe29lQkQugrn1d1NpAShZMcupFEkCXWhDNGujaQnuEAvKKJw3aCqUyhIyBTgeEt/8xkQJmpvNhqEf6JzlZrxiijNvprd0xnLT7xj7gSXOrMvM/LBw/+8+EJfKL/zJL+M6TZql+7sqhbu5pb+5wToHOVJTAKVR1jI+f4n2Padvf11ew1LIrbvceFGGS3vu1jkRympbMyq56Ftj0c7J0Go8ZOlIlw1/a2oyBtP1uHHE9v1lfd+qcuQ1rud6ThkIzkqjKplzx/e7Ok8u1oZSK3E+EuYTaV7J80IOAVBUVVsCW/x7aEgxk2PGWY91nQzZMaI0rXJUVNySS/PCVtzVBr/dyqp6DWjXXbyvGENpDUlpWcjLzDnUBvXSzCTJfGT9rFvbVlya5zijKjjvCGvgtD9JS4835JCISRR76zymqvYyNJ6ssSitiOss6qUxlFLwm4H+5hrbjbLC/n4VrhZAXu9KpYTAepzJMUIWX6nueoHQx9TS/lE+N0pL2EhptLEU7wkhkmsR324FXQoUSawrb8X6YJ0M/LVQksDgLZZUVlnjp4i7uYOUSPu3UIuwPJHfETVKeEs7J48/Sj89ymKa8qtNJU5Rqk+b/UOfrR4147YDw+0Nxr/zyNJeW+2chN5qpYaFcDyQcpAyB1WoMQrGzDpBeCX5XKoWnluXBYNC1UyZIlixxpQQznKrfF5s81H/COdf+q/+p7BG8ZWn4fOHPl/9zA3/w//ir/I//j/+2lNw6ek8nZ+x88k9okYTQ+DNhx/y+OZDyKGliQU5IyUwhVqQ4M3Zg9kS0s7JenCeRb3onObmRqow16VSpoTOwgztB4vvLDFkYgPRg6Tnfdc6vGNpMHlwzohNIOfWyKLIsWCMlralVMi1Nv6iqH8xVyTQqy+8QglJybAcc8V6i21esZphDbIStShef7jy+Dqx8VuGrscYw/W4I5XE69MbTFXshpHdsCXElXk6MS8LIQZcNvzGX/g6RM0v/MPvS1uO6xiev6TbbFE1QQxtcLJgnPgcSqLb7UjPnnP4zrdE5VUG52Rdv04LrvP4q21TC1MTIIUbarRwODHnBp6VmmOzYMqFWCuNHQa63VaGgnbzIcNRC8fk+O5/GycK1IUhqZuSJ8GYBl6V9W+F9fhATitxXcjzIhBxVFvJyg1FE7LJS6IqQ9eNEhZqTUHGN4RTC5MpwI1ewPBW47Y70rJAzmjfi2dVpHFR4EJg2e8p64qxXhLqtcprRlvB03zCzgpOKgh/tATB+ygP8+HA8fEgoaoWUCoxMdxcM7x6n/V04vTRR1jvWpZHC1opRbQWwH3Kke5qx3DzDNMqQqmImlmrPLYYLgN6XAXdVUK6qKGmGwBNmpfm26xy06A12ju8NuQYMc4zaIMfC2/vH3BKYYqwXa1zFA0UhfW+3ahoVBH7gPFWUufyUhH3+wbAV9QgCCxFJU2rpOqzlDhIkCiSUxQ7j9EXBmtY5Z8ZrZpK6mVYDhG/8Yx3dyjXob0T/26S0gtlnSjVOVNyIC0nltNByBBak5cVlML0ndASogwuqvFA4zRhzzYSxPeO89RVNj5o3QJ1inBWon+E84ufuf6R/v7TkfPFF1uc+XSYrk/n6Tydn9z5xIPoB9/5Lof716RlD0BB4xqbL6WCBIgVJdeLvzDVircKbQynKVGKsEF3Nz2uMUHnCKd5xWqF8Za+t3JhKhKkSTFjO4O2GmuNAO+RlLs3lpizhItyIp29ghmMlcErt0DPOY1/TuWeh48cZShVSmGdKF85ZqyViIqs9TO1SLDEGc3DY+Tb31yweHbDFu88N+MOrTSvpzdYDNf9jmfbZxQKp/nEtCysYcFrK4nlrPj4r7xBT4Uv/+e+wvbFc7Q10hIUo6zGXau5rDL81VoJ08R8/wBKY4yW1yoH1n0kBfHg1XNzk7IXb6PRqoVhtARJam4hDA22DQHe47oed663BCTJ34bJ87oSqWbEdRIYqg0LJMZaWSufrQ8K0BIyWk578jqT55m8JIx3lCSKpXGeEoIoWS3tbm0vChcCrU+rtHkpZDVdc1NwncZveukI9z3xcKAqCQ5Jd7j4kHMuosAuk4TEtPgI5fVQgGmKGqLmWUOpmbjOKAXrcZV6Sq1YDidO+xOlVLzvGIaOqmC4u+PZl7+CGTai0vZblo8+kFR0lcetrBVvZalsXjxneHYn78P3I6+0DMOUQkVTVWU9ncjL3Cy2mVwqrusF1XU8iYdZCZIMY1De4q1paiDkuEKtuL7nxcvnzKcj0+HEdjvI+5wSne/Qxsr7phBkkveiNnuDUgh/0+p3Do1ahQVbhTlaU8KMG/k8pNDCWLWFh87hM2RNjszM1jqst+Q14AbPcHeH6joZ3sMq6nZcQRtp0CqJGhZSXIlpFQW9VkqVz6b2HWWNYuS2prVgJcJhQiEq8eVGyXXvAm/GoJpfNa8raVqI4UmB+2k5/+p/4x/iv/4//wvMIX/aD+XpPJ2n82M6n3gQffvBb4lyVeXqo1uve22MSxlAK9YIVqUA3mlyqoSY2I2WoTdYbzBGrnKnKXM4RmJI9L3BeyN/PjXl0Sr6TryJKeWLp804g7HmwmisVRGipOat0TIUNyyibTif3AIoVqsLvmldRenwzlCQ5L1CyV13hVIyaxA7QMhFGO+18M2vz8yPcLPZ4pxh149469gvB4wyXPstt7sb0Irjcc+yrqxhxShNrhVVClfdNRrFR7++x159zFf/1C1ataYh6+QirqRLvKYI2nJ8/THH73wLEAC3Voa0riynlRQDzhsZXNt/lFYYNBotw+HZR1kReKsStJOyFuM7ut0W63suZsYGHhf2Z+NE1kxFo3wv6mrJEpYxHqyXqaIIu7RqBcoS1kg4PJLWE2UJMsB4I2tQBbb3wpTMsn5W1olSWZojwAkpwFlLWUODvUvzT62Z/nqDdaLMhsMR7aykzc8htShfN6VEWWfxIJZMbn5mVRU5xxZ2itAsG3FZBVtVxfPcbQZKzkwPj8zHCaWg6zs2O+m099c3XH/x59DaoArYrufZ5z/Hm5KZXn/MYJtVpdVx7t77DP2zl5fnjs6cuWOqlkYPkHKA6e0DeZ3xm1FCRFbjxh6qYjkdyWGVQQ9FVgo79pgcCNMqafhS2lDpEOKRZbu9wg0blmlCxYBv9opznzvN2aKdQg2esqxNpdUYZZqFQcJpFdCdJPwZ+raej+QYqcqgvGqfpdzqcjWmM5QgBRnKW8oa6TYj/d1d8/Ma6nKS3yc5itBuTWtzgxikxaq2mwm0oawLpuvlsx4TVdP4pJW0rKim7qKlnQugzpP8eS2/K5S2VFUa1qrSj9sf/Tft0/mxnMFbnNHMPA2iT+fp/KycT56aVzLYVF0JMUszTwPPn1mQKIV1ipggtz74cdB4Z9t6XUIrIcHpFJnmQE6F3UZUKKn+VAL41rJyT5m2lmyDotKsa6Gu4kPUWiGFNYa+a4pmET6pVooQcqt4BKNNU9MqIUmnNVWRWi83CGJKK0UqmWVtj0crTIHBaz7+KPDBtyKbbsOmH9j0I2O/4XE9kWvipr/methgnOHx9MBpmVnWBQOYllze2pHeeFHpSuJrf+Fvc1ge+Qf+mV+h3w4XL2YtkoIPy8Lhw++xvn2DcRY7DqhaxScYAorKeLUT/6G3VOOgVnzDJCnnJHGdK6RMDbmtbXu0t/jtFjdu2tQH79TN+s4vVys1RwoK4wdJ/JemjBp/wQNxbgRqbM/1dKKEBd91aFVZQqCotj42VniSp/Xy+ZHO9aaCOi1DaM2ts72RAhA8lzIKa7ysXJUhTZMMpN59H44oU1o4ihQFaVUqtRiMlXDMhd9ZywV4HpeFkhPWe4pSdFc7Skisx4VwmrFG432P9RbjHdtXrxhfvtfU1QreUHNEl8Ld5z/PsfOsb19TUsL3HcPd+7hhK4OZavSBs6+2nNFZjpIzp9cfE08n3NAT55VaCm4zoIBwFIavdR7QZKXx2xHCSloW4hLFstD3lJKww4gfB0opFF1xXtLi1vfyvp19sqiW5Be1vMyLJO6tlZ6DZqGUaRWq0uQ1ybpbS597WhZSyKLuV1EYqfI7IIYV589+ZUsOEdd1DLfP5GYqF2nCUoZao4SelG3BtEheI+t0IseA8RZrnQTatGlEgCrNFMjQm0NEISgtvu93Uc1SEKDsu0750qgReVlxvnXdP52fmvOv/Yv/KH/6f/pvn6l1T+fpPJ3f4+cTD6IoWFpHvFISJiqXQIWSBLuC6ZTRVrHdOIwVJXOaMrZ5P2OoHKfIPAWGwWFHJ13CBZyXgTVlGQBjeAeoX0ORi5i5BNzRRuGsKEYaCS1ZJ9WWkswWZVWaZFpDUuOaGuvIRdb8ul1pjDXyfVMhpoq1MoyVCp3XxAzf+Xqgro5x29N5z9iNHONCyis3/TW7boMxmsfTI9M8E8KKomK0oeRMpzyjHymlEHMh5cibwz3f+De/xUTgj//n/xjjxslKsyrm/Z79d76FzoL4MV4S4+vhRMm1eTo9dugpVeD9rAvGSaON0lq8daU0dJYGi6igvaNrQ6j0leeWiFcNFVRlsCzS247rcd0gYP/S0vVKWomUNtQcxD/qenJRxMNbSFGee4wYNM73rPMEnJU1CVEpNEoZSfo3hqpq2COpOpXhQeo6DdoqUYVbuj3HJOtXrclRnu9FCQ0LtUSc8zKEZuGNKqtbPaekpc+W2JxjaxDzlKrw40COiflwIi4LptEEjHf011ds33ufbtzIIOk7lGo0BEB5j6mV6/c/y6kfWd9+xPD8Dtt1bWhv3UDncMwFYCtex9PHH5HXFWtd60XPuL6nFiSsVCvWWnKuJCrD1Rar5DMek+Cj3NALVsr16L4T3Oq4Zbl/INy/pttspU2L2jy7SACqvb5xOpJCwPYe66wo9Qr5XKQqiXjnZGUeAvm0EOdZKnadrL9LiGilmz+5odWslbrZEHCbgeH2rrWPVWrNl9BWzRllGpO2FuIysx6OlNZQpZSs9JVS4Gyzd7Twmu/kJW2VpLXdZKlmyyBHKqVRJRpKLmcUim4cySFhhu5H/kX7dH685/PPNnzzzenTfhhP5+k8nR/D+cSD6LwkKuCsaQpBGxIbcDy1C9gwGrRWTHMSNRLYDJa+N5SCqKC5sNl0ElQKsjI0DYNzZo6eT62VeS3N41lISdIpmqZmKUmLu7ZuT7kSY7ok840Rr2KOjTtqZEgtpfWXtx75cxd8iLml8WWVrVsgqwIffCvw+nuJbb+h7zp2w5ZMZQ4ndm5gtD3GwHE5Ms0T67pQcsEqQ8kVi2XnZWAJpVBy5nHe87DsOYWVv/xv/DWq0/yxf+IPY1Tl9PpjcpgarlO8kWlNl054rSrWSEd2qZDXgLEWtx0lVVwTeV3a4H4edgAn3lG/2WD7oSmMCtXUQhoOp1apM61Ko/0gIR3EVSlJfn9Z45/V22o8OVfi42sZIopgknRb+RrX4SrEdZE6yWZGVLSAUD03FwkDQJ2T+UracVQbYK13F8oBVLSW0FFO53CKDJw5S8LeuJ6S2mNpiCCZFFs4xUgoKYbl8rmjgvGWsCyEw4kwr1ALvvfYsae/uWH38j1s1zX0kWvDe/MUNpg/WvBJvu+wz+8w1lFbEltrqWOlQkltNV8hTAfmt/dSNVkVOaxUpTCuo+RKXQLKtJ8BClUrxnHAOSucX6vpdjvx4ebG5PVeKrKsZjocCPf3+G4Q1TeX9nOgG35LPvNhmSi10N3c4DYbEWxjEoU5ivqtvUd5L41Oy0xagiiQSiwuteGQzj/bNRcJFjmLqoVuO9A/f9F4tvKaqWoFy5RCq2CVITStK3E6ST1rIxtUpMIWLazcGpM0QqUktIIgoSgatP5McqhJfqcppagacm5hqFzRxmJ6L4/xSRL9qTpKKf5n/9wf58/8y3/u034oT+fpPC4kuHIAAQAASURBVJ0fw/nEg6hutYmoVuvZZMkz1cehmZbM/iT1iwroO81u4xl6Sy6y0tdGYay9cENRFdcuxLVKcEi2wa1lRSn6Trxc+dwZj8I5g21w8aZtkHIh50oTMhs/s7XItItJjOeaSWlaqrW2cp5CiLnpa0ApMnRrQ6FyeIh8/TdnvOoZ+p7duAWtOIUjTsFgPc4qlrAwLzMxBlKKUl1YChrN1o0YJDSVYmS/nvj49MAUVwKVtJ/46//mr+Ny5vM/t6FzCtM5Uogt0Q3OddIP3rrRaUlgXSq27zHjiG7tS2XOlExb8ypRRZ2l220pKRHmE7YbBKTfVGRJPIuSmGOgGIMbNxgkFV+1YJBErVQSeGoKZq6QTidyXDCK1lDVVrctsa4U+N0O5RzrwyNKO7S2MrA1C4aot00NazHtmhJVKYGpuwZCbyl7QTLJKrdW4WwW8YcIvsg6lNJkHUUh1y2s1QZ0Za3gnMIiKiqq0QUUcVkl8a2EBrHOmWHo2b54znD3AuuHNicLjUA1pfjyemrpWc/TPYQZrZrHMVdRB42RYT3ny9AWjgfWh3tJ2FeB7mtjsK6j1ExJSdLnVXyOqnP0bf0tHswsj1+JUlxrwRhzKT447U8QZsarrajItTbvqrpsIErK5JzElrC5wnWdvL4lvQv96Ya5MoYSVtJxIs4LOVVRyqvwO+vZikGD5Tvfyhgy/vYav9u1xij5uWs7f0pckBW6KNc5rqQG7VfeX9i0pvPUlCntZkhbRyGTlpV0WlobmUHVDLb5b5PcZKn2PFLOMoQWUFWwV0KtkIH26fx0Ha3hT371FX/xb334aT+Up/N0ns6PeD5517xSwgtF/JTqnF4ukFMhrpklVWKWFfDVxrHbOpzVzYMpw5CCBsiW1bp3poVKpPUot7533SpBURBTlarQLMqpsQZjJf2N6GbEmAlBLADnIXN0RqpCV0nW917+XmnVnzKschmSqVX8qYC19gLET0vh21+LpMmyHXu2wwZnLVOY0LUwOgkrxRyZlknCSXFtGGxJq4+mwyChqZQTx3XizXTPMcwsORNLZmsHjvcT/59/9zfY9D/Pe5+9IZ3EA6qNlZuBNqjVKn3nKIXRRtSbc7goxvbnqiiLpVCtwY09tusETu89cRGYvLPCixRGYybHSFwjcZ7blF8x2y3yf5oGmdNlEKxVWKjhdJDWH2uaoljRDY11/nvKOrEUF4XRTlbyGmpb89fGeZS2pDaINqX0UnmpW2JbKWqrRC1hFSVXQ5xbS1Jbd5cMfB+Cp6Ysyp/WFF3JKZDi0hp3WnVkLmjtBOhfPJXCcpiwg2b38hXjs+cy4BojynAtlJykvhQaiN5TYyLPewjzZbVcm0qqtKLE0FbdmpIT6/6B9XFPObcAVakkNdaJ2lflMQqmzOC6TsgJQRBJZIvqOkqK5HmW111rqpWNxHo8UmPEd74Nqxpo3tjWQPWuWQq6rWC8cmjg/FIvnyvjnLzXKZOXpb3uYmkpOcuXVlpeb6XFStEG5JKhv9rSXV1f1u612SS00dQifk+MWFHC6UBOqdXedmKdqKp9/URewqV1zHQdeV4aNcyAkXaq8zo+r6t4Q5UowMJeFQuJUoK8MoMHxFOt7FP95k/bMVrzz/+TX30aRJ/O0/kZOJ94EK0VZO7R5Lapyi3kk7OoKJ0Faw1DZxl7aaIJqa38kIunRliCwg6UNpcYM8a0C0tTJGsR/FOpbW1vFRqFUfoyTKIE81OyXBxNE21jqsxLpPOtJaYIg/TcJ22dbk08ShqfGutUN0adtedGpUQqhQ++VXj7PeicZzOMDF3PmhaomdF1bPoRgNM8M4eFOSyYWlHKoqqmN176upsqOK0n3kz37JcTa6kc44LDUE3FDHD7/oD3ilIKxjmM1oLGioGiC6XIEGWNFnXQnC/uWbIjunkPGw5Idx7bd9i+awEtwBhcv5Hh5XTADiPUQpgmlv2RkrIMEwpqjkBluL4T/12VwQKtySWT15maYsOTNuVVqctKVhvT+swraQ2UEClt8C81oxuqSxmgaFKDkWsjoSQ3dGi7bRB002wGojqWGKlR1tS5VhmYijT60LixosaKwUIcCrp97hJQSGsgLQmlahtW2rCdEspI+CmHlW675eb2jvHZraC1Gt2gVuk4J0WhBzgryKr5RJ0OwoWFFkZqq/hzSKZZEHIILA8PrPu9DJUxgQLfD7KOT/K60xR21XncZsQoRVlX8rqivUU7e1GEa06ysjaGGCJxmqglS1mCEpUR01LliGpdzlWba5SfO9SFf1pzRjWMgLYyVJaSifPCeppRSt7Dc5VsbTcuShuMtaK+poTuPdtnz6W3Xl5pahLsE8hnE23la8VVGqTONz5WwmFaCxEhLYGyrk2EVijjiCGgKvhhaLYL175LocTYPtuCZKhFNgCmVd4qY1CdgxZiEzvDUyrmp/EM3vBf+Ye/wv/+//G1T/uhPJ2n83R+hPPJFVHdeuPLu95wqxXWKELNpCxBod3gJDRT6mXFptpAWThf6FvAOtVLMl01MvmZ/Sm+P3BaBierFbqB689+tpyl2vHs+0pNab3aOWIUJXS79YJ0UqKwoYw8NiS8lFNLy7cWqFxkYEmpMM2J5Qgf/FZGV81u3HC92bKmQKmZ3nUMXtLL5wF0WhdUyRjtoCq8tthzbWBVrGnh49Nb3s4HUqlMOWAQNFHtC1ef87z3pQ3oSi7grb1gZEprfnHW4LzD9L2k5KN0rnNeY5dKY/RIorjrL93dShuUk/ackqL46uIqXMoQme/3Miy2xLjrPDVVlsdHtLE438sQowxpWag5SM2lVdQiLUG11a3W5vtVWgaZdFpIy3qp/tQXz54M1hJSSQ3bpHDj0AItWnyxqgo4X0vffa0ycGMUaVnJYb0MDcKsFLW0tpuhqlQLISmpFU3pEvqpRVq0cs5oI61COaysxxV/tcNvtgy3d9i+lyHJD+cPMTWtlLBi+gE66TXPx0fqcrwMSBRkFa/bcKway7ZESs6sofL4+oG6SpDLaIPrB5Q1xHVB1SwMTgNmGOm2G3QLAZVc0NZinBefbkqoKlWnyhpBn50m4XX2HaqeLTaltR+Zy/ugjBQnGGvRxjQbTZKGKivBNO0sykgXfV5m4rLIZ0BpwiThPO38u4ILK3++lozpHMPdM9wwcrYv1FIkuHX2KbfXK6fAetyTc74E1Ghr/qqghECeZhQK7S3KO+KyUmPG6lbccA7SlSL2jSxKsmoBN3mdHCUXUso471DeibVDyefOdO6H/w37dH5ix1vDn/jFl0+D6NN5Or/Hzw/QNS9K5dBpul4A6SFVjqdIrTAOFucNMZaL+V+4lbUNIwrbhtBlTXhn0ErhfPOLluYLVRVnVRucRM3U6p0okbMElmTkVMIJRZbGOSnePq6Mg20hJKnp1AqsaWlZNLn53JY1yQDa1v2lFCiFORSWULFac//dwnoqbDcbbrZXpBKJJdDbjt52OK0JMTKvMoiSE057SlGMxuPOChaKmAMfn+756PRIqTA1OoC1lpMPvLUnasrc3Pc4b7HeY5zBDX0LHgW8kfYj7Rza27bmBYoof7R0sOo9fuylIUcZUcasqNTnFTxV3quSC/Ob16SQSEsgpSyp8pzwdpSUPYrl8QFubzHdlng6UVOQFq1ayIXfMVBglHjtjCGvgXg8SdCqNFWyhWpAyWvfFMJaMsppuusdtu9lAA9r8wy3oMk5XZ4ztSTiPAukvopir50oWjXXpgw2VJdu3ehZhjdVxKd8bgirVSpQTecxY0c+FeIhcH11Q399ffFDKufFjxkDNa7yfV2H6gaKtqT7D9ElCri+lNZ0JGqd9Jln8VXmlVIVxstnyd4+5/jdb9Obih8GCTXVgpCxhAigx60MoUrCabWC6TtRuVsCXHyxFuU61nUlzRPWCQge5H0yzl6U4hIT1juU1YjB2mDGDdoY8iw3D7qttpW17f1KrKeJvEolprGOtEr9p2lDqIIWfGrWirFjePasqe9ZLAkpX7rjVVMkS1jJ00RcJ1LM7TVoVpRmH8gpiR+0bTGK1jIsI4qzcmJ3oCm85/sBZcWukZco4UvXEZeV0PiyVm84s1xLTFKPap8G0Z/W897NwH/rn/ol/tV/429+2g/l6Tydp/NDnk88iF5tLd4brBO+4LLC0pAp48YJQL6CszJYxJaoNW3NfUYk5ZjpO9uQk5KaVkahSsFaWbcuoeD+I01uwtyspFgvKlNMmRQVQ2fY7ARgvm1+NGrCd0ZA985ijCanQqqJlDKpFIyV0BO1iv+tFqYlk3Nl6DWnN4q3HxScc7y4uSNTmMLMxg/0tqMzjhgj0zJzXGZqzlgkQHUeUksuaGVJOXE/PfLB4S1zEsj3WiJ95/jAHllshFRZXydRPI1hu+3ZXm8J80KNma6t4XW7MOZlFWoBpfluRVGyo8dvtpeAiOk6lO+aArZKfz2SXg7zStgfLoidnJIoYZ2jG/q2ElVYL0P88viI7SOq1AuHUbUwEs1qUYvQFGrJrNNM3B8hF5R12M419qzYKhSQ5gWUNEDpwUnHvZWhTdXSniPCemzPt+QsiKBloaaIbtzNWoCC+Ctzugy7aENVlVjTJUSkoeGj6kU5DSHS+zZ4KMPzn/s5hutbwRopQFvISWwQOYk62nmUG0ipkvffETiB9aLspQClQfKjVE9iHcSVqi123MAyYSg8e3FDyYl8EPW5FhkUYwhy4zFsGMYBlRIxStOW8g51Tns7g9JOhrt+JCwTaZ6xXYc1Bm2U8D5Tqw9VbXAfBN1krBbcUVtm5HUhhYB2Xv6scxJCi4Ewz4TjIk1XWhPnhRgEoVWAFkeXdTwF13mG651gqwBlrAzyJYPrLo+FNZCnI+t8alsVI0GmHH4HpaMU2bQoq6lak0LEWi+W5tRUcC1lDWT5vFRaqC4n4rzSdYISiyFhlKbfjq2yNMrNhRG/aDwef5DfqU/nd/F4a/jH/+BnWGPhf/Xn/sNP++E8nafzdH6I88lT80pdlMn9IbOconScG02pUuVpjCJnRYytH75CSLJmN5KFkA75TGtikvVqKZVaz+EhWf2HIMEhY0TVtG1w1UoRs1ycjVGU5m8rubLGxGbjmZfIOHYsa7rgplJo/jMlPNM1ZIGyA6oKg3RdMs4ohk6Rk+a7v51JqfKZu+cYrbhfHhi7DYMb8EYCGTFGas7s/I51PpJKobMdrqrGJVesOXBYDnx3/4Z9EKQTtjC5zAd2QruKUQpnDa+uPN4k9vPMYV4Z74+MwyBqjffCaqxQYkQ7c1HylHUYVbGbEb+9ghgkJuW8gOPDKrWIKVNjFj/lEknHSbyBKV1CKtZYvLfie7QOZTwFRZ1PuH6QIRFJ1Z+Da2hNrVoGU4m0sx5OhONCiQFVi/BdpVTodwSpBMADpnP4zQClUsPawkMSPNNerA4lRkpOxHWRbvUqSp32AnSvzdsqKCRZw2rvxIdZIrVodBtKJXynoGS6zYBSsM6LWESc4/kXXgl7NEWpgbTnYgD5LCnbgfMo3wvS6P5DtHdtDd04TNqinPSxl5xQvpMBTDvc9oq6CvBfKY3vOt774ud4fL1hffuG3mmxG6Cwu2vGqx15naXhCCWDZwuFKXUOsmXc9RXT45Hw9h5j5UZLCBUGyE2l5JIML1ThcTovgaimcla4/Fwqa1AlN4RaIM4BXd+tyktB8F4tca8At91I5b13bO5uL8qiBOMqJQRUN4jSqhR5EUB9jIlaW/1qC68r3wFVaj7li0gIzhhKShgjA3jVom6rArpz4k2OQWgKaEotxGmh24wXL67WShTjvhd/ahFSgR068jyzLusP+/v16fwuHGc0m+6TI7GfztN5Oj9d5wfyiMaiODyG1sUuiXStpRJTKYiptZArgWmXWqkFus60IVZdwksaWZfHJD3fXS9IHvF3aVIuLEvCGOm0N8ZQgXWJjKNh93JHSpW3D1LDuD9FrNEcThHvLNMcm8LatnO6tfEo6bG3riW7S5HUfar0fWv6yYWPvp15eBt4fvUc3zveLPdYaxjdiNMy8CxhJaaE0x1hXQgxyL9XgllPRbyxh/XE9/ZveD0fWXMi2sLBLaS+MjoJYD3fdXzp5ZZd79h0lu3WEo4zabslOUe/HdBGS2ilgLKqIZ0Uyjlc50Q1cx5yRvm+/TtLiYGaxEJByaQ1ENcgmBtTZE1ZKiUn+rEXBVW14a9UGYacFpZkJ7iikuKZDEmpAkLXxoC1lBBZHh4pIWMMWNPJEFAKeQntvVTkEGXt6gyus/i+pyZRpymypjf9iO47ainkZaHWRJpX0tqGMaOxnW9Jcgn4oFTjhMp7HoMgmIx31JqFB9rCXdYYGUK6jrRKc1B/dcVw9QzjOnmGFz9jluG4Ikls58EN5GWmHu9bxSYyuKrWHV8KlHhR40qIqGErVZvzkZJWsFZW4lqjreHmvZccvOXht38Lo2D36g6rHWVpCqRzjTIgNZoycEsAy9084/HDD6jHo2whaksWUuX1yRmUoL5wRoZGa6XG9HiU9be1kDN5XiRo1PVgpfO9rIGwrKiqUM3Okls7VMkZU8AY07y9YIeB/uYWN8oNRokRcqXGCd2N1HNgqDE9U1hJIVCzBPWUkddEaSU3UkWIBtBuQkvFul5+rifxh1YExi+VsTQCgPTQ53XFOQ8aYpY2J0rEdE428qW1SnlPXhfiGrDK/Ki/Z5/OT/j843/wfT7eL/zvnvyiT+fp/J47nzw1j+a4F2XAdYKCEZVUPIZVgfeiNJYiapMCvDetMrOScsY17FKuFV0VXWeJsTBPAXOu9UyZ0ymy3Tisl2DKshaUKrx4OeC9JcbM8RShFGIUD1iuArq3WjW80zlV3xqglMLYtuZPrcgc+X7OCbe0aoiT5vV3Azu/Y7cZeVgeQMNtd8NgDFBY4kpMAVUMqUSWsNC7AaeNtNFkUVmnsPDR8YGPpj1LTSxd4dgnuh42VuO04QvPR776+Vt6Z3DOcPdsw2lOku6tFdsLsiiF2Ibo1lbTkFjeW1mrNnSQOq9Ec6Qsi6yoW6il5NjQOpp4OmLHDboa0jS/QzuptsouorL1uw2urfrPAafz66kaA1P5Du17wmHPev/QfKkGtG+96RldNDU1pQ1FrYVKphtG/DC2KleN0uKn1EbUshojcZlQVZGiDJX6vM7V71S5s0dUuZZ8V5X1JAQApTS5JfVVFdUuLAtVg77aoEomhcT47Jk0/LThQ3UdtIYmmYIQyLl1YDzptKeuR1EkS+YC+1eCIKolCUxda0BjNju0MxDmNoQPEqppK26QlfPV3TPiNEGYcMaDEiuG8V6sAKrxLbUCZcE7lPU8fu+7xMcDtuub4lwbRaC93rVifYe2YpEwnfTT1xjFu6k0eRGeqnE9pvcYb8kpEZaVeJpR6AtKDFXbDVKRli9n0L1vPE/LcHODGQfBMFUJHclgLjxPYddGqrKkEOS9qhltNdrJavwM/c+r2Ec4Y9tSQRsna/7GKy05yuchSf9806UvXFzbeciV5XSk70ewlZoUbjM2dFj7O8tCiBGru6eKz98DRynF4A2d1ayp/P3/wtN5Ok/np+Z84kH0cAxycUXai0y7DpUqiXNjNCEkCa1U4X7qdmFN+aycKmquaCOKZCmF00lWyFpLMGk9ShPOdutxLfGbCuw2ht3VACjWJXN4XIlJFC201HLWUtjtPKqpdLXIgOpaKlhrgaynlFFIZaeqBWPURd1LSfG9b0TSyfBsN/IQHgk187J7xqDlor2EIINsFkTRaT1KfSUKq6ThqVSY4srH0wMfzY8cVWTuM2tf2Paa0RkGZ/i5Vzt+/jPXeCec0KtdzxLEa/nszpLLTFo3FCeDkW4sxGostpMLv+082sqwqlorUV7nBqZXLRG/NhZk89jliLWOugiv0m56YS4qdbkYYxX99TV2M6JSlHQ5CpAENEk8mNp70Irl/p5ymhobVEkgqbbVbQtS4RxKWwgLxkG/ucb0I6XkFlbRl6BazUXU3CD96qkN05J6fjd4CudABh9VK0UJ+iosCzlLmYCs9AvKanJI0sCUEmqQ2sqwBIa752yfPxfMUwvOEJOglFqwS3tRQguafLxHpRWttAwxNNA7NFZqBuvE8oDC9EIBkEEM8C2Br8q79DgVivhfB1Ng6KlKkedZFOdzu2YSFJjQASzZevbf+hZ1ncXC0TBXUmNfyClRSsF2Hbr3VFrAb1lQKNx2B8aQo/ycm64XRTwn0jwT15U8h0v5gGCekHkfQbKd0/QlZ9xmYPPihQTHSqHW5tW1VtRPpcRnrIQPHOcHcsktzNYG0N4LrqsqsZZQW9UrMoRqK+v+nIUlG6MMuq0Vq7YKYrnxjGJryYX1eMR1HW4zkNcFvenleQhzihoTKSZc16NyU7Wfzk/9+dN/9It88/WJ//v/9zuf9kN5Ok/n6fwA55N7RI3lTAbMpUqDkTPnuYUQM2vMUEWNPFdr1gqmrcVp6eQYCqVKml2CRe8wTMKOlNBSTJmcMzc3PeNgCWvhNCXCklreRIIR0p4EfvRQBbCvbbs40vxnOZOyXJRQzXfqzt9bLAQKeHgdefww0bsNU5lIJJ5vnrH1PUZp5mUlxCQ93wWmMFNzpbcOqywKzRQm5hC4Xw58vB7Y28DRJbqN4m7scUZzPTp+/jNXvLzdkGPFWc1m0zHPgmF6djsS1kRKezrvsdbirJLhyDu63uO8BbSksbVp/EVFCaERAGQdm0OSga4UjHUy0CA+01oqtvPvwPdFKi/tONDttqKcxUhpjTZVNa5okjAaxpBzIt8vwoGsFWpGKUHmcK7w1OZddacGtx1x43AJLinUxSuoEDNybn7Qsi4NC9XwQkCbQkXdPTcDVRnQilYs09S4lIrSFF7Vbk6Ms3RDR1xXurGnKsvuvVcMu13DOFnxvBbxzpKlkUr7HmUb6md6kOYmY2S1XGlDVpShS1t5zrSQj+1RFGpYZEq1vg1x+d0KvxZKSsTpSDwc0d5CgbTIily1obOm9vlvyKVUKvN3v4MtGT0Mwv0szaubKzkLpojGdq1VkvVpWdGdxVgvVocGg8d5apCSgLwu5CRq8QWx1fBKpfmBFQrbyxq9poLfbhlfvpA0fz4XFMjKu9JeS7tDUSUdf3wkf78a3nUSwmpDZcmJktsGwEpdLsZgjeDMclwluNUKHmqKUKVSNudCKVneO61ZTwecd7iuI62LcEPPam2V0F1pJQIaKLVQav5Rf88+nd+l86WXW64Gx36On/ZDeTpP5+l8wvOJB1HvtKhIIPB52/jcbdgspeJtw680LI5uFZq6KgFEF6nU81Z8miEVjNI4Z6i0gbB9v5QyORauryXFuz9EUirEVNHWkEu7MAHeWZzT5LZ6dE5aoKS+qSlCWS6gCrGBmdY5X6sM1ciGkLffy5RoiZ081+fjLTfdlkphWVdSzKQYSLkQwkpKid7I+k6h2c9HHpeZqSS+F+95YyZWn7i7drzY9XTWcLvr+MKrLbuhZ42FcdT0g+c4BazWjJuO6RRAiW/17f1rSoHtZstwvcMPHbbrWs2nbipQU4AytMiyDN9rpKxBlEbnASUNQCWjeo/OVeDqtd0cOIfbbrCdp+Yk4ZW29kbJ11YAWhA+OUZJKFcZkqVPXDrrJWjSAPdWmJZaa6ki9U4ad4r0pJ89vCCfmRxW4jrLY4upeQkbDsy1QbE9bmtaM1FJhLCQYyS3kJw28pk0zqCK0BpKA+u7ocddXdFtruk2GxkQmypca734QZX36L5H2Y4cVtLxUVL6unWjK7EB1NwYnopLfSzWYrpRRrBVeKUYI1ttEM9mU+NziKyP96RpwngvyfkqdZ7aCsRd3isu3M+4LsTDAQOYzdiU0kLN7zyhVWlZL5cCtt24hIRyonqW5mlVRjyj4mrILR2/yMuiJcSDFiXzYiVQUrEpCnbGbjcMd8/QTlb/Z2tFzUVUWGvkhgNFOu1Z9/cUVdrX0k1xtu0zjPzOybG1LtWGcVMY08J0tUgyniqf/SxDowyPqg2h8trlFPHbLapk4rpgvJN60NZWRc7UqrDjVlTWEC/M5Kfzkz3f/fp6EZ6tVbz3hR+uzepP/ZEv8P/+2mv+6m+/+TE+uqfzdJ7OT/L8AB5RCd6AQltFaev53BLQ3svFQDiiTSUN0phkrG7+wnIZNM8pX61BW826RGjMUWc18xTRFaY5U5eMBjpvcFZS+lo2xLgz5L4USqmNGa4pSVRWub5psaYVCVChwWlNLjLYnh/P248jj68Ful813I03PBuu0FSWNZJjYQ2y7l1jJMQVpxymPeGH6ch+ObIn8Jojb/wB3Ve+cNPzfNszdpZXzza8d7chJ+m2v7rqoGruHxY6bxhGz7IktAbrLYfD2lLpM0t0DOpKQPDI4CesSRmoW86YvEbiulIa6F5rqVcERY0JrME6J17euEgy2gjs3I0DxndQMjk1tU5xGZ5oinKpmRwzJeTv6wfX37+dls+K1k2FVhjnsNahrL2k9JVWTQkX9bDmTA6CByoxIOaOFiyjim2gpaNBBqRaKjkH1unEOgVMU9+1FVVSK42qWSgLtRLmBWUdmxev6HbXmFblKiqu3LhIyEjqHXU/gnHkZaLMJxSleR5piXVNyVGG+7NVoIB2Mkyeg1eitup3YayGUKpKSbPS/VtiCwyJUiyfXXOJjre/Sxuml4k8TWgqpuubB7Rgjb4okVgDSl4/N3Z0260M2LqB/UPA9R3K2AtzldJutpYAmIajEo9rCbENoUK0kJubSs0JN470z+/k86PkB7TE5VJgoFobVs3SxrXu78k5yY2FEhSTsi0YVCqQm/pbz0ZPFEaYskkUL9V5eS4pCpf1/B4oQXjZ3qOMIR5luLeDJ54mtBNe7NnOUlOkVOQGwEpoURhzgh17Oj/+8+G3A4cHuXH41t/5vkHUKVKqfO7L3Q/1df+JP/QZfuujAw+n8ON6qE/n6Tydn+D5xINoiMKq9M6whkwupVUACog+5oKhYozgmyoV7w1Ga1ISX6Zp1Z6yLitYq7FOszbQeYyFrtN4Z7i66kkteX+ebEptuQ7kmqy0brxKGUKVVo1hLX/eNqh1Sg2UjrpwCHMuFy5hAR7uI9/67ZWUHN2guBmuuBtvMVSWdW1d9ispJ2LMzGHGVAHqKzSP88TjeuJBnbi3Jya78mLr+OyzkW3v6DvHq+c7rrY96xyIMfP8+ZY5FO7fnNhsPVe7nmkKOC9+0eN+wTnD7nrgdJqxNrO5GvFpxHbC3TxPftpIACeugbSsxHnFtMCQVCsWam0+zOa/rDGRc5YL9Djgxl4U48aoPF/8MS0B3ipV07mruw1tMoC9W7HXktsFXmpcMfriW6wg/M02ZF2akpSswtO6kJZFBp5GNFCaFjyR4fPsIzTOAoU4T6RYiGskB4HxGyMVliVEjDVYp6lFEdYV1/dsX77HcH0DqDZkV2po2KICiiK+236kVEU+3KNSkCEMSXAr1WDqSfBAZ+sJ2mGHUbJwtco6HtoQ2mbJEmVg0oq0LKwPbykhfJ9Pt32Oa6WmLMrdWbkG5v0elRPWWsC15iBhp8Yo3ExtJHhWaqXbbXDD0L4Gl5s0PwzyuHNunspCiitxDoLRquLAFXVWkv9n5qcyRv5MSfirDcPdc3S70UAZyjoJ39RYKVMAalwpKbAeHi699jlmTO8kxV8LxMak1TJ4lxDlhsJ18tq3KtB6htwj/tqL/adWUghYL9zdkpPUgjpHnmeUAtd37cZaDAMpBpRylxICZS26VBlCnwTRH+t5+1Hku98IPL7JLNP/v/82xcpv/cZCrfD5r/zgw+if/KX3+Nf/0m8/DaJP5+n8HjmfeBAtpeKsrN1LlkFT/GIyGFitWYMMd0Or+YwhcwwRazVD76gVQkhoVRk3HblUjqcAFa52nkpiWYX3qFp9qCqVlBEeYlNljdFSUwicwdzWSUgixXrxrZVUqaTGKaX9d5F++Sp2A6MghMJH3w0c9oXdxrIbtjzb3GC1YponUiiEdWGOgZor8zpRSsZrj6qGx2nmTXrktdkz+5l+UPzS8y1ffLnDtPrKF8+3GGPYP84oVXn5fMcSCm9eH7m5Huh7x+G40HUOpRSH/czuqqfrHPvHBWs1nYfT8R5/dU2nNqKENnWqlMo6LaQloo3GD5sWjCmtp7xgelF7cojUJOEO27tWpSmqT2mw89rW5EqJ5xO0FBDESF6ke14Z24Z+3cJD71RzaqUkST+7cRTFM7XWpYYyOgPwZfgNDaAuZAZttHgBdQOPIv5erY0kx7UEhJbjiRyCKKVVGrcqmniGvueC947iHblmdnfP2L58hes3ooJaWa/XKKGt2lbOynh0vyHGCOtRgkdaVP/aXg+562lBpqbKK9tJMh7pZkfL8K1MC9HkM3LLQFXE0575/l462LWhKlk7a2tksKySRs/rIkl56winE8SIcVYGxHZjV2uhNMSRdR7tHClG7NjjxlFW5C0hr7SWitjWqV7iOyU0TBJgUg2JZXuPdoa0xqaEGkAG/Qr011v62xvxkOaM8lq8tesir9klfBYpWQgIpVZRoHOSZqfei+0gV/kaSN0rRT5HtpPgUilF8FVnTqtSEpprQ3iplZQLdhjaDWfEWA+9oyaxqCikaMI4J9XFIUDVUv8apJ0Kc27oamufp/Mjn+mY+Zt/dWKdK/Pp7/2axlD57b+5oBQ/lDL63/6nf5n/yb/+Vzku6Yd9uE/n6Tyd36XzyT2iVpNiljS0gpoQeHtvSDEzrZlhtHhnmOfENEVSLmw2ju3GE2IhhczgNdoZ9seAqtJPX7L8rt9uPSHKxa22ehbnLSbXBssvrQb0HGgql2tRKdKIVHK9DLzeKowWpFEpcoGiBVtyLsQo69HHh8R3vh3wvmfsB56N13Tasi4LYY3EEJlXWR0tcWZNAYcl5MKcTrzWD7wd92SbuBk8v/j5K77w3hUpVFKq3D0f6Zzh4zcTXWe4uRl5fFw5nhZe3m2oSrPfz2xa2GqdV26fbTDWcHic6TvLZtPJEDtF+u1rfNfTKY1SlRQTcZlBKezQoatuammhpIoqDYfkOwnMNMXIb3rcsJHBExkMtGtDPJIeriCMyXUVa0XO4qWjfQiKeEurUrICV0rabhQYb3FDL13fuVx63kFL4Mk6NDJopFVCPNr55uPNlBzaGltUU610Q1lZWWUfT019VcQlkNoQHdZI1QrnHZTmaQauXr7k6tV7aN9xpgfItJLeJaNrFTxTNxKXmbqc2kNWnMV5pZoSXVILZFVRYocNbtw2vqeoeiiFsl6G7lJaOEb+/vp4z/L29cXOkEvF+A7tpFWpRKnwrI2LWpRieXjAKIXvhxZuinLz0J6KOXfOI0xfv23M0nURX2+MwiK1bYCttbVPVVIST6i0JcmNndT1Nn94EqUbY6hZblb6qy3Ds1u5v8hFcFcU6nqSdbtrJQBV/LNpnsSzrC2lBrH4eN/uRprHtpx/qLOAFoYR1V4TVaVBS8rTUuPjyguYU6Sg6K52QlpQGuP7htJKku4fOsqaZFPgHOvpBFUG9xqj3KzmLENop6CaJ0X0Rzi1Vv7yv3UA5HfwMtW/z994d2L4+w+s/3HnF96/5l/5r/0x/oX/9V8iPt1IPJ2n81N9PvEgGmPGOVmzhyB1nNYo5mPEOs3tTU8qlbdvZk5zZOgdL+5GrNMcp4Sm0g+GlCGuCW9BK8PuyvP69dzW/aJuOqupRrW8ggxJ4dxhXxDFQv4VCsFDxSwpYoWsi50/42tU67KXAdQoge3nVLBGkYrit35zoUTN7nbDs37LaD1hXZjmmZyKpKRzIqTIcTlhMBzjAhZO24l1XNgaxfWw4Q98/oaXdxvmpVBL4tXLDc4Z3t7PDIPl+mrgzf3KNM185tWOVDWPDzPXVz25QAiR29sNucDj48x24/HO8PhwQlvL7nrg4+9+QIpw+/I9SpLVpes6jPdSUZiKqJ5KNdXMiU+wFNI8gzEMz27barsFhXwnQ2WsKNVQQkX8W3ENLZB0VqH0JcBRS5KBVWt0A8tjNN12h/G29bmLTxWlJL1twPiBqi3puCccT9Lso/R5K92CLqJqUwsKdQnwrPPMejjKalzROuxpvNpM33kBlGdRwJUz7F6+ZHv3XNL1xrTQT5XAS8lNBWvr364nng6QAtoa6tkrqxELQc3N9ylDci4Vs73GjVtJ0pdEVd93wW2Dknh95TO73N+zvH0rg7I2pCoDNSWTlzbgtiCU0lCMZrp/YGiqNkCOhZIKKWaslbCX3+6I00xOGTsOmK6nxNgGv6Z2N4LAu4Q55BRlCDX6cuMAFdNqZUtomLVWo1pRjM9u6W9vRL1MEdWP4m9dZuo6y1o7rkJAKJU0HYnzjDqrjKXgrjct7Y54ctudZVVQlcZtx/ZzL5YJbaVSlZREXD4n62slo3HDCOtKLVmg/SgJLjUrRZ6jrN07z3o4kueF/upKGsFQbXsgw7nKBd1173yrT+cHOn/p39oTFqll/mHPt7+2Mmz0D6WKvn878pQzezpP56f/fPJetAopiFo5DJYYMsuSuLru8c5wOkUe9jPLWnh2O7AdLUprjicJ3qQM65S43jq6zlNRHI6JlODlS7kYxVVaUQqK3NTKHDNKVbyzUhuqhDcaW7tTToUlyDBgDXTOUhAuaa1tSE2SSrbICruUgnMGYxUff3vlo9eR6+2Gq25g63tSCEzzTIqRECIP8yNk2AcZTEMJRL/Qv4RuA6Ny3G57vvpzz7ja9nz8RgaBF89HnDU8vJ3pOsPVzcjHH59Y18SXvnBLKZr7j/fc3o7EWFmmldu7DSlVliXy7HYkhczb10du73b43vF4f8R3lhz2fPT1lc5t2D67vrTW1CCoG+W1rERRTWErxGXB9h3dbncJeEnGyEh7UmqInobHSakQlxPWDRdFr1ZkyG0+0HOIpqZINho/Drihx3rXWK65hZwKNcuQqqsMy3F5IC8T2rTAWUxCV0iZvK6ywTeihGrnKFUzHw+kaaJmUFasBGdeLFrhnJWkvKqgCnboufrMZxi2uwZ/15cUtgw4Mmwr16Otp2pLnvaoxjWllDYcWc5XtZrb2r0xS831La4fUCVJXmtt0HXruHSaFrmhqjGxPr4lzav4PqMgr6yz5JikfMGIvxZjsV1PUZqwf6DrBUFEyWLZtVYKHFzBeY/xsraPMdENPbYf5fs2Dyg5NwwbArkviYKSdfw8iye2ymB/Hpy1EWVc22YDAGqM9NdXDHd3cB5CvZfXI0bKPMnqPCehBeRKXCbSMouXu4Wn7DBeuKPiz80XvFcOGdOJpaPmLM+hhbhqkrIHGk4qN3qF8566LFSjscMooaOYqEvEDJ68tkaokonTxHKY2N7eyKBuNFgN1cmgX5GqON2KA57O3/OcPeV/6z+Y+d43QvtnP/rXlfvh+kPTC/4P/51/jD/zL/+5H/2BPJ2n83R+YucHUkS9NxilOJ0CXWd4+XJDiJWPX0+cJqnW/ML7ooKGWAhrJFdIqdI5zXbbU1Jhf0jEVAkxCf6oc1gtCJmqFKjGOqw0BUu9CyXUSs0V25L48yKg7qtdL2xDpCe65IrWzddYJEl8bsfR2tD3lsfHwK/9tQdOFF56x8736KqZ14kUIiEE9uuRZV1ZS+FhPtFZR70JXL2CoTcYZXh+M/ILX36GVobXbyZqrbx4PqKq4vXHR/rRs7seeXhYsFrx4rPXTEvmsD9xezuyBLEJPH91xbJEwpq4uupZl8QyBV68uiWXwpvXe4axw3eew+MBrWec6ygxo1wnZILSwiGtyx0ltYm1FPxmxG+2ovIVqXqsjWGp6zt0FsYQppl0mmRlWRKVculwl6518WtWbWVFry1uN9JtdlKPuCzUUkRhM1ZWsyiUltBLOB1I8wnnu5Z6FuxRTVFKD5RGq4LyDuM9OUXmt3sBkxuD8RpVCikJikor0xqMFFpXtHH4q5HNq/fx40aGSK2gVUwqpGlIoaBVo1Y0ZXpElSTr9JzkMTtJZteKrPGVBl0oymC3N1jfyZ+NQXyIWktanSqqckOc5TWwPLyhhAXtPCUI37OeUVhJWJrGSBDLjCMhZeL+gX6zkXasmNCuVV6iMJ3BWoPxHfF4ZD4e6ccR0w+iIqbApYUJZNgTCCm1OPIaCeskHtuQWl1rfZcax4i6XBvrtxbxhN49A9WqXrWh1sYYXWfO8H/lHLUqUjiQl4W8xmbfADN0GCf0BMJCjalZOgTzZnwvrWpnb3fJ8vVQMiAG8bvmEonrLH92WUEZVNeDk88gSYboskoQTBtLSZF1Xtm9eElZV+GhtpssfWG1ZuqZ5PC0m/+7nlorDV7Ah98O/If/wfwT+T5/+68v9KPm5Wd/cKSTMYpNZzmtTzcTT+fp/LSeTzyIDr1lWeS3zt1dzzB6DofIm7cTS8hsNo6rjQOl2R8ElB5ywXvDduPJubLOEec0XacRbranFPHGlbP/DtBVoSqCFVLIhQ5FRv5ZJlOShKGsVfT9INtPSkv0Qs4Czy6loJXCXqq/FUPnmefI3/j1B77xcOAztze86Hb0yjPNE6d5Yg0rS1g5LBNrTLxdj5SusHm/8uyFlSpPrXn+bMOXPnsNaN6+OWGAFy83hCVxOq3srgeGTc/j44Kicn0z8HhYWZbI3d3I8RBRCu7utsxTIJXC9bMN6xQIa+L2xY6wRt68PbLZ9mhlOe0nusFgvWOZDygMhcpws0MbT5lXGWicaxzQTLfZYr3UbYKEPmpKDRXUsEDNF7geDuQ1YHwnzUnKyvpeayC1xLT4PbVR6E6wQMZ7GEbqKl3u2nvxE7dVLrVQ1hW0YV1niAGrLZw5krWgiqC5tDco14PW5BRZDidqShhr5OYERQpZhoumdMvq3KA6S399xeble9hhe3luwolsYSolVZ/KO6rtyGjy4W1bTWtqWUUV1NIWVJWmxrWhqjTKj/jNlYSw4gqp/fn2mIUMcB5CpZp0fXwQNmWulLxe/JZUsX+gDabxVtUwsi6RMp/w3kvPe5JmKG2kVrekgtLgnCWtK3Fd2Nw+w2hLNZoaVkD4puqM0ULS5mhNDpG4LljbiT+SIoGgmttwVlFVyBRpjdSa6a639M+eCZYrJbS2wrKtUFOjDkALsinC6UhaF1E9NcR1xdsRY60o0qmVASjxBVeUvKdKUVb5fVNSQvet7rVUIUC0bvs4L2hVxZOrLXYzyOq+Vc9qZ1pIUaGwVCWh/M3dC1TNxBBpH03xheqGOCsFaiYcZ/yrz/2Yft3+bJxaK8tUiKHyV/788dN+OH/Po5Xif/sv/CP8s//Kv/NpP5Sn83Sezn/M+cSD6DQHNhvHzc1AqZWPXi/CuKRytfFsNg5rFKcpkmLGd4Zd7y8XmM4ZTOfJpUhFqNUsq3jWjG34nFooVZGy4IgkOW8vPh9lNHFtnrZc8F7jnW0BkgpG/m5Kcn0/h5oUVa4rgLWGECJv3p74K3/nNb7r+EJ/y5UZOU0z0zITwkpIicM8cQgLJ1aGV5X3Pjdws/NQFUYbXtxteO/VjnXJvHlzYBgcd883zFPicAxsdz3jrufhoQ2hVz3Hkwzpd883TFOm6yy7q579fqHWyvXVyDIHSs5sdx2nw0JYIrvdgFIQl5lx01HRTMcF5xPTpLCbnr40L6NzkgxuwSy72ckQqhQYJ+EiFCgjjUOlUrUix0jcn4S/6CylyEBSSpR+9LamFmZlJpeMHx2u6yWBrKDOEv4wZ77kmd1apeHG9Bu661v81RWP3/4twjJjjQUjw64+8ya1DFvr4ShQ9bZKJxdSW4sDjRkpvtaUCt1uYPfqBf3tc7R2zWtZ4By0KucVn0Z5B7YTusL0gFa1+TQbukqpC76nrrP4j9tjNY1KUFsFqTLnAFBL3pXWJFSl4zweD/L6aU3NyGvYKA4lF5RRaKQZS3vHOp+oUfBMJUVyiNJ6pI0wVJXcrCktn4mUMr4f2j/T0q7V1vHS8CTvRUUg/zksjbtrxIqhtZApUisf0CC3hZVwnCk5Mjy/obt7gfBEm/JbJQ1PTu2/SwuwZQkmxVW2EOb8mouqleYArBIiav5PrBFigDbNk9wGb28lrJWkZQutLxgxVWTzobVGDQPaO6qRx6R7UdtVjA3xliAp/DCIlSSsQidIWUD7Vpi0skmQAFr34n12n/38j/6b9mfgHB5zK4qAX/v3froH0O8/WsHPv3fF3/lg/2k/lKfzdJ7O3+V84kH01asNfW+JqfLwGNkfAilXtr1hHKTZqGRw3rRud4kZOWtaj7wMpOe6z5iqDAUXrug7Q9GZzGK1/J1zUj8tueGjpMUJxDKAEk9oaclj5wxGV3I6+/vUxd+XYiKj+Pd//Q0xw6/cPOeZ3zLNM0tYCSGQc+a0LjzGE/YavvKFgfdedfTOMs+ydnzxfMvts5Fpihz3C9fXPVdXAw+PC8u8cnM70g+ew35FUxlGxzxHoLC76sXq4DTj4Hl8nNFUus4xn2a00XRDx+m0iA2hc+QkATA39o3pGvF9qzQtM8vhEWcM3XYjLEelsN5JA5O1bZ3ceupb8EhpjdGaXBJpXQn7A6qoCyS+nN8IkCFKKfl6zoOqOCepeCrCp2zKmwDAlXS0lyJBIK1xu2v89hqtFcYM3HzpKzx+47fJa8Q6GXpqrZAhLZEYI+sc5DNThQMLAvE3RpNTIkX5TMQ14nY7rr/weYabZxfqgmreVs5DemN/KuOo2pPmBRVOLdhmuASEUGJxqI0vSgXbU5Wsd7VS1LDIytgaYa3Kt5R0fBto0zyxnk7vGpcUaO9bwcO71L1zTlRMpSkxSDFD35GXVfieDWNkjED30Up8synKZ957VJYqsRwCpSmyFag5obW8r61zADBokqiQZ+C80ZfPhes6md9XsWWML24Znr+QwTNG8VFq3ZRa+f/K9eR0ojTebmnJM2lmkkIDnNhFyhqkVlSBta4FxTxnLJS8SVJKYIx4mPO6yvBOJoUAZNzQNfYqAt3XirI2fuTZnN4CdEpp4YeGIJxalDxvKzdBJTY2rNNUZejuXrF5+b4o3r+Pz+EhMR0LX/v15YdOsX+ax1vD/+jP/Cr/3P/iL37aD+XpPJ2n83c5n3gQ7XpLKnDYR9YlIfYpJc1GRpOyqI6lDQCdE35iaOl005pwUq5Iq6QwA6tWslFVtJWjqHhKKWKQtLWuwi6NWZqXtJEeaRC0zRnNVKt4ghTlXR1gU0Xl21dwll/7G6/5xrdP/OL1K97rrggxsYZATIklBNYciW7h+ectX/rKhrvbnhQL85TwXnP3bGSz7dgfVpY5srse8E5z2C8sS+DZsy3OG/aHBa013ssQao3GWMu65gtr9XBYcE6KAcKScJ1tHNFFFGEriKZxN6CNZVmCDDTGCM4K0FqzrnvUwVKtYTcKvNx46ZBX6lxZmVpoqAV0tCLOC2GaidMsYRb1biAspYhVwrrmmxDfnxk7TNeJglarhIwUQFPr2lqzFgn16M7jttfYbpD3BiEa2H7L1Rd/nvmj75GnI00PJa4L6zyjlBZvb2noI9vA+J2HmilF6jHRivHFc26/+CX6qx01p8btLG2IPDf7tDpUYyVlfdxT44x2orrXquSPts8NKQqiqULVBu0HTAtN1JzfKaYli+XhzHeqhRxFEQzHoyiTgNFa7A45ybBUi8DWm+1BOUdYV4wW2kE5tyPJvuBiSxDIPJQgxQLGGRnSrQR7VD1bHVo5ARWtPdWIFxUlP2c15uaF0ZzrOJVpga4qP0fWa7pnd/S3N43xGSTwpIS9WktGdx26G6USdv+WME9CUbCu8U0bGF5rIRC0ul2UooaVmDN+d43CXD5npbV11aqEXLGsUrtZpbQBBX47gmpM0LPSeppFRe06yrqKhaANr6YpxTXEVhYgVgTx8oj393xjYK+eMdy9QNUkN26/z846Fz74lgz0r78XeXiTP9XH8/H3Itd3lq7XP9Tf773hH/uV9/nzv/69H/MjezpP5+n8qOcTD6I5VeZZkvIxyWrXNYRTjJlUZPh0VqozS5aucWlSkrWpaXV6xii0KYRmDBXItPA/z0pSbgqcVsjAigyqSmlKyW1A04KFSUmU1fY9ULK6c063CtKCsZK2/9o3D/z133jLZ7tr3uuumWMkJelUn0NkZmW4hS99seMLX9iwGT3LnDgeJZTx8uWGzcZzOARyLNzejgA83M9Yq3l+t6EUeHicGQdJei9rpOucDAa1MmwcYc2EkNiMXWNmFvrRk3IlLJJetwa6TiwNIWQIK85bUsrSiKTFK1lyQinFOj/S7baYvm/1hepd2j01359uyp9SrPsD6TRJSKP5PqWOU6MoqJLlQt0GG915dNdhO4+xtq2VW3oeSVcX4bWj2srZbLZ0V9eYNrDJYKUlhV6FEalfvsfxe98hnU7knAnLQklFvH/thkM7j+2cBEmytDmllFDWcPXyFZvnL7F9L4OOacpmlMH7PECjLBVDjit1OUCKrSjhovtyrtGU9p5CVXJDY/qNhLxiaI//rKAiqKYK5HAZwNfHR9LpKIpgbYPwYFHWNp+u+GaVsShnyJdAjTRm5SVIAr2pzepMAmghIvnMBrGuNBVTcGYX+FW7ORNwe1VKhtJcoawNti8raFEtK1XJ96mlkkPEDY7x7gXu+hqVM1DgXCmbE8o6TD/Ie1Iq8XQkrAtYIR0AEoQzrTkrSmVnye1zg1AH7LjFjmNT1VN7v991zufmFUUpqR1VYLqOEkRxN30H1lGWBVAY30tQrr0/uWR5n1v71BndBaIWC5lDgZfSDTduGZ6/wmioQSwCv19OzpWv/Y2Zdal89J34aT+cy/ngm5HPfbn7oQfRTef403/0C0+D6NN5Oj+F55MPoq29ZY1FAMEVtJWLnfcGp2RITKmgKJjeEmMlJ+n4tl6+VWkrX6Wg6ywhiT/OtJVoTvK1rZE18nmQqKr1qyOesJgBCroWfOufd51c8HKpdN4RoshbXe9Ylsj+sPI3f/MBHzwvN9csMRJzJobAFBf0pvDyc5YvfHHk/ZcbStUcH1dOc8B3jvdebOl6z+N+JafC1VUPwMPDLFWcVz3zHFhC4eZ6oFSIc2AcO0pL7/eDZ57kF/wwONYlYK3C944lZGIoaCrOKbreobVlPq5YI4D2dQ5YJ9WdNGVMKdNsCYn58WPi8gLbWVRGVuOt5ahWGchKTqRpJR5nyBXjrShUpUBtCmRrnkEJh9HvxsaUbFzJ88pTGUnElypg9VIpNaOMwd/e4XdXMhyVIoEn0XDbxV1BShhj6K+v2Z8OhGVmXQIGQ1VyQ+O8xQ0erQ05CVqopozrejYvX9Lf3Eoav928SEOPDIRaa7C+oZQM6fBIDRNaVUm2GysqKWeAaW2gelFcazdirBaMUC2tqvK84m8KaG4cUpSEhg574jS1tbgMhbbvBBLf2p5KU51t31G1NEvpWtHaktdImldxUrTHpRQopOmoOo8ZN6zzTAkL3TC2sFASddbotpovsjLXSsgJVcmgrrgwdlGqqYAFsNIfECNaK/qbG9xmCzGIim1d+x4RbZywZ1tjVjo+Evf3Mujq1shFQXcOVbgEgBSqeWUhrRHTDfjNtvm4cwvFuXdfoxSxDBQI80JeA27oRdU8h9e0EeqCMUIwqLXhsqBmsW6kZcZZg1WaQm0+ZiceVpBu+phw1zcMz18K/i0268Xvk9T8X/9/nii58vqDn82E+avrgX/2j3+J/9Nf/vqn/VCeztN5Ot93PvEgWiscjpE1irLWOcVmdDJMhUpeE6om+t4Qq+XhkLCqsB0dpcoq0BpZ+6Yig2ap0vVuWwL2HKIptbaEtBZFSJ2zKaJixFTJgFa1VUGKQhpDwdrC0HfMS8BbhXWW/X4lhMjXvrnn7ceRndmwhsCpFEJKzGXm9j3Dz//8ls99dsPN9UBYK/v9zLokxrHj1XtbvLW8frsQY+LmWpL69/cTvjOMGyfJeKV4+WLHuiamU2C760iNdek6xzQF+k5e9mVa2WxkQDmdVnKu5FwYR8swdsRYCMvCMDhClDX+ZtuTc4FcsNa2ApoidocwM58mXn5xlYCGbun4s0XBeeKykg4HFBrrLNU2VMFZIWrrYqW1IIZKwm92GOvQSobfPM+XVes7xbUpazWjup7h2XMZGGp5t+puIZNmcmy+zURaF6b7N5QCfhyJMbFMC+Mw4DoZAktqzNNSyCXR7a7YvvoMfrOVYaGti4mrwMib+n4eQmvV5OMe1klmyLY6Rrc1c84NHSVKaM4FPV7jvBePYK0S7iqttvPsQ6m1eW8V4XHP+vhGkEboy3rZ9H1jWgZySqjSYPGbkUqlLAvGOhRFvJNR1ufWe3JOpCQ1lRXIStNfXeGchZx5+N4HYAKDNZebtrxGLgglIK2hTVrNu2rkZkC64gs5v3u9UhSI//j8DrfZSRJeaZRvdZwpon2P8t2FwxoPD4TDg3hes1SS1iKIpnNw6jwYqnYfkkPCjFu872QIjaI6ais2g5KjWBOUqMYxF9Z5wWpDWgR/ZfsBtxmEABAjdhykvCI020MtOGuhwJQrOSeG1jlPSKQYMM5jO0NaVpTvGN/7HH4YqSlcwm1S7fqzef7WX5s4PMjafX//6a7ff9Jn2zu++tmbT/thPJ2n83T+I+cT/4Z9ex84zImaMzdXnusrjzKGacqkmHBe0Q+Ow5SZ55XtxuJdR1xFEQVZ2RttMA2zRH3HglRWSRCiFKymJVcVxgoL1BpYV1E3TFtvGq0vF9d5LQydhA4Oh5mb6w6lNB9+fCKsif1x5evfOGGTI5F4CIE5J3Qf+fyXB/7AV674wmd2bDcdx1Nmv19Ylsx243n/Mzsqmu9+dCSnwrNnW1Kp3L850nWGvne8ebMw9oa7FzseHldSCNzcbFhX4ZwOQ8c6R8beXoD8N8925FyZjis5A7VwcyUd4dMUMArGTcc8R3KuXN3uOB0nlELS1FRpOa0w7fdYv+FLv/IrdNudMClrap5IGZTi4UA8TdIVrqqsR23rT8+lpcTAeCdrZ6voN9fSvoMCbak1iZXCqObdzM1XKVWj9vqK7fOXkg5PS/MgNrA7inNvvUhviTBPHL79DYHtO0/NMG421JzJCobNeEFNLcuMMprNizu2738O6/vWnNTJMLnMECPKu0tgSllHVYZ8eEOZT6JuqYZNOnsdU6LEVcI+qkq1eL8T4HpawTn5IWi+0NoeO1W119ewPr5lfbyXmkvEq2mslVCPkgBRDsL0NL5DjQMpBlQtWC+hs1IQdmWSQTWXSl6D3BCIWYLN3XN0LeTThCmV3e0Nbz98jSqVYdOzzitlDbjW3b5M4ulUzUur27r7bImpWmGKoybxXlZvGZ/fofuemgPKOgmnNZVYdwNq2MhQGgLx8S3h8Z5U5GbLGOGk6WaFKFVoFgpDSZGUMnFZ6a5vMU1ZLrmRDahQtHiLU2reZojzkTjNdONIyQnnekEymbZOzxkz9LIVCEFCVCljlGo3MJpxGEgoQs7YXMVjHOSzW1WkGMfV57+I32xauqqFt4y7/Fz8LJ1v/ObCt39rJSz10m77++H86hef8Wf/5Ff41/7i1z7th/J0ns7TaecTD6IhZLyG5883bHei0O33kVIym9GijOPt2xnnKrc3HRRNWKKsx9oqTtSFimterBSS4B2VJsaM1mCcMAStUawJ1iUxDJ7puLQBTBLxqq1GU1WkVLjeeda1MB9nnr/ckjN841uPUAubwfLb34mcDrK2PaaFrAov3jd89edv+ML7V7x6saXvLYdT5PFxZlki19c973/mimXJvP34SKXy4uUVYc08PhwZRoPvPB+9nhl6w831yJuPJ5acefFsIDTuaj84whrpO0OMiVhgd7sjLJH5tIrCWxPPbnuM0hwfT/je0fUdh8eJvndsr684PB5xTaVUSqDtcY08vH7Ls1fv84U/8Iv4cSfr165rDUOakgLr/kgJBaMlCV5CEEwPqvnppDhAfIPCknR9a/4pSNqZgrZexMwofk9tDFlVcsl0d88Yb59TS6Ssq6xWW/sN5+7OXIFMzZH54S37b38TYx3WOEqMMsRYy/b6iuPhwLzM9F1HjIlUM7ev3mP3/mdlwEuhDUmFElZZS1uN8n1LvCtKLcT7DyEs5/12e64tpFIr5ChToBEF3gwDru+oObS1fXse2soAmvPla6Eq8fENy+uPJeQyDK15SWD+Z7W5NkKE6TrUuCGHGaXa606hrFGsE9bgOqlVjcuMsa5t/xPj1R11XVmngzRO+Q7vNly/VJxefyzeaQ3aW3ItxDVIW5KSsJN2DoySkNJZpZYye3It4C1XL+8kpb5MVOfxnfhilbHozXWr1MyomoiHR9b7N3KjgMIYjdKIWqol/V9DaGEpLcPfstCNG+HH5ig3JrXKmG0kPS8w/YYPC4F4POK6rtlvOqqCtC74oZMwmhUAfV4DVQE546yV+VErQTspi1WKEAMP9wd2nW2/QxTVaLaf+zzDzQ2k2LioClzf3r7f25Pa2Q97fCz82l84977/vrK+Xk7nDP+lP/Yljkvk//xXvvlpP5yn83SeDj/AIGp05fmzge2u4/ExcDgGvIXt1hEjLKeF3U5TMEyHzDhKyjdmUS5rC7UobeQ6jrBGT1MixUTnDa5zl9RxSBVVJSX/cH+i78WvaIyk5M88UqvhauvZHyJKFV6+umKaEx99dMQZuN72PEyJb313ZVkTS1q5ujb8A798w+fe23D3bOT2psdYy2nKPDysHJfM7c3Ae+9dczoFPvxwj3eWV+9fMU+RN6+PbLaervO8fjuz2zpubnoe9ytKw2efbzkcFvE+Dh3TacF7S0gVYxzXV579w0RoIQxvYHe7IayF4+HE9mqgGsfD/ZHNpqMoS1hWdtdb1nnBaENB8fj2wHJa+MzPfYX3v/hFnO+o64rZbtC+k+D3aSIeTlBowSPBBmkjDTY5xLa21w3BIwNhmVZO84HN9a2ssHNG6QqYFkIXZTGtkVQrmxcv8f0gvroUWhPR9yGRmjcQKiUG9h98yOmjD7BevJc55EatRBp4jMYbx/T4SHSWYbvj1Ze+QP/spQx2uciqPJVLeltZg+oHGWi0Ia0L6eEjSZFbh4R4Khh78aqWBmHXVlqijOsF+VSzqGHncnjd1vLpjAaSVXg4vCU8PqBrFnB/Sihv5TvVgrbuEraz44jqPGmdUKWgW9K7xJWiZY1es7QtqVKbQhypxtD3HWU6kmLCdA7T96SQqFoxXm/RFJb9Ed2QXOs8S6NUFZ+kPnNatQVvqDGTTyd5D1OlOsP1ey/EG9mqOeMyE5eV7fPnqG4UNblmqIU0z6z7e0nfK43xRuBanQdv5QYmF2mPUlCNVMP67U4S7iXSqtPE5qDaDdAqgS+UJqdMXCa0dcQ14foBrRTrPOF6j+u8BPByIc+rqK9arD5nxNVZAa+tLKH3nhevnjNPC2E9iH3o/a+wefZcCgCaGnr2pFMKKkw/hl+1v/unNB5uzpW/8H97YmiejzWazprLfdjTeTpP59M9n3gQvbrqMFbz8ccz85zoe03XOx6PEpC4vunJCeK00ncSGEKBc4aSC9oaUegAZ2ANivvHGWcVm60XdaJW4ULmgjGaNUpAqnMGq8EPjhwE2RNDxihZRx5Oic7D7nrD4z7ycH+ic5phsIwbz1/9zUe+9/EJ3WV+9Zev+eUv33Bz1XN13bEZPbXC/hC5v584nQI3u46XL7Y8PMy8eXOi7y3vvXfN4+PK/cORq13XQksL11eO7a5nmiLD6EVV3c84b+l6zzwH+t6SMxircNbycD+RU0IrRddrdruO05RYp5Xt9Sh+z3Vle7VhOi04r7DOsM4LpRRSzBz2M8p6vvyH/zDPnj/Haglt6N0oneAVlsORdDihG8KqhFXUkVZ9esEaKU0OkoIuIVBTIodAioFDfs3Vy/ebF7dCCfJeKSipUIxjc/MM5yxlnZtn8qwiNnBmW2VXpcjrwsO3v8l6v0cZRYmZnJKAzJ1tloJKCtI4NWxGEoq7L30ZO26oMaBdLy1QYaWWwJmBqbte/h2KMJ8op3uMgqra4zEy7MhkWahxEe9ireSqsdtrNJWaVsmd12YhUQpSEGB7qwotObI+3MsQqlWrzZSLW54Xas7YrqfmQg4B03n02BGnCV0VlAa7D0kqR7VpXwNqiFhniWFBX12zGXrSfo8yDj+OVCttUyAtZHlaccbTvfeS6XBkeiuVoBSB2Csj3lytWmtUzBIwqy1Z7w03n31fhunWdKRqpes8y7QwPR7YvLeT1zoXyjIxv/6IOE1yc+g92hiMtxeqQQ7pElyiKtIqa35tbasKrTKIliQ3BVZTUqTGVZqnWhGAaUxbOw5oa4gxoKzFjqNYHap4pKWPHrpxRw2xpf9FDSy5CIfWiIpttGJ3u+VARLueze3thQkLQKpw7rUPi6zofw+dFCUQ+pf/7QNx/dmYtM4W8B/X+bP/yM/zwePMv/cbH/z4vujTeTpP54c6P0BqvnJ/vzItmd3WYa1hfwh0naYfBqYpYVWlHzwxZaw1gnlBkEy5IAxJq3k8RmIIDJ2l731L0YvCWaoEkUKQ1qGcm1KkFOssXMB5jgyDoes71pDZjFrg8UdZq1ur8Z3l7m7ka9/Z8xu//ZYXLy2/+osv+MJ7W4besd129IOjFGF2PtyfiCnz/G7DzU3Pw+PKmzdHrnYDd3cbHu5n7h9OXN8M9J1nmlaurzqcdxwOge1oUcDj48QwdmilmacV4zSpCHCfWjnu5/P4Rz9Y+m3P436mlszmaiBGCRcN48iyrPSbXtiebXicjxPzFNi9eMUXv/pLbK6uULX5ZpWEPdKysh4n8rJgu46aMylEoLUKFUmMa+2oOZFywvSdBHWKJP3RBteNzNOJ/UcfcPP+51DGoL1HUUlJfHnj9krWsOvyjqsp7zpKNT9ikVR5OBw5fOc7LMdJ1rFZE1NjxTaY+vk/567yzfWW3Yv30MZJMtpLhWaJq6iZpYBRmG5AOU/VjnS4p073mIYVkuSMkYS/QlqAkqzKay1UY3HjleCiUpS1fnsOl6MqyhoKmhoW1v0DaRLWqdgZgFzIOTdCQWsx0gq73VCVJh4ndMlQxFZS5pnakvJil9TkWRqPsBZ7e8dwfQ05op8/h9SYpiVjtCVraVwiV1znqShJlfdiDyiZRldAhrBaJLVfgCyWlmw1z95/idWaHJMo2KWgnKXWStd35LKw7t/gjIWUmN++JuwPwu0dnHiKTatCzbJOrzHKPYk1TXWvWGfFPkELAGkaaEpD1ZAWeV1qFtX+vFZvIbeSMzms9DfXl71ybTWfylmG/x97fxKr25rm+UG/t11rfe1uT3PvjYhsq2yXwaKRSgiEBJ4wZYCYwACGHiAhIYsZYoAQMMBCYIlOJWMbBkYgy1CFkctFuSxTnSqrqKyqzMomMjIibnPO2c3Xre7tGDzv950Ilw03MiPzZkTuR7oRcU/ss/fXrP2t//t//s3NnTRtaU2eYg02kIOWUhrtjFyrUTJeV6sV7d1rcgzSwGStXE8xwzyJ8c6IFv5naf7+3zzx+NXPl/P9n/nPLNhc/3RNY7erhsZqpj+FObEv8zJ/kuZr/2YfT5JpuNk4UoLTEFgupPVkGiNGKUIWIGmdrfWFkt2ZasZoKXA8zlgD7bpBFUUMkYx8nbQjSfSKcwajxLQ0x4TTGoVlngLLpcM4W/WjmqZx7A+B02misRKLdHO3oJ8S3/3hnl/5bMU/9QtbNkvRvK1XHueFpXx4Gtg/nwC4u1mJ9GA/8/Q8sNl0XN+seHg8MQ4Tt7dLrLMMfaBtHdoYhiGwXnlKKcxzZL3p5F4WM771hJCxTlzfp+NEygVrNeurBcZo9k9HrFE06wXjEFBKsVh1hDlILE0BjCHOgX5/ZI7wya/8Km++/W2c8zV30lfTUGY+9kyHAwqFsR/f3lJqi1WM4k43hpIC8yyg01JI80Seo9Qpoikl0S07YggMpwOr27uLgcS1S2lZUqXmZ3LZwKu6li5nEBoC42FP/+5L5mGs0ZWFmAIFac+hSMMWpdQAdMvi9ob13St5Ajmjm0aeyzyKgaq+NqZpUa6lYIgPX0IYURVknxlgVbWqpZQaV1QzGPwSt1yhUqTkKlOQF0wYOwpk0bcWpUljTzzsyONwqYPU1pCDRFYpbciz5MAqlASrK8N82GHOtnGtLoDMGlMzNZUAWBQ4g1ut8U17YWHLNJNCkDQDIy7xFDIosK0j50T/YYeq7UspJLQXw1YuZ/lvjVgLkXkaUa3n5u29pFbE+WO7VM3qhdqUFUGlyDQOpOOB+XQSg1DjMMZKdFYRt7o4zaUIQWlNUXUbon2F9aW64hMKXSWqBcIgiQ1ZqmC1kteDxkm+KAKiXdeKyz5J9mdOCe0cbrMWHapS5CAZxkUjkgSE4S1JUglyjGjvae/eiBEsSeqCQoL3c57Jw4RyUrn6szbrrfkx/Wcp8Pzh5wuY/jTmv/Vf+jP84y/2/Pr3n77ph/IyL/Oner42EFVaY7ViHEXnt1x6tFFM1figNPgKNkvOhCA3caU1zhjJ0UxJnO1K9EtKc2lZUgpZtxuFbywpZakBVQp3iXRJrJaOkBTTEOgWBmMMz/tQm4sUq2XLetOgjaYfRj67X/L6upMcTmdYLCzGGk59Yvc88PzUo4zm/n5F1wkIPZ4mrq46louGx4cT0xy4vV+TYqY/TixXDVpr5jnSNvYj2F5UN2/OOCfNR8ZqpikyDZOsO71hfbUmhMCwP9J2AmjHYRaNnTGESbINNQWjFNPpyNDPuGbJL/0zv8r13R0aXZkeU53cMJ8G4jCiURdNYKFWddYGqlwkHF58QwWzWmCUhpSI43wx2OQgTnmlNdY1jLsdxjma9RXNaoNxvjY1JcrZkPQjq/gzGE1zYNrvGJ4fCeMsLTm5kIvET9mqWz27rosquLZleX/PYruVx2AMyp0blsQIBNKwpXyLahaSr7l/D2GUyKZqBVbnMPVUu8vP2ZnWoVvpi1dZzFPkdAGsnJuSamRYBuIwEPbP8n0RQ905PF9rJVKDGCVE3reopiVrSxpOYiJS1YiTpbZWFSUMrDaUUNlOY3HrJd57Adu2NiRFAbcSVZREwgAY60g5M+1PVXIpMgTjbF2LUwskRJ+dYyaEGb3wbN6+wWh1qfi8LHGVrka2LGvw5Zo4Dky7Z+LxRAmxrquV5McGiYsqNUBfPg+kQ6skBKyeJRo1d1bybYX9P/90KcKojVVajE8l1lrfHMXIaKyE0iNAU7UtTbe8XLdntz3WYJylnE9IOV+yR7XRdPdvsJ2kMxhfjWvUFA5VpLNe1cKCefxJP1e/0fmVf7b7sX/PqfCPfu3Hda6H58Rp/8IE/qd/8Zbf/WpPP/98R1e9zMv8SZ6vnyMKTGOgawzdqqWUQkylro3FRJSCGE5yrktNbYS9iKn2i9dqzgKm5oie6wrJ4IzGWKkGLSD3D6TverWwYC2nUSoM1yvJsdwfBIQ2XrHeNKzXXtzSKbNsHN95uxFdqtP4Rlzk/Smwex7Y76XX/e5+RbdoOOxH5imwWXsKmoeHI85p7m5XnIZAmCPX10tAXM3OGWLKWGexShhRSZ1SqCKgsu9nwiw1jl3XYLxl7Ee0Br/oUPlcTSpShnOLUU7yugzHgZDg6vWnvPr0ExbbLVoJ83aOqcnTRBwm4jBijb2AUEoRBvSyelJY38pKWmds22Eb6TNPYcZ4MYSlkMghYRuPVhCmCdM0aNfg1xtprqmB6QI4K+DTWu7nRkxn4XQSAHrqRXOaRH5RSqFxrhqm5OpKScBZs9mwvr+j6RZyXTiJkirzJD+zutWVsWjfUpQlDT1lOoqm0wgLiK6GFSVgScxNyKrWOUy3EoB7ds3X711q2ULJHzW0lMKw3zEf9mgQJtjay7o4z0H8TEWc2na5wq83xBAkMirN4urO4WN7mNKUIFpJpQrFGHGpL5dYgzxfkDD4eDb6aQHytfRBa800jqRxRCWqTKAS07XaVUAdUnqQCiFn/NWGxc2VVF7GQE6xVqjKc9JGWrbQHtstCacj/ft3pGGqIFOuv/M6npLIIV6KE7TVzFMizIFmsfhYi4r6kXpZIwazmlaQ0seWLn1uiTKqJhQgwfXWEce5fg0o63DLDaZphHmPcw3yr6ap89+vqQU5Z0zjaa5upX40VimCqlFeOVNIYF0FzoU0nJh3P9uMmTaKP/efXf7Ynz18FXh++A+xpAV+7zenP8ZH9s3Pf+0/94v85b//Of3PqCHtZV7m52G+PhDNiUVrRYMY8iWNxyhZ/c1TFHc8gFEXA4EzmqLURSuaz21AyPo6p1I1gtLFHZOYnJQ2zHMk58T1tiFnxbGfab2maxtygeMpEeZI6xVX1x1d59BakWIhRmGtjAbvtZimioTyH557TsOMtYa7+zWusez3IzFElktHyordfsR7zWrd8f6hR1F482bLPIt+Tao2M8ZWM5ZsVAkh03SeEDPH44Sm0DSWpnXEJPrLpjYZhZDwzlVWOJ1z0SsgSgxjwLdr7t5+wtXNDc45VC4UXSpYTYR+FE1ermtIbQgpoqIEmueqKzzr3DIZY+SmrkoWTWLKssYtRaola5C4tgJ03XrN6s1b2vVGmKcUJC+ziNtZVaZO1frOkjPD8xPT4wNxHClJooRiEDaUM/tVap+9klrL1e0Ni+srjBMgoKwTXeMUaj0o4vy2DtV0pFhI/U5W8Qg4Rdeg9gIQavROqQDZgGsq21cd9CWRa55nUZzfAM5ag5xm5sOe+dhfDkglZWlDykkA5hwlTkkXjPeodsU8TpSpR+VILgJYxb+lRSKRMrpKEDJQGk+z3mJyIs+jtBsZ87HIQemPDVlZ2re0N8ST5JN6KzWeqh5AJOvVctYF55gIMeG2G7pld2ncErpVEipUpUQVWfrVVWYcHxgfH0jDiFJGanYru6rr6rokQ0FMZ0qryvb39f2F3DY0XrJYz9dKiUleZ2MoqlTZQWU8a2XtWRsuf1HYY6rkB2Nx3QrbtlLqUE1nOcsht5RCibLOV0U+rJT1+Jt7bNtJ0kI1UildO+6j1IfKZ1uhhInp8ZEwDj/p5+qf+Ll97bh97X7sz0optIsfN2Y9vovfeNXnq88c66s/Op3uf+O/+Mv8S3/xH8p272Ve5mX+2OdrA1HnjBhuRMV2AaApSkaos1YAVcrEJDekxlm5QZCq7ky+zxwEZGmjsFZyQ4uCMSRZw2vNOMx0jaZbdMwR5lFY0dWqYRgzu8MklZmNYbNt6DqxVaYMqch/ay01otYaQio8P088PZ6YxsBi2fDm7YZxSnx4f8IY2FSz0O4w0LaWxlu++HJP0zpevb5mOk0YW7CtZxoDzjlyzrVgqBATtMuW/jRJkL8SvapvxdyUc6ZtnTCk1mKt5IuWnDHOYJ2wvPOpZxoi25t7bt++YXm1RZfzTVyiZVJIzKcjpNqpXZ29MQQxwChZ50LVBmpNIomzGUUOYubQxkqDVe3hVrqy0kpTlGbx6pbu5laioVKUPHrEUFRQVVeoL/FGoT/SPz8RDgdIgTRLgHmsfem55Gq2EYCRU8YvG65ev6bdXqO1ETaqMsQlCtOmcgTna6vPghQz8fggRh6tZOVLZdGUljaupCrLDBmF8Z0YuqrkgJQo8yCVoBdXfa3uRJHmmXDcEYdB1stGAJS8vgatCokzaLcoZ1HLDad377C6yMHiYsCqWwIlj0kDeuGJ/SxyBOUpp73IVJyXCk0joD6XWgFaXfmogm1b3GqNbjr2X31FmGa8tlwEoQgzr50lx0guBb9d06xXqCL6z6INxIq8KkAutaVI12tz+OoLUVxoU7ccYFovsUsp1TrVXBnnIgeOOYjT3Tu0KkzDSFGapmvRzlHCLHmmRYL+Sw5VZgJx6AGFcZIXmotIeBQVxHtJ5NCNx7atPL8gkVop1lxWhbQvWVe/ryJMM1lbHDWk/iyiNLIFIE6isz4XPJTM+PRInKYauP/zP0opPv3F5sf+7OaV5ZPv+H/ia//uf3D643pYbG8s3fKPDoj+F/6pN/zL//ZvvADRl3mZb2i+fqB9SLReequ1ghSFzbJOQMg8J2LIaF1oGofWhjhNopsrQMx0C0eMmRAy3hq5qWlFiJlhSKKX1Jp5nFl0RkxIp0iaI9fXLW1n6fvM4SiGg66zXF21+MbWe6mA3BQS2hS8M1hjGKfMw+PAftdz6meuti1v324ZQ+bduz2LxrLdLhmnzP4wsVo4KPDweOJq07G5WnI8DDROgq7DHGlbR0pZmNEg60DXOR4eTjit0UbRthbXePb7Aauk8z5MYnQqRdb6rnGoLIaLmGHY9Rjj+OSXvsPm6gq/WFE9GICiGEs4DbImzRnbeJSzEDMpJ1BFAEsW80yKUUCGUzjtySERYsR1Hs4ZiylLQH2m3qClo3zx6g2r+1coCmUaBKRVhhGg7nzPOgz63Qf6h/eUGEjjRCkwTYEwh4tcQaMkeikncoHV9RXbt29puk5yG6vGUao268/IMzQLTLdE+Y40DsT9BzRFAu1VQU4etrY/AbEGz2ep6zTdApXlceBaCS6PspIuJVezir6s59PYMx/25BDRjURCpTCj20aebqqGnCJ6TNO14FuGd+9gHlFtI6lVVTOsK8OcUkK2v5ap7yFD0zboFNFdC0iOq7ZGWLkKZEuqmmujce0Ct1qjlKY1FvPZZzx+8QXjcaBrz/rYDA5SSsSc8ZstfrVAUTWcaFCOrCvbVT76s3IMzLEwPj1jK1udq3TCdI1EMKWEKqI/TmFGKxiPI/M4Y4zGNhZt9IUpjpNUaLa2VLAHeRC5RclSjDAPAzkErGtQSuKYjNPkFNHKgjUV9INbLEQvO/SUIK58VZnvMkcu6DXLtiEMI0ppxi9/CG8+wS1WFWCrmqJQZR85gnGEw5Hj845SNO2i/YN/wv6MT7c0/wQILKXw5//59UdNMfDhi8Dv/sOfvpb2zbcdb77l/v9/4cu8zMv8zM7XBqKtq1+asziqVcG1lmnKhBCwZJatw3aecYjEecJ4wzhnjCpYZ+iHiDPQeEuYI1fXDY/PMykmrq5apilJcPvKk9E8Po00XnF93+Fbz+5p4niUWJWutWyvOprOVTc0TENkmoLoQZ3GGsOcNA+PJ/a7E/Ocub9b8ur1hv0h8e6rJ5ZLx/3rNftj4vl54ObKkzLsnkdevV5jjebwdODqdsE4ZKZxZrFqmEPEN44wS7e2aTQP7w5Y57C64DuHa1ue3j/jG4d1nnGY6DrPPCV8o6VLPCdM13HcD0z9yPXtHa8/+YRutZTA8yLav1ISMQXm3VFCv7VFa10zEmdhpKw4tSXAvAbFU/CtxXlPGoM0/riqR42FOI+omESvWYQJ8ps16zef4NZbAXRR3Nrl3JCE+qjtrazl8f3njLsdlMzcn8gxE1MmVa2rZJnWzEclFpKrN2+5/uxbwmgm6XBX1ezGOdNRF8kHXa5Rbsn0/AD9MwpVWTqRMWDqSj6lj6BCSbOS7hZoqpu7aaVT/ryDVQblapFCNbXE/sh8OJBTlPB1JNdVW4sKQcxZyHNBa2y3oFjP/PREiZMAzhjEQJUkaglryVEOCVjN8XhCO0VrHXEKtNst2rr6c0ytSM2yrj4bt1PBWoNbb2TtXmUX1jhu37zh3Q+/YLfbsd2uwTl5D3LCr9e4toUwixSivpdlHuT1sWLQUtYS+57Un+ingPe+rrEjKgWMb9FKk8cZVCFHyQvFaE67PeNpFO1uazFa6jWLMljvyTEyPnwgdi3tcomqEoQUA0pbUoykKMH7ZxmJ1hqibFPK2XhkDe31jaQNzJMceEKoBQ5VlmAlySBNcr3Po0g3tNHkeaT//u/SvPqM7v4NSmVhxesBCBRh98R82NF2rcRu/Ryu5v8wo5Ritf1xcLpYaT75hR9nTv/GX/7D55j6RuObP9oc13/xX/tbHMdvVn7wMi/zp3l+Ate8wjnRoOnamnM4ihFn0RoWy4aYFafDKAwImjQXWq8IUTGMkdXSS7tQyXQrz+dfnWisZrttORxmjMpcXbX0Q+Kw71mvLLevxFTy/t2R3W6mcRrvBYS2nZyUU4Z5CMRUaBqNtQpjDGNQvPtqR3/oKUXx5s2a6+slu/3M+3d7Fp3nzas1/ZjZ709cbRqM0RwPA69erTDWcdqf2N6u2B1mSopsr4UdbRtHHCPGKOZUOBxGFl1LShOL1YqsLO+/fGa9ElPOPM90qyVpDhjnarYoKGs5HSfGfc+bz77N/SdvcY2XzMUaPaR9w3TqGR8PGGvxnbBBJaXqIpf1Y0nCCrlFQ06ZeYr41QLnHeE0yo3eWdIUwEnweEwR7xxFFTLgN1es37yVLMppEBBibQV+wn6LiSZJj3tKnB4+MO6eyHM1vWQqCwiYQkqFVF3VKhfsomH7+g1Xn36nroklNkc0kLOAUBF9opoGs9yCXTE/fAWnB7Tz1YyUJXZIa/mzglSLWiegKgZsu4V5kJaudnGJbxJmX11ApRhaIuG0J/Q9JRXcYilb23HEOC9a3CIxUjkJs2hXG1JRzI9PmLqmv7j0c5Ggfq0pOaK0p8TINE6oxtFZJyvztVzjeZ6lxQppIdJVKysxVGCtwrWNmJIq2C5Up7h2vPnlX+Xz3/odDqc926stcZ5xmw3NYilGnij6ZlX74JUFZSS1oWjRXSpraa9vaK3jsNszjycMSZhmlKzdq3kqBXGg98cT42nEeoerbv0QIs55rHWkEAnjiDGa0PfEkFg0AmSMbdBGEfpe6nutMK5KV52m0ljnLsH03dU1xjnS6fgxjqvW057d/DlkSkgopRmGkTzOdOulvC8xk1Lg+PvfJRyPLD/9FGs9Z8lR7I+MTx8koL+aylT66eZX/jyOMWJY/dH5z/9XNv/E1z18Gfj7f+PrGYNefeL45T/302ejz/nW/4u/+A/5a7/xJfNLjujLvMw3Ol/7E3a5tJU1g6FP9P2EVoXrK48xln6IaF3wjebYJ4zOLBeOfoiklFmvGkCxaiEkxbt3R67Wlm7R8vBwYtkZ1psFu8PM6TRzfd1wc7MkpsKHd0d2+4nWa6zTbNaerq2d6bkQJjE+NI2AZW0tU9C8//KZ/fORrASEbq+WPD6OPDwc6DrL27cb9oeZ3X7g5qpjjpnHp4FXrzfEBNM4stx2PD6euL5Z49uGw+MzbeMYxoC1imHK5KzlBlwCd6+2HI+B54cP3N5vCDEzz5FmKc9FwrkV2kh26nAaiUPgW7/8K1zf3uK6DuNcXRFaTNMy7vdMT88434kbuEYM5ZxFhmDFQZxCxC86cimEnPCNxRhL6CdSzX3MOWK8hVpHqakspzYsb65Z3r/CaC0/HwHKgOgJlTx+VUBZTZgmTg/vmA97whQuZrWQS61YLISQajyXaABt23L72bdYvXojVZJagfWUHMnzWNes0rmuuyVmsaEYz/TFb6OCuPcvelClwFq0b8TcPo/oRlisTMau1pSjVBuqxUqMLzHK2ruI2ai2sFNyYj7tCKeTRDN1soKPo6wbS5D4pFJD2wugFx1hnsljL3rRJNehUnLIsG1zkSEoZUnTxDzNdG/f4CnMhyOL+zuJOzudqoEsXcxAJcohoBRwzuOW4nwuMXHuj6fIe4KxkCJvf+nbfPX9HzBMI+16RbNakueZOE31UKFROWMXrYQLtA1lmtGmRWuLWa4x1eS03sLjaUBbi9Y1cilmuaammZwLwzAQU8KvFpAKKWWpL7UO60U2EedZDEZKSyRUnNCLFbZriUMgVsbR+gbTNBI5Nk+SPLFoyWQKsHz7iVQEzzNKO9I4AloY6Hm+aKhzkXa2lIEQ6RatKDxylHB9wHrP8PkPifPI9hd/BWsNOUxMuyepIz4XN4yzFA68zE88/2FgCnD/ieO//F/d/tif/c1/90B//HEwuL2x/LN/fiG/4z+lyaUwx8z/8+/9kP/tX/7Nn9r3fZmXeZk/3HztT1hds0D3h1nct16JHq0ohj5gnQDMOBeWC43Slv0p0FhYLFpikhX9/hiZx8Dru5YpwFfvjlxtHZvtgqfniTkkbm471kvPOCUeHgaOp5nWi7Ts9ral65y4cZPoTaFgncJ5cYPvdhOPH06cjgPGO968XrNedxx2I8f9ifXKcXO3YXeY2e96tpuGmArTGLh/tZYqy5Sx3rN77tlsFqAU++cD1jrGKdI0jmlOoCzWJDSZ7c2Ww2FiHkdu32xJtU677Vrmcf6oqUQc1Mf9iPMLfvWf+7Mslxu0scIiliRmoWKYHp5J04ixAmourvrqoDZOmoxKSvi2IcZITuGixYzjJOxk7RCn1kgqJXpDikI1Le1mw+r2VmQAqcjP0kY6wQX1ia4wJ0ouzPPE6f1XhMNRqhlTYZpmcpQsUGU1OeZa6yqgu1mvuf/Wt+mutuQ4ojACUFKsq3iNdg1FKcxigV5eidnpy99GkUQP6hqphTy3/yhdG6Ei+ApiSsY2S0q/F11qtxSPfJgF+IK8DlkY51Iyoe8Jh1OtqnSykh16cdiXmlmpJYVAW4ftOuY5kIaTGPfyWWSpqjRAkgqUon6vkWmcWX/r2ywWDWH3xPL+TmLQTr0AVgqqxg0pkDW+Atc2aNdKpFQ9oKgzOKrgi7Ob3jlef/YJp8cP2KYljZOYlUIQgKg1yjjJ4tQKpqn+ORWkC8tdSsL7lvvPPmX34T0xBNQUMFqaknJJhBzJJWKtlngkagJC12C1qYfEiTgnrHPS7pWTyB205IHmeZTs05pmgC6icS2iPc4hoBcti/s35BhFuqB1NREJm55rpadxFkHXYoTKIeC7BijEaRbtb5b8WlJEG0Xe7zj+7m/Q3L/BZKkY1d5RciaFWQxj6Q+3Xn6Zj/MfBSz//D//TzKnP80ppfB4nPje+yP/g3/j1/5If9bLvMzL/OTztYGorOEzzii6lazzwpyhRKzXjFOuFZ+Wcc7M00TbGqy1xJDQVnE4zZAL223L/ihr3Pvblqb1PD1NxJC42niWq5ZpEnZyHGZaB9ZqXr9a0nS+Bu9kiSySyEhs48hF8fihZ/d45DTMuKbh7esVXec5HGZ2u57F0rNYtbx/6JmHqeaCSuPQ3f2aMCdi1eZN/czmai2GlxBonGEYZrw3TFMi54x3Gq0Vvu14etijFGyvV/R9wFmDbTvmcRLtm9aoksixMM6Fu8++w92rV7TrFbrUEpdSyCimcaKMe7S10lleagSRqvrEGC/h5XGOmMYTS6aUWjBgRKcoFZKmutsVcZrEae+MNNIsFizvX+GaugIr5Uf+u4AylYEVwJ8LjMcjw4f3pGmUtess0T3VtYTWYspR5xQkY1jdbLj55FPa1VoYQiO1liWL/hBj0W0rZhQnIfXxeCAdngRUGy/h/SVXxtRLPmicJc/UGHKcULbBWEvpn+V7+raCzigr7TOmKFLZWcJEOJ2Ipx5jXa2AzORwBvA1KL0Io2LbBqwjhgBhqoH8CuM0KSoomaIVyljRXypNHAdSKWy+/S26Rcv04YPEZWlNPJ3QleVO53V74RItpU2DbRaXxjHQlyajS7LAOHI2nsWxJ6UoQffTVA1oRQ4RRlczV6aEiN9uyNMoxjEbMa6t70mS2Kwihrft3R27h/eMp4xTVcKQwsec01oeQAHbeFzbkudISlGiwazEO0GmWS6EcU2IvrSAavylHlShREZRdcy6cTTXN7JWz5FCJo7S/26Mu8hTtHHkWcx6qWimfqBdSNJDHASElpwx2lyKHmzXklNiOhzJ5XPa1QLtm48NTKVgjSaFF43oz+r87lcHppj4F/+1v/VNP5SXeZmX+Y+Zr981HxOtN7IGyxBCEHyiFClkGit6td1uwnvNZt0QYiHUFpSxzyw7SymK5/2Ec4q7+wU5w+PTBGSurhq6hWcYC7vdSI4Rbz5WdjatgM0UEzFlNBJUr40iRvjw4cTu6QBAt2i5v13gnOb9hxP9aWK58HSLhv1uJIfIm9cb+iGiVGK5amoSgKwXyYX1piPMEeekPUdqNxXjFHFWo4rGeQFq+91I6zWubZjGGeulfjOGUMOya7RSjDi/4Ft/5hdZ31xjrBhlVDVc5RiYp0myKasmU3sna9FcKCFegr/RMJ0GYe10QREhSQxTyYmaHyT/aLmxm/pcdNPQLNd011eSP3pm8woCdmtzjjCVNfszRPrdnuHhQXI3U5GK1tpmk1Im5YhXNRA8F3zTsKxVnbbpUEr0u5LTKHmkWCOZodajKvOb+qOA0HM0lKq5k0qhVO00DxPnzNlcMrpZSmvU2FOahbCGOVYgVs1JF3u4oswzw/5Z2EJ9ZpkDteRTwFhMEodUQPmWYh3zOJLHCaMlm5aSJYqssaRxlve7ep/G44msFatPP6NpGqbnJ5EIKM10OGCclwOKqq/y+T9UwTQNtu3kfTxLFlwrjPnZ0HU2WaHIcSLGUDWqqYbHn5uTJPO1FJEbuMZLu5NWKCzWd0C5VMVSiyqUVihlufrkU3a24fjuPQwTKUsE2UfrtMI1HucdsR9JNf9UWSPB+SnQLjuaVjJMYxQW+6w/LpeDi+j3igLtBYSqKiMhK8kfzYBTaG3qa0ltW1Jkawj9iHNW1vAxQZJ6W2XN5UWW5wUFjV20NOu15I+mREZ+B5RCdMFnHfHL/MzMr3//iX6K/I//r3+PmF8Y7Zd5mT/J8/Vd861EGqWQZWuraz+8EjfqHCIxZZrW0ngnuZEUCa3PNbopwdDPrJaW9bplDuXSPX911WG95XiMAhRjpG00bdew2Xa4xpFzIc6BmKXRyVY2cpoKDw8Hds89pRS6ZcvNdYd1hqfHgWEKLJce5yyn00jbWlbrBeMU8Lbg24ZpljWyNhpTSu3rjhgtTMo8B0IQA07TiDNeacmdnOeA99LOEqNUaM5TEAOIlradMElQ/M3rN9y9fUuzXGK9F3YrJXIqxGkk9CLk1zVDUtWaRkD6xadZwGtdjyfAWY0uGVUgxDPwquRpEc1iyZJ/aZ3HdC3ddku7XFemKddInXpzrm7yi2kIxTxGxof3TLtnYZSyANOSszzWAjEFySPVRowrq45uu2VxdV3XpqWCYwR8gLTY1NdB+uI1qT9Q5kHc7GcQkKltUepj5NJZqmAsplkImE0Rmk6AfQzSWlTjpS5Ap+ZVzvtjNQXVGs0apI7SKKOqdNZStFReFudJ8wRhxjojYfYxicu9XjvJ6FpRXxgPR0LObD77jG61JBwOkmjgHXGeMdZKaHvONX4ISpIDiGtajGs4FwSUMKO8F8b73ISkdGWrEznOxCjNTWRhwpXWFyZQqR8BU+fw92lCG4dpm48ouOQqK9A1FUHapZRxXL39hPFw4Pj8SOu9SBYqqEPpSw88c67vk1yEuWRs2+Ca2twVpRDDtJ0E4I+TMOGNqzWxGu0sfrMG5L0pIZDHUR6bFYZfKkLl0Ki9IWaY9js01QGf5JrPtWVKlQIGMTahyDnjlkvcaoGFj+BdoghgHFHOyu/by/zMzN/67ff8r/7tf8TD8U9XS9TLvMzP6vwEzUqgSsYY6YcXTKGYQyHGSOsN1tmqbRMAOs0JaxVt4xhH6YzebjzeW/ohEeZE22jWa4/Sht0ucDpO5BRpWgmqXyzFyV5yIc7yPZzVGCNApu8Tz8+j/L1cWK4b7m4XWOd4fOyJIbJetZQCYz+xWHq0bzgdRrrW0DQNp5M0qlBjbbQ1dY0rBpScInM1abQWlC4Ya5mjhLNLvFLtUFegwoxxDuMbpmFiHibatuP+O5+wff1GnNS1/adUPVycRtI81XrDUrWIVuJy5llAaMwY79HWEsaRRMa1vhYNQKqtVOYcf4OiaCU1lEmyQf16Tbu9wjUNGNFCYgUYntfegLTMaLlhj4cD0/Mj4Xi4BNiX2nRUigDeUqT33OSMazzdds3i+hrXdrJSr6CpwHmDLwHwurKhxpNCJIcBpeQ9OH+hsLsVdJ474C/5pQrddBdneslZgFplcaXJSXHuOs8pkaaR+bAnTmf2U4Eu1YFvJc5IiQkGrXDdkkghHHtUGC+vb6mvtdKin9aqoJToF9M8U5xlsehoG0eZZ3KI2LatBwxdGXDJy9QGYUGtxB1JMoAkG0jXuTT9qBrArqyTmMycSPMoLLlSwugaI/rflGrhglTrKq2lvtPKIct3S4xfiJygMt+XliE+vr5YC8Zw+vCBsN/hK4ubo/TCa2NEslBkm6CtI06jHGaUwnUtvm0oIRBnkTz4lbjYSak2YVUgTkE5h19tMG0nz2EKokMu8viMc5QYSZUl1t4zh8C422OloL5GX6n6nCsDP0twfooJpQx2vcQtV+iSBNAC+bx5iGJq0s6Rzxfsy/yJnr/3vUf+7u898Nf+0VcvIPRlXuZnaL42EDWmMFfzjXVSxdmfZD2/XHrJiywFbRSHXgDBorOkDMdTwOoirKe1nE6BaUqsV5bF0hFT4fg8MU4RhbQlba9aAY1aGpnCnOpqWWNq3eGxjzw+Dgz9DAWurhbc3C+JSfHVuwMlJ1brjjlk5imw6BwZzXgYaBsjrvVBmntsdYcrlOj6omgiwxzRRhqdxuOIbizae6ZBNGTnJp5SwGj5+qZtMU3LNA6kELm+vePm9SuW19eYphUkHxOJJGBklMzJczd4DvNlnZznWdaSBWGcrCWlSDEaq13tqi8kXYGbNtL37RxFW8ntRALAu6tr2quraoKpa/jabX92YHNmEpE60ul0II49eZYP9gKoUkg5EXMilyzeq8qoNYuWzat72vUa62XNroyr7N2POL2VAXMGoQ1x7CHOl0NAqYwWyggoy6XWlRagRkHV/nFiIBNqDmmhIB3uZ72rPDRhDafTUQw8tR++VLr5nEt6lsgK8+bQq5VIQYYTKszCAibph1coaXJCjHMxRuZR8mCX97d0t7cwjWJ8qa5updXFYJaisHnK24uPzfhWNJTa1mthoKS5AtP6eik5CJScifNISlEY5tqkpZS+yGZySugz+7foBIiWjPEdxkuLTknnCC3pmlfnBidTGVetGXc7Dj/8HgTRXqcohQTWig5cIZm2KYRa4yuMpV+0NIsWcibMs+g5XVNrPkW3q2yth9UCfm0jvz/UqC1hPTPaWbRzgCbnIIdAJ3W6/cMzVmnRkM4zRmuU9XKNGCMd9E4KOcoYUY2mWa9RKcu1cJYhaFV1pxntPTll8jnT9mX+RM733h/5N/76d/ne+yO/9/74TT+cl3mZl/kJ52sD0X4UxqfxhilkpjHSdQZT19BOOig5Hmec06yWjmEuzFNiubAsl44Q4fl5JpfEcmVZrDzjkDgcZ2FPtWQlSmWngJdUmdBSCtZbFIVUCsOQ2T2N9KeZAtzfrdhuW+a58MMv93QOrq9XTHMhTCOLpaw5U0osl545pAsrpbWRCshSsEaRciZlqStcLJ04cKeRxdKDsYz9JHFN+UdRi7Cb3cKTUmb/4RFjPa8+/RbX97f4xUKYHCkel5tru2R8eEDNM9paUqyh64A21bkbI9pbYdKUEROQxCYKe5Oy6D9zkUxOpcXEYgR8ADTrNYubO8nFrOvXUgwqh6odpbrhU13FasbjgdP7B7TXGKPJRXNuXArjJHmSFYCLBrGw2KzYvnlDs1hVgOFF36qE0ebMLeXq3HctRVnicEQlqZVU2oiuM5eqiWyqu3vkrFKIKaF9i1aFMk+io20WIinICTi7/YtoO8mkGJj7kwClIGxXUQrjbV0hK2xdFZ+hqVltmOaxOssTWEUJhZKC6Gql5BwQLXAYemKYae9esX77FuJMpB4oYqpGMg3KopUia42xWkL7ta5stxh30FauBWMASQsQp3wR+UEpxDCKPvWcIXtm00PE1DW4MgbTNKh5rkH+FrfYiDM8ZWH+SgZjhak1wn6KLkGDKvTPO46ff588jFgjcVKpgDIG2zQC9Gpyg+SUGmKc8V2L8420eQ09lIzrhCHPMWCMlesWkQKUUjC+wXYdUolUKPP8UdepVGV5IzkG0QNrxfj0jMkFrQshzsIIWzElSWaq5Ncqa4iDyAAWdzcYBenM/JcCWYkGPWV5z4ocuvL8AkT/JM5xDPyP/i9/j+MYXgDoy7zMz/B8bSDqjQRHH06i6dysHCFr+n6ic4qYCqfTyGbjWCw7Dn0ipcR2bek6xxwk+innxNXWs1h4jofA4TCTClgNxuhqWHKVnSrEKQqj5w2QKQVOp8SHDyeGYcJay/3dgtW64XQKPDz2WF24vZMe+bEf6DpPzgqjC10rINQ5xzBHvDekIOHkIWdy0RVcRVbrhqmfoSSu77YMo1QF+kYCsI015KIu5qF2uWAYJx6/+MDt6094/QvfZnV9hfNN1ScqSgy19/uK7voO0y55+p3fpMmga0C30gIKUq1VtIsFxVpCPwrrrKo2T9Xu9hAFNBjpic8pkqYZZS3d9prV3b0A2fNam4roaotNiR8NPblo+qdH5tNRdJJaXYCaro8h1xxLkuhSjXV0Nxuu3r7BNZ2AY9/WthuEYdUA1RFuxc0eM6Rh9yNd5uWyelfV3SzRRDMlSZh8Cgm9XGO1psSAbpdgHeRUN8laQKiuzS8li/b2dKzd6AnbtpCjrJYLH7WWCFjWWqO6JWEeUCGgcrroB5WRDNPzylsZQ5xmwjCQUmL16pbl3S3kRJomiZwqyDVitDDaUWQWKE3KEWs0tmlQtjbTWCuPSSF/VpuPzoaekiNhGslFAKz0vOuPEoyqb83zjFss0G2DaTx5HNG2kWzYUlBFjGIgeld01cZqoIgcYnh65un3fg/Ofe65oElYZ9DqIxucchZXurWEMGOcEflHyaRhRKWEWy2xXUeeZ0CkFilIoxIq49cL3HZLqSD83Bx1HjEkSWyZMrJtGXc7VJKihpIzumk51/2q2ham6rUR+pGUEov7G0lWGKdqApQD1tlgl4M0jan6vNxq+ZN/sr7MH9mUUvgX/vf/b2LKfPn8kmjwMi/zsz5f3zWPYexnlp3COc/hFFEqsuwswyAxLa/uhfV7PiVyCCxbRbfwTDMcjgFnCtvrBuMcfZ/Z7YN80GvR2p0zQlHCSko8FLSdJYUEWnE8Rt6/75nnQNc4rq9a1tuOKWjevXvGGHj95orjaWYcRtablhhyzRi1zNOMNYrTaWK16dAUitGM4wxI771VmeWy4bQfULpwdX/D6TBiTZGWoxClWSYXFAlrLdZ7nh93xCnxy3/uP8H1q1e4RSuMloJSJIMSY1nc3OGXa5S2rO5fM5+O9F/8gMb52pQkJhhlFM1qRUqZMOxwxjHPiRBmfCPrXaAGmiu0F6d7DhFjPIvb1yxfv6kVmnUVXaphyDlQ5qK/VNqRY6R/+sB02IkW1GoJvjeaohTD7oCuK9SSJRbKLz2L62uWb96iraXME8o1qFq5WOJc9YdUfalB+5Z5nihhvsTpKFUNJqX8OLCMgRIncgykonBX92jEMa6arrKS0i0ugDpVEKspIZCmkdAfyFmkI8ZalHOEw1A73TO2bVFWdL7aNOBbpqGv0WAaZRVxjCgnMoOYRgHNShPHiXno0day+uQ1TslBIc+THBZQFFWwrRfNZcqSFoC0J7nW4roFWntKUbVAoAKxCl7JkIM0RlEUYRikqtNo4jBWg36VIYQJv72tq3sJ7FdZWG63EPNPKVX2YK1ksc6VRXSu6jWlNat/euDpe78PORFLkR76AioJNraNBTTzFMgpS8vYPOG8w7cN1orBUBuD6hp015KyHK5U1UYrrYgx4FpHs71BaUepDKXSGmOsyEJqRmg49QKWrWV6fIZplutUIc+nbhCknUk0s7J6l5IDf7WkWbTkOJNjQEqjxPxEzdoVD6KYxKx39IfDH/Zz9mV+SvPf+Qt/nQ/7kcNLJefLvMzPzXz9ypAcubtumCI8PE80rtA1lsNhxlrFq1dLhrHw/qsT1hRurhoWq4ZhKPT9jDOFzabFOUt/ihyOkZgSrVMYq7m+keimUp35UuOtJCy7yM1smgtfvjsxTYHGW7brhuW6ZQ6Kz3/4hNHwybeueX4cCPPMetMyjYmmdRhrJEpJwTDOtK0jTDNd6zj2E8YYpinSNJq269g9Hugah2kcjx92XF+tCFVPpq24442qQfEovvzu77PaXPNn/1P/HIurrdwIU66r27qNXixZ3twLozmcyCVhuhXbTz4lHA/E4xGrNCkFjLfYRSvNNf2AtoaYR2FqtGIax2oYMxjvUQbJCFURv92yun1Fs7kS8Fm1g5QagVRjmUoR9zJaE+dZAupPBwGuRl9cSGmcGXpxLMeUKEneF9M4FldXrO5fiyZ1GsVE45yA7xQBzVlEqowDYzm9/4Jp/4Fue4ddX190iFTnP0pJUP08QF1rZ2Vpbt6IJrMG2JcUqwmqxjTp6rCuK/PYH5mPBwFedZWsnSPFJMQrRqQPKWKsxvgG1S2ZjyeYpQZVWU2aREOolalMqHTBpxiY+oFiLFe/8IvoGFDIa5znCZTUdprGi5EoRAmeR5PDjPMGv1qijKUodWFPz674iwYjjmCdJBMMB2HKrb0Y3ZRGmMjTiebqSjbZIVFCZHp6xnQtzfZatJk5k6dJ1u8lUyYxaOFqvqYSkHd6eM/+B9/HW0UxvkoLCkapGq0k2l0JpZ9FR3ocsK2nWXRYL8kOWiuyb9BOfh8umaNK3teYIrb1LF6/+cgIIzmxlKm+DmIpSyFVsKwZDgfiPOEXZx2nQeWI1gqjpVYXBTiPUsKMtr6jWa8rux0pIVcWuLLhKVLCLEkJBUqIHI4njh92f6gP2Zf5w02um6L//v/xb/Pddy+Hgpd5mZ+3+dpAdL1t2e0jQz9xtRIN1v4YWCwd67Xn8WnisJ9ZLRzbjadbNxyPmaGf8a6wWrcYZ+mPgeOQJG/SKXIp3F15FgupAA0hEkLGOY016hLEPk6F9x+O6JKkn37tWV8vOQ2Jr774wGLhuL+/ZvfYoyksNwtOp5lF50nFyE2syBqx9WLKsN7ytB/xRjOPga5zNG3L4fnIYuFQ1jOeBpz3TCFircG5hlQUxsj3C1Pg9PTE3f1bvvWrv0q7ucL4pppqCiXMFKXx22va7bWsPbMEb1Pjj4y2bF6/4WH/m5CjmJJ8w3A8SbC6quCxyGo7jbOsyp3FeIdSMA8zpSQWt7dsP/sOzruq/5MVfqlaRqlZLJQcAEXRnjRMPP/ge5Q8S8yS0pSiajyRMHO6pOooFpe0do5mvWV5dy/r4TCjmlbAFAVS1fblahyyjkxheP9D5v0zpuk4vvucTbvAdSsknwlx8ackILQkYt9Du6a5vpPXs7KeUATAnSOH6jq/hAQlEvoTcTgJ6xtnMa34BqXFYCOr3LpuLzVmy1jCYYeagzCYBVI/AAIIM+VSr6lVAWfp7u/x1zdYBfG0x6xW0v5jPTlFjDOVmau64PpaNQuHW24uYF9VYxdVJgGVvQ6Roj2qBOLYE1O4hL/nJAch7QwlBdyivRhtqDFRpm0xzULC6rNsKtDiIidnic3SRRqNqmGvf3zg4fe+i6WQjKaUhHGaHORxWS9JASll0hwxzjKPI4VC03UYtFw7YUZbJwajGKvkwKBUJk2JFESysXz7BtOIQ76kII53Jy78PE6k+membXFdx3A8Mh9P+KahoDHO1miziPO+6mRnMWuVDCnjlgv8ai0yhizpBtpb0ZJmkdakkOT/TyKfmedA/7Cna7ufwkfty/ykE1NmDIn/w1/9bf7S3/3BN/1wXuZlXuaPaL42EP3y3YAqme3SELOi382s15a2c3z4MDLPiZsrT9dZ2oVnt58Zh0zbwHrlMcbQnyLHU2CaAqpktNW8ebNksWol7mkMxJixTuKZjJUb3ukU+erLPSlIm8tm27C5WnI4Rva7Ezc3Hc5ZHh+OOK9wXcfz04ntWpp60iw/TyIJJQTbWEdKCa0U4xjYXncUDM+PB7pOnqOeZ/xqSZgCVmv6IdM0FlPjXvpDT07w6S/+Crev7vGrJdrVbvYYpTLRt7j1Fr/eSH1iTqLLKwrVSEUlYaRZtKzevGF494EpZMbn9zWjEzFwOMNcsrjgz3mnxog5RIPxhuXdG1avXkvLTKqtNbqaNWrmqexWRdtIDAzPT5w+fKDMk4CzVEgxkM8axpRQJZJixBqD7YTdW93dsbi6QldG8qx/lIrLGoJfs5qUc6SU6d9/TuoPWNeR54hvFowPX6BffSoxQgphpaZBjD4hQrelub6XFX8YK7MqmZjlHDWUkmR95gwlMTw9kuYJYx0lR3HnO0fOCV3EuS92lLoi1opEJuyepeHKiJEnx4D2lhITRRmINaorR4nKajv89gpLYd7v5JrqxxoEz4W1PHeik8Sopq3GtksyGpWKNEqdQegZSFLd4kpDCYSxh1JwXUfJSQ5WMYPRxBoXdtYW55IxxuCaFaZZoJtWTD6x1noCxCxaXVdNV1UiMe527L7/A3QuUsqEvC05isFMI+vykgpT32OUIkWp7lxuVhLyH6XpSztfI5rqtTTXnNmUSCFiO8/6k7cYf2ZcxfimcqbkobLdwFyqk1+Y+3jqabtWWOZcwEhMk9+sxF2vNSkVwnEgx4hbdVjnLpFMl0KDIpWqJcyotqu/G1UiYjTT855u1cm552X+2CamzPv9yN/+3Q/8b/6dl074l3mZn/f5+mYlW1i0jn6IpJRrHqhj9zyTYuZq41gvPRjD49PMFBLLTrPdtig0x0NkfxwJs5gemtby5s0K6yzznJjGKFrOxuCcgKyiNMdD4P27A0N1u95cdyxXLbvdQN/PLBYelKHvZ3xnSRGOu571yjPHIuvnkjBGQtozhpgylMAcEvMUuL5ZME6ZeRzpOkcIoq3L1pHmQNs6xnHGamETpzlyfDriXMNnv/Adrl/d06yWwgbWWJqSM6pd0F7fYLvFR3e6qppInSlGOq+pgeHdzS3D4UD/1XvICde1aGtFJ5eysJUV3GlVg921xq1WLG7vWGxvUEZW4qJh/Ojq5hxobmobTUocPrzn9P4B6x3aOzE4VbXhOWqHulJ23uGWLTjP4vqGbrXmUmdZA92pujpBLjXaylhimBmf3lPmCeM7UAaVhI3DaOb9E+2VaF7LcCKnSE4RvdjiNleUOEGQ9x8l2k+RFIj0oWgtADZF5sOecDpiXEMcJQ7KeldXzgKSSgiUIo5w5RtiSMTDCaO05EbmJEasmqqA1pf81Jyj6DObDr+9xigIhx3izRcWnJjASNd6jvJYS4GSMtZb3GJNUfLeK+85d8WfjTMlznJY0CIFSEEYcNM0UH+K0rnKDALK2KqxRZjyCrS0adGulbatub631WCkfXXnI2xyUYZpv2f3g9+HOOEbkQukKFm6KSSM0eAMMUkDkyoQ5gmloVuvpSKVelDQYLSXw2OtjcrnCK6aVrD85BNMt5C4MnJlc8/QV/4ppWAX8jzCNDLtd1jnhJ2PEslUkErVMgcB286SSiHmhHIWt1zIuahWqFLfC+0duR8vvxu6cfjOU5Tm8OU7yb4HlDN/sE/Xl/mJppTCb/xwx8Nx5H/yb/79b/rhvMzLvMwf03xtIKqU5nk3Yy3cXHcUFLu9hExvN04qMpPi8WEipch25dhsGkKSnvrTUUK+jVVsrjqur1qU1tLYM0ZSAuc13hvRcybYPQ3sHk9Mc0Brzf29ANenp4EYIstlI3E+IdK0jlRbZCS/tGA1kAvGWayzhFiY+pnFwpJjRqvC1c2SaQzM00xbe+wlwkdC2E0FVecu9r6fiP3MdnvNzf0r1tstzWIhkTMZUo4UbXBXVzSrNdZXt/o5tbJkVCrSuiRCWMiSKTnudsReTDK2bXBtK6A1FdH05UyOwnYpBZzX4/evaCowzNWUdNaByv28htVryaecD3uGD18x9weMVrUwIAmMyok5ROZxwtbGJGMMbtXRXm1pVxtctxCgbRtx3mtds+Zr/NM5M7QU5uOBcNpBjdsBYWh1J38XpSDMTE9fSc1kycQwYxdrAZDT6WPeaK3lpGSKWK4F/KaZPE/EU08YRmnCSekCigRLChpMqVzeC5qWlBLj4UDjxaiTz5ma5+ejlJQMII1MCSjO4xZLTCnkaRAmuRQxFWUx2OU5fmQ2tWR3Wm/xq40A8JpTiXOiG825pgYUMXspMc7kKHm1utZ2Ki2PXdbzQcCfs6h8Nq6BQqO0k9e7ZAFnFxCqLjn1JYsLHaWZ9k88//CH5EHqP0up+mctsUbaShB+LokUctVsBkB+N7TR9dBUrz5tJBopZ4o2KMTNT3Wzu8US4yxx7C8Zrqgih4NaGJDCjHYO2zSMQ+T04QHv7cXcVioYLRniKPFUtnEUr0WCYC3d1QbbNFBzenNIl99xqvFOO0cppaYPGIb9gTzFS0RXSvEP8NH6Mj/J/PV//I45Zv5n/9YLAH2Zl/nTNl8biJ6OE5uVAM6YFX0fMVrW7uKMLzw+T+SUuL1qamQTPD9PHA4jikTXWa5vFixXor8LY2QYZSXnvcG3YgIZRmlLen46Qc6s1w3rdUuIhefnAa0Uq1UrzKVROG8unfCudcxTwBjJv0SDNlL/F0Ki8RqFEhYwZY6Hka6zrHxXW5sMYAlFy4pRa7T1xAyHp2dMMbx++xnb22u0tbUL3JCnmaIsernBL1Y47z72sVRmspxvaBdgKOzM1J8Ynh4YHj5QQpQ8SSMrTZXrKjlAQUAoSqGahsXVFd3NvQDDGvotrqgKtFCVRZRHkmJieH5k2j2RppOEsteGnDTPpHOVaQ17xxqsNfjFguX1De12gzENFI1yXjInFUANHq/ubGUMKcxM+x3xdBC9orUUhFk0jbswhsRIzoUyDsShxzYd2nl570pCmbreLQhTeH4NzzrKeSaMPbGatwSgyWuhrJhOVK4Zl+cdq9YUbYhTIA0nyYTVmly1goqza7u+jimRyeQMxWp8u8BoiOPpsumWt1XVOKwkWtVLHKfGOC85paaCZOdRzkgjVyk1/7QIuEeySlOaK0AFaii9wogktkaGqZrRKkR5QVHQppXsUKNq+sA5tl8eI3Cp+VTGMJ2O7L74ATkEbFe1mVlet3OFL7ahoCjTLAfFOZBLxjkrjVIVYFIbruIcqgPdCiOLAicGPGMddtFSUpC4pEteqkZruX7TOIprvvHM88zx3Tt0qbm5eb6YiYqWyCWVarkCAmBzTHTXG9rtGkKQ5IckNb4xBEzTXOpWlXWiTQWm/YnxaVfZcSPfO//Im/wyP9X5a//oSz4cRv71v/Y7TDF/0w/nZV7mZb6B+dpA9O66xXeOcSqEKdA4xWrtsc6y2wf6Xnq9b64c7dIz9JHdPjD2E0YllquGq+sF3UK0mdOYmOcCaJpW4xtpQDkcA88PJ4Z+QivYXncs1x39KdD3E4ul3BBjFENTQXI8G29w3tKfZnLMwm4qI403IQn5WLM/C4pxCKgcaRth9ECMURlZ0+UQcF6anXZPe1LKbDZX3Nzes9ysRZNnHLrWJZamxW9vaK62qBTJwwlsw7kFR1BSBYeVOczA8LSj//CONA21mUrX/zZS7xmjZDdagzZirnDdku76lna7FYdvnOvut65Zc6kGHAGhSknEzvH9O6anx0vNo6ZAKoQk9ZNzqCBUK5xz+K7BL1csbm5pV6uPOlMrz71SgFCBjjLy52EaBVRPfY38yeI2txZTa2DPYfsFWcnlJIHlxjfS+KM1yjgBP6GGrp97wCWHipIlKD1Ok7x/WklfPICROCaVlQDQnIVZNZqiLXPfU+YZUw1xOafajsWlJUpExQLhYpA823a9wjpPDj/CPCsuVZIqZeIcL4cBpTWu6+TAUllNrJj9yhkMgkQWIUxgnmfyPFAUYqaBi+lMXneLLo4yB9I0kULAtKLd1a7Fdj8SzK9V1T2mKpeg5sUW0IaxP7H/4ocSJdU18v+FKLrqKmvQStW0hILrWuZxQilw3mO0QhuLaUQiE0MghVGuVSW/06UI2LRtZZKdR1kpicgpo0quoNheWG9tLbrrCMPI6d0HDEgG6TSjlFy3Ode8WZUx3kLkUuHa3VzRdJ1IWLSScHwK5ayPBtIwAgq7lNd36gf65wMqg/ZSh4ouH8H7y/xU56/8+uf8K3/1t1/qOF/mZf6Uz9fXiLaewzGgSqH1itWmJSvFhw9Drc+0bDYtvrHsdhMPT3KTcRrWm46rmw7vLSFmhlMUdglF12qazqKUrNwfH47MU6DtHNfXCwGC+4mSMtvrJWGWjE3vrYRVa41GmKeYCsMUWa8XFGUIQb5W1w556ySA/rjrWXQat+hIMVJiIiObckLCWYN3lpgiD1890zRL3nz6Ha6ur7DVBWy8rJlTTpjlmu72FdYZmCcBZb4TF3eS9aU6s3o5UNDMw8Tx/TvS0Ms6XQhAFMLgAgIKlUgLSm0aarZXLK9vccuNMH5BWEJ13rdKflGNZhKd7TiMHL/6gvlwwKgz+LHkXEhB1tzzHIkhiBa0bVFGs7y9ZXF9h3ZO2EFtKea8ho8CDs9MnvEo65jHgfH9F5Shl3rWszRAV81fTMQ5oKwVABIDISbcYkm73shzLzWw8gKuRT9Ijpf2oBQC4XQkxiCr6Fq1qmoMFChx6+eM9JdbtG/IuRDHATVPNZBd1aB/BNzWMwMUVBGGL6aA9h6jtRigorzeuiYMABfWmSK5lEUBJeHaFtMtPrrjTa1izVXfmmq9pLFQFDlMhOEkGkxrsdpIIYCxNRZLTDt5HEhhFmNZmDDOYZcrtG9qzuuP/PJqOdyUHOuqXKGtYzjuOXz1Q1IM+EWH0Yp5nJhPUpxA41BGESbRxWrnmfpZ8l9rTakxFte0GOeFJY1R2FGtauC/RCe51QK/Xsn2XX5ZKTWPV45nwgqnalayTUuYIqevPsAcMK0wmGcPXKEytfWJKq0x3jEcjnTXa9r1SuQNQV7fUpnuNNW0iHAuKYBkA1nBuD9ikPfv0iyVEunSoPYyP435O7/7gf/H3/shv/XF7gWEvszLvMzXB6JPuxmnC8ulZbFqmAM8PcsN6+qqYbUS9vDhYeDdhwGtMsvOsV43bK9ajFZMY2SaMilKvuBiKcYkpR2754nnpxMxBNbrhqubJSkWDvsRYzWLZcdpiOScWHQNMUSMVeSsmOeEWTimMbLeLLHWMA4TMUacteScpUGpwHF/ZL1ssM7K/+8dserMlFY4oyVw/3hiOI5c377h7s1rVtfXEr6uFKYVvWiKBXt9Q3d7J00/U08511SWuoo/ayYveaKKYbfj9MUXKFUNMUlYxVxvtGLqENmBtlJrirM0V9dsPv0OpkYklTh9ZAm1lJWrYshhlnUjcHp85vTuS0qQrFSlFbp2tadYhB0eR8iFdtEJaPENq5trVje3slIvpepLTa01PduIqwNfa7Ce8bAjPn0gT1OtnZRAdu2cmLVSIoYoLUNVw5nJtOuNpApc6Mhz73uuAC+jSALuENZrPu4lqNwYwbg1CrJEKVdQ58dVhAnVVg4uMcwXqYCAVBmtFTmdIQ4C5oAYAtY3WGtEj3kGKFVWIQ1XyPcqUIp8T6MLtl1gmkVtTS1VayoRYnmekMpUAZfkTJwG4thLbq6VAHdpf1KXOK08DQLircVe3aKHE2UcsIu1REAphBE39qM6o1Z4KnU+oGiGw479F99HlYJ1Eh0Vw0ycAiVljDNYZ0kxk1LGLxYM+z1pCjStrypaeZ0whhyiNF05ByXXa9dRlJZs0attfb0gTqMcQs4uLkSGUsjC6vqWECOn948QRNupKFLyUFUtSqkKeuV7nN+r9npNu93I75WSA2BRSkoS5llSC5wlhQhtKx+AvmV6fsY6i0ZJ9WkplDlSFMT4Ypv/acwPHk78z//vv85zP/NuN37TD+dlXuZl/oTMT+SaXy4sq03H8RT48DjReM3NdUPbOcKU+PyHez7sJtZLy6JtuNp2LFaOUjLDmJgmWQ0aq2hbTVfX5x/e9+yejlAyV1cLNtuOfkicDgPLTUtMimEMaDLrbcdhNwKFZdtwPM1oo8gx4xpHyTCNE6SIUYppCqy3C1IqnPZHtpuOWCSaxtrzzdphnYS055R4fv9ISopPvvOLXF3d4NsWMmgrjURZKVCW9vUtzWaLaCQLqlsKMDz3d+fa/Z5jZXE0h6++ZNo/gS7kIjmVqmRKKhdWTSmFa/0lScZ2HcvXn+JXG3FOl0KexhpUf2YBufx93a7JOfL8gx/Sv/8KrYrkWRYBPnGKtcFR3PjWW3SW1aX2nu2rO7rtFfoMPI0BI21HpCSZkwDaoSrAGz68I5/25HGoUocKMHTtmj9TdHWlTgkU5+luXuF9J/Cv6jqpTCZKIoOUUhTrUUUA3LR/JteQeXGHWxIQh540Thjn0e05Y1TVOJ9EyjPWObAdaQpiyKFU1qyuYoGiRIMZQqRdryHEGkrPpadelcrcqnImUClROu2N1Vi/wLQLKFK3qXwr79vcS/uUdSjfca7uTNPIfDiAqSv+M/M7SxZnSZk8CjNonJdGpAJKGexqi/EVHCpQylaNbzWhpZqzWkPzh6cnnj7/fVmrO49uPCVnQo1Hc51Ho4ijMNe+awjThCLjO5Gb6Ppenq+hEueL7hKtpMHKClPtV0tZjYcARtj0koQdzkUitUQnqjDWk7L026uS0a2nzDOxn8Cewa+t5xV9VkaIXnWzZnG9JfVHqBptaZEqNYJKmG2RMAiA1s7SP+2FhW29mJlyqZFdUJTIVF7mDz5TSPwL/7v/gJAyT6f5m344L/MyL/MnbL42EN1sGparhlMf+PAwYoyWHvmFY+wjX3555OkY2C4dzmkxJS0dMSTmKTNXj0nXGpwD13hiKnz4cGD3dAKKmJI2HcOY2e8HNpuWYUhoVWi9ZblqOZ4C8xxZbztSBmsF9GRlySHRtp4SIGrFfj+x3CxQKMI4sFwvas+8RmsIRWGQzFLrHfM0sn//xGJ5xetvf4flaoEzUoMoPqBCnibs1TWLuze4phV1ZBY3PLGQx5OwccDFraQgTDOHL79kPu6hZOYpoIvCOTHxYDKlSDj52cWO0pjliu3bb2EXqwrSsqzjEe2nMpUONKI51G1LnCYevvs7zI+PWOfErXyuMMwI0lJaJIOq0LQN4/FE0ZrrV/d06w2qsntaOyrNhqBxPqYAVEf2+PxAHvtaJSnOZBRVviAA7ezqKTlQcsRt1nTX9wJGJrk56a5WdhaJPxJg/ZF1zWPPtHsWllBJzai0YUbCMBKnIA5uL9IGpUB7RwyR2E9VcmDk71OkpSdF0WEaJ6xmCAJaFbTLJWXocUu5hlI16JAL2la2tpw3+eJ61xrcYiWlBjXtQDddNddMEALaelTTVrmBgNfpuBP221pxeSsI/Qltm0vbkW07CZ8HKIkyDFWHaeVQctZY5iwMYEqUUiORSkE1nnHo2b37HKMQs12toQ27PbooTOMx1hLnWaQ1xhLGGWXkuVitSaVUotnUKKUo6+yKCrWR6zGnKCxygTxJLWoJERUTuW4AzhpipRV6saZoS//+A3mS3FrIcp3a6pLXShIQcpEA/pLJORFT4mq7Jhx7bNvUg0xl2M+64lR12lrKIHTTsf/wgdIPuEVX46OQKKggLKi2GvMS3/QTT6na6v/m//KvMsfMML+wyi/zMi/zHz1fG4h2S89+P/H+cUKVwvXWslg4xiHy1fueMcHtWqo0b+8XLDrLNEbmWbSgRmWazuAbi9aKeS589dWBqZ8oKDablvXaE2MmhcTdzYJhEoOEbh3Oa1JRxJBYrltZuQGgyEWhSBgFOcwMp4ljH7i7X2MbzzTOLK/WnPpZGnOAuWicc9gc8V3D6dizf9hz/8l3uHv9CmM9xtWbfHWfx1xw17es3nwqa/raoU6cYZ4F31H1br5FZYnNGQ49j9/9XeLpWLu1xUmNFic7gLYKfQZctQd8cf+G5f2bS6ZqKZkyDZefUcyPaNmURjeO4fmR59/7LnmeaRa1EaZqabMqxGGqXw/KFHLITONEt16xefMGv1wJftYafItoLdNFR6mSrCtRmhgi4biTHvtcKFrLqtmrygSKeUgilhKqFFJOlbl6JY7x4Yi48J2snc2599vIylrVBf44MD59IM+12cga+RoKoe8FuHhxnDNNqG6JdoYwT6SUcG3V7E7CaJrmnKN5riNNME1EpUhK091co1MgF08xTsw6OVW6VFbmxhipH6SuvxX41RVmsaRMo0QVWQG4hJkyndCuEa1njTVKYSIcd+hzBJKRGKM8R5T1sl7WunqfEirJe5OGCa0s2vuqdSySRlCS1IHmLNcl8l4pZ5lOB/Y/+B5GIHNNk4ioYaLMCY0WSUfOWGvRnWXYH1hsN2w++xZPX37J8+dfsHBOQGjT1Cx8g/HVWJYNprGgCmnI2LarRraar5sqS211ZVLThTFW1nF62hGHAV8NV/F0khzPUiBL1JkClJX1ei6JaTixeX0HMWCdQSEmRYjSHFVjuWKKNV5K2sGG457U99gK5HNljsMwkSn1/agSj5f52hNT5r/7r/wNvvfhePb6vczLvMzL/MfO19eIPk48Pg8Yrbi9blgsLEMf+fA4Ms6JzmvaRnNzu8QYxdAHxknYCGOg6Tzey022HxKPH3riPOG842btaRrLOIsT1jcG1xjmUCsMFcSsGI5T1blV4FDy2SguBS4l058ixsDrT7coxHyxWC5JqUguZSkYo/FaY1Qha8Pzhx3zEPjWL/9Zrl/dobVFG/0xYFtpVLtgdXdLu7kW124JQoWFIFrNc2B9kRpMppGcE8fHJ3ZffkkeJzEioTG6oK3E7qSYaoGMl/V9iqi2Y/nqLcvru2pcKpQkYFdV8HVOZkLbSzjP4asvefrub+G0E1e/NaQ5iHMZ5KZ/7hPXYuSIMbG6vWb76hXGdYKkz7mdWhxUpSAreWrvt7HMc2B6fpB80CJrznLWXtr6mEOqrn0uDGZ7c0u3vpJQ+TBL7aZzoverIe6AgExjUKUQ+xPjw3shZJWRla8x5JgJp54co+S4lkwOM3rRobwhhEBOlVnLoost1WQkLGaRMH4KJVYlqtJ0dzdyqElBnNq5urprUPwZpGDEzHKuiHTtCr1YiUFNKXS7rC7wgTIP6KYTEJoiGE0eesbdI265kYOJkhisFMTdTZGMS2UMaTiJ7GC5qMDUSGNS1R4rK8Y4Zaoed676YS0O/TAOnN59gUGYfdO2aGdIo6RMnOtS4zRhvEMbQ+h72vWSzWffQlvP9dtPiDERDwe6tqn6TNE55yK/pxhJsiAGYXAbL9FIc5DVvPpRY1a8MKjaGObjgXg6Yp2h5EQe58psUpuu5BqJkRoHVpiHnm6zwnddzbY1tYxAoXS9rowiTZPIOVqNUjDvDkzDgGsaSpDqU6Xl9yWnhG0cppUK3fyiEf1aM4bEFBL/03/z/8PvvT9+0w/nZV7mZX5G5msD0cenAe80V1vPYukZhsRuN6MKLBtD0xpubqWmsT8lYirSBmTAd001FiWmufDu3YmcCk3TslwYFgvH8Zjox4i1WiKVlEGpyHK9IMTEMEY0YsKQzVwmpcI0RYzRhFlUmOuVp+kc05xJMdEtWlKMcgPNBd80OGspKdDPkWHX0/gFv/RP/1kW6+VHVjKKq9b4Br3cSKf4YlmzQGXNnKdeHNTW1hzPxJkTDdPM7vPP2b/7Svwc2mCMANyzwTpUlk0rLRo55+iurli9+QTXLYCqp5vHyw1Z2orcBQAUIM2Rw5dfMDy8x1nJIDVOajdRkbEfJHrHyc1bGS76v82bezavXsmN/QxcXCMPUKjbS9yUMlqaqYaR6fm9aDrVWQ+aRNOqqFpSyZAsRmpNtbG4xVLkDFnc8qZpwDcfG2/O/2hhgIkz82HPeNxJHFUpmMaAkUKCPEtrkW3butEXt7VuOpKSFaurbFeJQUB/NXrJatdUli6Tc6RozeJ2iwLicEI7y0c7kzD75I/O9zTPgGRtOt/JdTALU6m8E21wSpR5orgGZb2sy1GEw575dMAvN6IX1ZqcAimKPlY5g/aePE3E01SBlLjM3VJajIjnQHo5CJz1uJR64LAOZSxxGjl9eCeGonI2QEngvtYanCaHKJFOiHluHieaZcfmW98RljsldIH7Tz5h//5Lpv0B77y453OBmMhGSdtVkLQA5Rwl5ku4fymlMrtFcl9zQTcW3XbE+jtjm4Y8h8vBrcQiBz+FsNBVxy1RTLC43tBt1uQgEguVZYOSMx/za1MmDZPErGUoGuZJEiLO+lFlLWGQWll9NvUpTRoDaXzRNf7/mnFOvNsP/KVf+wH/t7/z/W/64bzMy7zMz9h8/dV8o1hvJLz+1CeOR2lVck6x2jQsl56cC2OfmGeJpjFO03YWa8QpHGJh6CM5K2LKLA20nYSJpyKRON5pUJahDzVkvEbrYKROUhWpYMyQU8FaYWCsVSyXFuscx8OEM4pu2TEOwqKmLK5lg7jSd08H5tPE3f0nvPn2ZzRtU1kpcV4XoFiHvb1jcXUrPzfUG1KRHnJiECNOll5wZSwlw3zq2X/xQ/qnJ3ROH80niktQegyy7tbGYJ0RZ/HNLatXn+DajpKiGE1CEMe6AijSr65AGVfd4wcOX31BOJ3QxgmOa3StBU2kyupa7+QmXgq5ZJrtlu0nb/HLFSVEUAbt3Y89H6GZK9gxlqwU8+nA/PRBjC/aymNSGq0Vxnth2GapqCxhFvlq0+BXa6zzlDCKyb9dCHg6B/vXjMvLKn6aCP2RPA5Y44hJ6jolVzQKqEhRdJU1xF45B9aSVJEgdbg4qs+gSxsjUUglCyMXk+Rcamg3G4xShP4kzHuszVecDVPiPBfndtU1KoXrVkjPexJTUo10KikKM6m1RIiFUUj044EwDrX6VVjgkhN5DlVGIS9FPO7lpfeeUhLGWvxScjg/ZtN+lGaUIr8X5IJyHq0tcRo4PbwTI1T6mDyQcsJmLZWw8i5y/l/zMLG42rL59FOM9VVWAaUoVIHV1R0xK6a+p7PCaOaYSDFjLRjXXB5XjrWx6ywoKZAmqWs1ra+HG8V4OFwAIEWYTV2bkNI0U1A1YUAyaFMqtNsl7dX2EgOlMnWNXzNla5tXPkkxgLYG5TTjvq+yAnk8GSBGCgXX1INc4ykxEYaJ6TT8gT5cf94npsw/+P4Tv/PVgb/w//qtb/rhvMzLvMzP6Hz9QPv7BUobdvvIOAQo0j292VbXfMhMU2YeIylnvDN0nZXWo5DpT4GYIMZMCImcE77pMMbSDwJqu1Y0gX0/EmMiZ/BNQy4SxaIpxGmm1OpNpaUL2xpYLCVe6LAfsHV1O4/zOdVHVtWqMI0T8zijkubtZ7/A/SdvcN6L5rQUVAa0xi5X+O2WZrnm0u9NosRU6yORRqWU6kraEWepITx8+QPmoTb9KHW5ueas5X/HJG51bdFO41cLuldv6W7uBWSkJN83xtojDhcBao0OyjEyPHygf3gn63wt1Y3G2bp+h3mcybnQbpZAIc0BlGFxc8vq/pWErKckph0r2lniVPWLVlbRCNuWcmF8eiSf9hhjL7rPknN1MWvC0At4Q13WsMZ7mkUnDF6ogKKVvnlZ9WtUqekCRqJ20jwx758pMWG0lcYjpSrAE8CllaK4GnFUY5isNcw5oFLBW1O1k/J4tGtqpI+6ON8LiMu97ejWa6xWxEnyT0vtmj+bf0TneI7lknW81ubSllRSQnmPcv7CwErRgJjKSpgoJRPGkTSOl0aukiXfs8Qg70WNhUrDCFphFxIVZqLFb7cY6wTog/y8ulIXYKrByN9Ha2IYOb77gvmwl+sWuY60tyiVJQVCa+IwirygRlAtb65Yv/lEYsJqgxMaYeWLvKc3n3zKcNgTDgcKmZQzJUfMYoVtF2A06RyDBKh8ZjH1JZpKO0sqMDzvUCmjfI1kokB9bLqx5ClTohxAtdYUNG7Vsrje1qzcXLNt6+FOWdI0XVj+lIK0JBnHeBjQiKSi6MoE51wXDZLRqq1BO0NMskmRIoqXOU8phX/3H3zBMEX+1//Ob37TD+dlXuZlfsbnawPRlBT755l5imidaTvLatXQeMswJsYhkmoeZtMYuoXFN4acYZoyMRUJsx8CMUWurloa7ypATeJ+LxBCJBdFLloYPKhO5USIUZg3U9dzMWENdJ0jZ0WYk0QRGcs8x4rbagh5yZwOAyXC1c0tV9c3LDYrbNN9zJPUBqzDLhe022uJ+iFXvR4CrlKqLJmqq84C2nDaHdh9Jc1FSskNu7Z6k2r7kNJgqxPcWI1rPG65pru9o7sVBzlhvhh7JAu0CNOlzKXhJU0Tx3dfMu2eLsykynIw0EaAz9SPpHnGdWKCCdOE9g2ru1d0V1eixUz5o2O8INrGlC6Mnjxgwzz0hN0jeeirNk/Jjfz8tTmTka5uVSpjTcYtV/jVClNBbrFWHOOX2tHKuBZqQw6keSQcDnXtrkmpGlyUVEDmeo2JtlNXZjRhuwV+tcRpxemwY+57LFUXa4yErDsja+IpULQixohdLuiub9BFIpRKqlFcIAw2VJ2rSAPOTUBKKZEBWIn2MU0rTvWcgESZ58p2CjMsa/dASlEihGr0VClFQGsFoQXIMaKbFtN4cpwgQ7O+khinnMDU9/yspz2HuteAfowh9j3H918QjkcJ7jdyzUq9ukY7aRRLWRIOROeZ6TYblnf3WOdrZmydUgCJWMI4tDYstldMWjE8PlBiwLUtdrkS4F0zcanNUWiNLly0vUprYoH+eY+uFZ/SdCQHTLK46kspkk2qIjlKpadtO1av73FeNKCYLKUOVrTNOUbSVJMltFxbauEZDydZ4WeRs5Qq91AI66y0vmxDckzEGNG64Ffd1/2Y/Lmff+tv/z6nKfKv//u/800/lJd5mZf5OZmvrxF9FuOA94rFsmG9kqrNvk+Mg7TjGKNpGsty7XBnpytF9KFD4XQSTd3d7RJvDf1pEs0kNUxcgdIWTTVNayVrdw0hFnzjxL0eJRi9cYrFsqUoxTSJkcE4R66snNKgnSbOI/1xpO023H3rLduba6z3shKtq9miJMi9vbrGt001CQmgJARh/nKN7MlFblhZGpn2Hx55/N73yXGkbRq09sQkLF45RzuBrA4Nws5YR3f3msXNHbZbos4sYo7VfaU+rqzPvedKMR0PDI/vmXY7+f5Gowo1pklYxenUE/oB01i0EfDRrDYs717hV6uPqVJGVtllnmoElQDLS4e5VkyHPenwTOxPWCv5lKWCcd00AsSjAOesNDnNkj25usK1nWgIjazUlZKGH1Xd/iVKyw1GWN40DsT+WPWl5856+Rp9dp/Dj6y+EyUFYV03a4wX1lNpw+H9F0wh4uuq/OzaTtMk1xsFt17TXW1RJZPmqTLRWdbuSqGLrKyVFkNTjlEaM7XB+rY63M8rY9F4Cl6LYA1aGXKYyGEiBgG/2vlLzFVJlxonKIVU27CMb8UNnxOEXH+WsHuFUg1qVANZOXcAgJY2qfl0YP+D70OOaCWh/toI42+cq01diThNaC//nkOkWa9Z3N5jfCsAT4ueWaWEJO9mcM3l/dNYnPNMWuO3V6Jr1kZ01LURitpXL7+M8veUhmw9x4cP6Cj1nHmW3zHlrYDQkD7GOhkNCbS34D3dzTW+awSY1gIB7WpuaMykcZSUCfkUQLuG8dQT+1Hios6gP4mZTnuD9haNaJNzSsRhpORIs2yx5iVH9C/+2vf5nS8P/Hv/6EvG8GLeepmXeZmf3nxtIKrJOK/YXrU0jSVlxekYmOcktZslS8UlijAVtMrSkJdhGiPDMNM0htVmQZxnpjnirL4o0zKA0qTav31uFNJFnOXWG2ISveg8zSxbQ7dsCbFmN1pX3fSZECKmxuCc9idyyGxvXnP/9g2L9RLj3EU3WNDgDH5zhV+tcc5UNkzVFWu86DpRFbieY15CYP/wwPHpEV0CrhEglCmXFavcHaGUjLFyw/ObFe31Hd16KzFQP+pM/9Empqo7xTSQMuPpxOGH3xen+rkqEtEsaies7XQ8MZ5O+MZJT7h1+NWG7vpWGN5SqrO69sYH0SWK+cnU7ydM9Lx/Iuyea25mdcKjpM3IGclXnQOFdFmLKu9oNtf4phEjk3WVUaxay/payPMrEjWkFPP+kTIPUIQV1LURC20u3eBKqxrQXqrWseC6BX65lNdDK5FtGMvy+o7Hzz8nxZHFZlUZ9CA1kkrRrK/wy6X8+ziKoz7nqiWtnfQ5V3lC7SZQ4gzXvhMjmDaS7VpbfkoS05VyXljiGKSKdBxRVph6+WWSA5bEAokJLU4joCtDrSklVn1oI4zgJSZBnve5O/1i8KoHr+l0YPf971HmGWONSG9rhqt2VhIDkgBy7VzNGAW/WtHd3ImON4Z6FqqHrvMbp85xYcgBa57IOdJe38jrEZMc7goopCzgfOopl/9IqLbh9P4BlRLW+/NlLN+jSKtYzoVcFFari6s/W2g3a5x3pHGoiRNKDiCqkINIfJS1l86FgiLME/E0XDbspko6Us5op+tnjRz8xJ2fpEjAW9Hxhh/tS/3TN3/p137A/+nf/12e+xfT1su8zMv89OcnaFZSbK5bus4zjYn+FBinyDgKg6etZp4jKWaceFiYRtjtA4fDSLdwNI1jOI14b9EWCrIizBXs5SSuc60FBMZSsFpupCFIY0sOM9tVg208sTKUpciNPaUIJdEtFkzTRL87UKLh1aff4vbNK9qukUzOqoVTKJJzdPevJcRd9tNy850nCSBX5hKuLiyogKDx1HN4/4HpeEQj7vpcCrGup8+mH33ZlkqMTnNzy+bNJ6KZLIWc4seIplyNQTUOCGXlBlzg8O6HhNMeTYIaQ0XOlJww3kJJxDGQQsS3LdZZUBa/2rC8vb/UZ6pztiXC6gpWKBIOXs1HcQ7Mxz1lPKGixNoUpK/beC/aQir+qav4nGXl3KzW2OrWLlpapZSyoIvkYub80e1dXf/P3/99dj/4HsurDcubO3Rdr+aYpa2nFEqca81lpmgB+q5b4trlx5xHbQTMG41vOtav3vDw/d/HDJqmbWoygaFbboQ5nyapQz1XTOaINrYyncjBI9cVM/JemraunhWiq1XS2FPijDJeVsM5iT40QxgHAac1y1JVGYOxAjpLgTiONTLMkUuu3fIaYxs5iNRqTi6PBcjC5GNkxa6NYe57nr73XVSSayJHSSvgXJNata+hH/HLTmQfuWDbRphQ58S4VmtARUcpj10OBPYCovM8EoeTML9Wi3GscVU6IUD10lSVc5U8JHTj2X35HpUifrngXAqgz5rjJO59bY1oqSsjjje02yuc81J/S6mVtQZVY69KUcKohoLKAkjnaWJ42qFTqdWgVe6TRVdqnRW9cYgUXUFwCKAVrpUDoHb+D/wB+7M8f+e7H/gLf+W3eDxO7IfwTT+cl3mZl/k5na8NRG/vF2it6fvI0EeGITKOMzlnjDGkkGlbzXpjaVvLNBV2u4nDYWS1afDOEOZI13lhMi4mnNrRnTOgiXXNKxQJjCHjvSUkxXzsefVqRUQyRpVW5ALeGlKMaAvetxwPJ44Pz6yu7nnzK99mtV7hGo/tGnHbzzMZg12uWN+/xneLavBQEDJlGgVIVA2eKuKkVwpwhuP7B54//5IYJnLJWOOkjefc0sNHd7xoWiXzcfHmNetXb8SdH6NoLWtgfqlaSbkrG3AebT0xZD78439A6vc4J6yv9hIDlULEaIXKAh7Rhna1ZO4HsjKs725ZXF2jqqaQM9OXkmSf5iQ37/MNXWvCMDLtn2oLUATnL2yprnIGVK46QHnvsBbrGmFBz/pK5yRVoLYfgbjIL+t17cil8PDbv8Xp3ZdorTg9PeMWK9rFUkDb2YgTA6Ef0DWcXGmDWyzxiwXnvbSy7rLqV0lak5bLBeH6itPuGWOl875ZyYGjTKMAGmOBXA8Euup/Re+aU43MKgGtLXa5QSkjbuwauVTiTJ5HtG/Rvr0kDpSimI8HAe9OtJ05ivvcth7lxSGeTxPGmkviglYaVTLG+o8AKCdK0XVtQNWElnptSr5pGE4cH95jtL4woMY7+TtnqUeGMI4Y50hFtKi28Syvr3G+kbzPKkU4HxRUZZoF8NoKvGficBITWYRcorQZ1VBfMc8BTtbsknuaKLZl/+GRMk74rpYlZCiqXNz8ZDBnM5OSGtxMottsadoqGVCqykdMNe/J54dpWtkuWAspEYH+cQcxnhUuxFhZb2exRlIASqoH2piI/UhKgWa1ku//p9Cn9G438N/7V/8mc8ycpvhNP5yXeZmX+Tmfrw1ErTOMI5xOkb6fOR5HchKQaI2iaS3rtaNpPachs3vsmebA9Z1oEmMqNJ1HUfBtQwzSFT5PmZQL1mi5j+WMLLc1KSuatuF46NHA27dbxikRY5C4JSU34jjPgh+M5fC04+n9nk9/6c/w5tvfwtvqhFWGEgspBgoKf3XD8v4Vuhp1MBbCKJFDlygmWSHnXMToYh3P3/899l99qEaKjDlr9y6rbX0xuGgt0Taq7Vh/9hnL21eSEZ8j5bwnzImSw6WeUSkrQe7KMB5OPP/ePyb2J4m9MdW4UTJ5zuhaRh9CFHyXM3E4oZzn6tvfoWnEGKRsI0Cisq2ECkJBMiytBWOZT0fC4ZkSJ3KIEgeFHBC0q3rTFGpeZXWrK/DrDc57mCeKAdV1XCpVzI8YamrLEsqQY+TL3/yHzM9P+KZFa02MgecvP2d79wq/WAGFPPbEmm+KFUlFs1qLHjHXm6RWcnBQNaO1aS8Zr1ev32Abx3g4sFxfS+/8OJCHAeW8ND+VCkSURP+c+8lBUcKM8x673lK0ocyj6Dy1/ni9aCfsaWX0VSmMz48o67BNK7FfJUvcZ9PWiKFMPPUi7TznthYxVhnbibO8ZGEotakxWlRAWX+OEdAZ54nj44dKfMZ6uEFayZSWg15MTMcjftmKJjcnnPesbu9xvqvgtiYTKHVZqQubK4cR0VQW4mHP3PfSppUSze2dxCDNiTwOFKUkvQFQTnJcVTEMpx4VI857eY1DpJzlBmfzW9VCkwsxJbTRNNsNi+sb8jwCBW18jRcTkFtyuIDndOoFQDeO4+fvyP1Us0fFnGQUKGcwrRPpgXagZDsQQyDOM6712BoVRT38/bxPLlIm8l//l/4KpUBIf7rlCC/zMi/zxzdfG4jGaDjuT/T9xKkPxJhpG2E/F0vHZuNJ2bDfJ/bPR4zVvHl7xTgJSLJSVUPRhjDNZBRhjvRDEGd3hhiEdYxFo5Wiax2H3ZFFY7i+2zCMVbvmGkJI6JJxVoO1xBDYffUVcdb8yj/9n+TuW2/lJpwrG2Q0aQ5ErVl/+i2a7Y2sYzWIjuAkwfEgN8dcRA8K4vDNhi9+/dcZnh6wRuKedDWxoOs6spyZULC1GtBt1lx9+xdollu52Z5rQbWnjHu531vRFIqzWYDa4f17jl/8vjjzz7WGxqC1EgOP0pdIHgEgiTgnxnHCLxRxPNEs12IQqiA3z7NkWYYgxQDOXhjZ8fGBeHhGK2pPtL401SgQ/Z9SqPrnMYhW1rUNroKOnBJqsZI1f85o11TdZF2dWzErjccj7//xbxJPJ0zXCvMEGOMZjweOux1XbYdWCMusjOj4tMJ1rbToXEBtfZxKi7RAK/JwoIQZ00psVeM9ZrVEl0zsT5ATZrW6vLbU68SojLICRLOSalPXNrjFWrSu0yCGIKBMg7zXrq2ZpedrIDMedgLcKzNnrBxqcpVTpCmRpgFtLbqG8aNAFyVNU8bK70qYq+651HICJea5mryA0sQ4c3x8B0pLy1TKWKswSuKHlDUYpyVFwJlq1sm4zrO6u8ctVhBrzFIuVXKqqilKVaPZWXCZSMOJ+XAgTQGtNf5mK6/5KCkNioLpWnltqmEo58xwODEfe1zjQdVs0Zwuso/LYbDqXyVhIOA2K1a3t+RpqocbXRuWENlMjvX3EMJuzzwMNNsNp8c9cd+jjCamLI1m3mCsAW1RVURaEJY6zSM5pEvmreQCG9Hq8vNb8TnHRC7w3/6X/xqH8WX9/jIv8zJ//PO1gej7d3v6fmYcIzkXFp2naw3LpaNbNqRi2e9H9rsDm01Lt1yw3480rcNosSTlIvmfxnkxicyB9bZjnBIh1sbEUnBO47TheBhYrzyL9Yp5jhitBThlYUoKlkQmTRO7d08sr17x6Xe+zWK9EGNOKmCF3UkZVLdg+/otzfZaAunFFk2Zepgl7qWQRQdaGQFlLKfDiQ+/+7vMwxFtrdzMavQOSPC2xCzJzdfWysLm6prrX/wlXNPVTMlE0RLxU9KEMpWVMU5uwjUe6PjVlwzvv5BM0yyud9c2ommt7TCxZkkaay6h4bppuL65pqTC8PCAv7qnXS0u7T7nJiTVtMLoGUNW0D+8J5+OFYTCWRZx7mPPMWBcK81BMZJDIKeA6zoxaNV4K6zkaBITyjcQ5orOq4saTf/0yFe/8RvokmmWS4FvpUiUDtAtlvT7I3v9juX2SnIzi6xim/VKzCMIKBcAUw8a1qJsQz7tKXNA+5ZMJp5OzLtn0QTagFsuUc6T5vHyXBUaZRXKGQFi1WxjXSts5cUBLvpTqXTVohGtsVMUQwmR4fBcf7McCVVBaBIGvEhuqVJgfSs5ljGCVqJNbRfCFqezjlZd2NrztSLqDTGyxXnm+P6dGJ2UrQVYmhgS1hasP5sHRUKincRhGeNYXN3ius3HwoIcKwmqL4cvpWtsGdXINU2Mz8+EccIvFrjNWhjvetgzbVP/jlTzUkH00E8cPzzijaVoK8UESXJP8zRfnn+pma05ReI849ctq1dvRLeZIhRFihFT0zPUWb9aCvPpxLTfY73ltD8yPuzwrRe2vEoG5OdmlMqUSDVGxYum1ziPX68vkgBp/Cq1Te3nbw5D4H/4f/41fvPz3Tf9UF7mZV7mT/F8bSB6PE3Ms7Bi3cKx6Ayrlce3LeNcOO6OTNPE9e0aazWnw0DTNTWUXVMwYvIJmbZVhFmacMY5o5VC64yh4K0VpmdOLFeedtEQE6A1IYq/3lqLMZo4z4z7A/OYefuLf5b7zz6haUUnRpDWHbQhAW61ZnH3WgBAkuxEUpTIpNoEJPq26uY2hjTPHN59zu7LdxLA37ai51T8iCO4xhGVhMoa5x22benu71jfvxWzTQxVyyYGjJJqaHd1r0tLUiROE8f37xgfP6A5Zxxm6cOGj41FgKmd8TkXkTb4hq5bCEixCo1neP8lzjeoFC7vw9lgo7Rki067J/I4SFIVoq08s2LaS0e78Y045LN0ueeU8F2LX6xQdU1fcu2ZTxF8JyvllC7r+Jwjx4cHHn//e2il8U1TcZbED+XaVAQK5zyHDw9YZ2nX1xhr6K5uMI3nnJmJ/qjfU9pKn3h/QJWMXiwlB/J0Yj7s0MZivJK1uDEXPW45Qy+rJB+17mC1AtU0GN/B2a0usQ4XwI31H6+ZHCkxMR+ehaFzDSVl0TrWelRtLTllYY2rYz7nDPNIthazWgBnc1TVSHM2I1XdMedmsUycRvqnJ2nOSoWcpEChZEhzwBg5IOQaKm+cJYwTzjes7u5p1tfyPQsVFNbJ+SLVOE8phdifCE9PlAJ+ucStlh/bqc6999VQJekDBYpiHGb6h2cMGtd1l8ajS5h/yZSq96acT0IFv12xenWPytUNnzNpDhd9tW7aGo+WiceecOrRzhNy5vThA03ToJ185ogRTSLijDbV5CcmuxBiDcFX2OVSDnZh/igNLWJo+nmaXT/z4TDyr/57v/0CQl/mZV7mG5+v/Qk7TRFnDU1j6TrLYunR1nE8RfpDj7GK+1cbxikxzwHrnTQbmVq9pxIxFKwzl8YfazWNkt4incFaSy6KECJtaymYKodLoBwoAaspROY+MB4HjGn47Je/zdXrV6JLO7NrRjrJ8Q3tekOzvRbW5Qxkcv4Yl2RqVFD6uCqc+57nH/6QfreTtbiWcH5lBCDkIsH6rna6l2IprcE0LdvPPqO7uqmGnnDBFBQJelf63Dcv69UUJqbjif7hA+l0BGVIKUGRetBSMlYbstakS2UilyglYzS+bapmztQWnELqT5zefU53dSPA+dwUVDLT/plx/4SKtZWGIgayc7SQs6AdqgRQmZSSrLVjxHcNzrWyGq1Zp0pLTiW1GUrc8gWcyCaO795x/OornD6HqSthuVKRlfWPsMq2aWiN5rTbsbx9xeL6Gm18zVCqTuyLBtWJgWg4StuRb8hxJk0ThYJtO8mYrACo1FpWZQw6S90p1GD5lKQG0ji0b+X6SbX9SSPd7RXIC8vGhd0O40hRBeO9+HwquypEr2S9kqXSVRtDDJKpa5zFLrdo6wEl71+WZADyWa9Z36GcLs+jf34mTpMA0/r6CaOdsPV6jiGQogDbNEW0c6xev6G9vpPXMM4Xk2B1NclhxdTyhBoon8LIuHuSVfzq/9vem/Xakqb5Xb93imENezpzDlUY2xKfiTvEV+CGL8AtggvghgskCwkhzJUtYdQC1EjYGIzc6saWu6srK4c6eaY9rL2GiHgnLp4n1s62wGQP1dnVHY+UUlf2ObnXihVrx//9P/9hQ61FgvK9Gti8/vkq8owZ5McpcrrfYVKm2aywbdDvXD0fjIqahWrKAoAxuL5l9exa7v2cKDmpZlmilqxXoyOGfDxRY8R3DXEcGR6PtFrfmZJ03EtSRgUj2nMB9kk2CRWsc3SXW5q+p0wj89JeDkYO3F8P1/xhTPzBN3f8n3/8kX/4f337U7+cZZZZZhngTxPf1Hj6zrPeNDRtIBfDfjdQUmS1FmYvRmlImqZKTokQHFkNSLXWszu+pIx3Tly8KdMEQ9MFYqrSduMdU7aS2eidVjxC0wSGw57j455pyFxePef155+zvb6UdbnmQOJl1W1Wa9rrG5r1VoBOTrJGLFXblLRPXB3zpmkopXK8u+P48QPT4YigyCIMJAJIKMKieee0SjHhmpb1y5esbp5LPqX20f+wm7wWMWMYDfamQp5GjvcP7N+/w2gfuslZNrLOCkA0hqzB3bPr3ASPbxqscQpurDxwayGnNCMgxvs7XNsJMD5HMz2QTges8ZQqRhqslVB/I73oxofzWpgK6XSg1krXdzjrmTMl6+yCrzwZvFI8r8vjcOLx7TsOt59wKoYsWeJ1atXYnvlwYAxFWWnXtqy2z+mun+OCmJs4R9HrH5872ou0MJngyGkij2KYsb6V91WKRIRpNBigHecFWzW7MkZJOPBB1vFOmHmc0TgudeabWdso7vpSM2kaOUceKatsNZrK1HJeNxukajbHiZoSrm0JG9HxoiH3OCP3iPF6ADM/uM6ZNGYOd7eUacIFqbLUGFioVfSzVXJJU5HDRxzlz168eUN380wOHuf7Ud4/uYom4dz3LsrQPA3kaVTzmDQO5SjlFoQgmbS1UuJ4BpgYQ8qVw+0OYmZ1fXHWKMt3TfJ4y5SouUgCgdFeemfoN1s5SE2jgNuYtXYzaPapXJcSJ2qK+L4jTiPH+0ec8/jgyDEzHUf5+jYwm8jQkos4FFKSg0GzXdFst8rea1IGFXLGhkBOv93ayZQL/+j3vuPjbuC//cdf/dQvZ5llllnmT8yPBqIXFy3bbQvWc9iPnI4TbWPoVy0xCpsYmjlH0EjOZ9Yom7nn2lphQoNnGkVr2nWWrgvkLPDCBa2QxBAaMdlkLDZn4mHPw+0ObEN/cc2LLz7jQpmTWbNZasE2Pc31M7rLa1xQ13aWjnihNS2QqbryM9bjuxXT6cjj27ec7m7FUFWr1GYaAXqytZd8ROefQJ9rWzav3rB+8RLXtMLczW7sOmNCM9OYYuaplePdJ473O9J+J8YUDMUqe2aEkZmZploEpGPANy2uCRKQb4WNslayLfOUxXRiBVCWNBEf7/HrtayPH+4hRyxW1ulBWT8kdN56jw2N6PXiQC2VnAs+NKIHBQV94azPlLdnFExVlRt4xsORh19/y3B/j9Me+ZILDtUgOiv1nUXfJwigC4HNs2dcvHojGsvZjT7rco2aqVKURAMFhXkaydOICZIFWqao+lPtO9cIqhwnqTctVfSPteBCi2tbqSB1/pxicAbV6Hs1RmKwjCFHySHFOKwz5CqO9bn2c64FxQoLaNRYVaYJ33Y0Fzd6zlGdJshq3Fq5XTRhwADVFNI4cny4F3bQe0lu0OaiWTlgnSNNUUxLTUNOEd94Ll6/pr+61usxaya9AOtpVKDdyHXVrKOSJqoB160kaWCSuDbrJdXBNZJHW5LKMDBUSfxnuLuFmGnXKzlMxii/B4z5QXB9kntYY7qKkTpNp7rPkp/azP5EnqqRxq0yTbi+k8PjpztclZQKtGAAfa21SM6x8x5rLGWSvN1awa9a+ssLjEHYY8y5jaoYMU/l8fRjf03+lZu/97t/xBQL//0//dVP/VKWWWaZZf5f50cD0cvLFbnC7ccD0zBxcSmh6eMwR6fIydtZg/fiVJ01caJ1rNRiAMs4Sp/65WWL8Z6UigA+0IBqe36wGmuwBQ63dxz3A/3qiuuXL2jX/RmEyX/dUTD4y0tWrz4XU8q8vi0Z0vTU5lNl5Wi8F3ONcew/feL+u28YHu4F+OlDTR6KqpnUvEMf9MFZDd3NDRcvX9GstN0nK3CxDoP+b21Lko51ASP779/y+P4dNUptpJhQKhb5GdbZcy2jsEMJ04jT3VSDMxZrLC408qBPUdt96hnTQMW6QDqe2P/6W5z3kvNZC3VekWMp5omRFFORMHk5RmqphPWG0ATR1JaKCQ21ZlUWOGWRFGUrMD3tHrj9+jthXq2lIhE6piCrXCfGmaKO5hlkuL5l8+Ilm5tnUmwwm2nUMS1AUK+Lsdr4VIiHR2GgG9VGTgI2q67RDT8APLlQJ1nbGgq+awjrLUaZ4bnA4Hy/GJBazfk9WtJ4Ig8HrbsUZtwaAaAlJXy/5tw2pWvnkiQCya/WNOsLCfivCaoFN+uTedKICpVORRjO48M9KUYBU5pLKkwxOKercY0gcq2sk11oWD1/xur6megrdTuB1aKG8STfT5UvzJrdGieqqWf9colRMoObRg12IueoyvRKeUGl+pbjp3vy8USz6iX2LGXRkuoU1WhaK+Aw10oumfZyTdN1+pUtswRbTHKlaEKFrutjxLWi2T7cfqJM4p6vWQ6jFTnUSkarwzbhHFyfpomSEu16RXdxCRgxTc0HDo2xcsFDSlrJ+ts1/9X/8od82A387r/4nlL////8Mssss8xPNT8aiD4+jDzsT9RSePZsTWgCj4+j/D/VaDIzKYBUdWqzkGzjHDnDfnegCZbLmzWlQBmlWchVg/eOYpys+J24z/fHIx+//UDjWp69/oKrmxtW2zUGODweOZ0muosLCA1tv2L1/KWYUpT5qbNh5kmoiax4wTQtucD9179i9+3X6qAVnaX3Tte4kq9HBd+IcznnRDaW1auXXH3+M4LzwmrVJ6OJURd8VUZTnm2OlDK7775h/PhRVpNGWCRZq1dd5Rt56M5rzBwheGwIuPm1OYdrW1xoJEw/ZmqSrMo5uF4IOY3lmaazqx9nsY0AWKMkZtV+eUPBVHHll1LpLq7kYZ4nqnUCZjQTk9mwpTpIqJgzqP+WNAy0TaAAOSnrasVcRcxPzBsZUyphtWLz6iXd9lIagepsoql6LUXHWs+rUvmZ8XigpEmaiWKknLWwlZKKVltKXmwexzNbVmvGdy2NGnfmtfo5t1MPUbO21hTpdk/DQNw/SjOSRe6T2dMUJ1zTUIaT/LdmQ5wXls/3KwleV2NS1UzQs2zEgKn23OdOyYz7HceHO7mXssgBai1nE49rW5yz5FE67X3XCSj3lvWzF3SXN+d7+XxKqYU6iUba+Ea+HZoUUeJEIeNCByVTBkkJcBrLda4LO7PYssOowfPw6/cwTIQuiCaUShmjpJLhKDGp/lmC60uBaRzorre065XcjxqdlVMSzW1OYmbbrMW0dBrwXQfGsv94Szyc9LVVzVi1Z9e/tUY0wk5Y2RwncpL6zu5atilzNaj1kmhRkoBr452A79+iZqW//0++4p/+4iN/+P2OcemEX2aZZX4L5kcD0Y8fd7SrhucvL6Ea9o+iv7IWrDmjEV0jGnzjSQOkONK2nmkq3N8fuNg23NxsOQ2ahYklp6Kx6QZLEud8rdx9uOP+047txQ03z1+wublgtV4JwCyVpgkc93u6F6/YvvkCH4KAhRwVhCZqzmc3trBbwpCY0DHtH/j0iz9ivH/AIsHdKU8CYou8JmMMPjjavqGmQs4Fmoar16/Zvnglhoo4CnBQ5qRShYEFeWiHBuMC437P3Te/ogwHzUwVQGyNoaSMCwIw9bFOyRlngK6lTJEQGkLTYJyR1p1azytK4NzqZJyjlNmMUQltJ9dAcyKtOr5nU4ZrPFWNOYZKHgeMc6yePZM1ZYrgAtb6c5SN5HbaM0iTHFTH/bv33P/qK4L3NNojXvLTQSVnqWcUw5bB6JrVrXu2r1/TrjbnxACswVSjea7i/Kmj9LaLHjEKCM1RXOjTKBpHN4eQJ9EWzuHwCiqNtVSbaEJL2FzIe0jxbJap00QtCWN/EJmUkyQpHB6ZDo/n92+1kQoMpcp9UAuSR5oTZRSQU4cB13bqLq+AHBxQ85Gps2TEUq2T/7sWpuOeh/ffi5FmmIRBdsI+UjVBQsPXKxLUXtKIC5b++hn91TM5kGQB0YBEoMWoJjx/lgcYHwSE1oTremou5OEECJgXSYBUk87aUlNEC22bTtIl9o80XXd+jTlOonNWfXhW0OeCZPFOpwG/6VhdX4tZ0FlVZSdc30mwfUw0W9HSTscD1opL//DwQD4NNCFQciaVKE1Tc1NSyRIpZgzERB4mciq44OhubuS7lhJ5lBU/GrFVY5JDhLGYRgsffgvmH/yzb/hv/rdfclzakJZZZpnfovnxq/mbFVdXax4fR2IqNE6iZKqx0i5UM1OU8G6MxdSIIeO8YzhO7A8DNzcrLq63pHHCBUsxlpQqQVfsBvAhEMfIx7fvGE+FV1/8jKuXL+j7Fu8DJYqj2AVP23Z03Zrtm88lKFvrFUkV8iTsiGYhyj8GEyTr8vDhHQ9//C8pU8YamFIi5SoPTdQjYi3NqqNtpJZ0ipNkg755TbfZCBhIk2jenIMiDJaZV8lOe91dYNg98vD1r6jTQEniTrZW9GgGsK24eWu1IjVQrSTBU1OmW63wPkgKgZMooFrmfMWZbVRHeZZYGm8N7UpYJKNShHkla6iS9+klBF4kBZacM65f0ay2ZzBvmh6Ts7rW50OHVeAkpo5S4NPXv2L39q3kvRZZ85fZkKQyDfkoKqbKAcFUQ7PdcPXZ54RupdtRXftXqwSzgNY8niQZQU1N4+MD6XSUFap1uL6XuK5xpGIkB9WI9lUyohKGAnkkOE+zuRAgOA7qEk+q7RUWDSOgFM2Njfsd48OdtDoh+aPzOtyGgGt78umEXYkuMu73og+uBWs9runPoNoarQ/VogCMO4Nv0afCeLfj4d2v8W34E/pS20idpkEAYcmZOEXpRq8F33i6iyv66xeaZjCH7SvjnqNIK4w7GwmttZIRmxOu32C9Y3j4QJ4mccrngmuC3JfWK9suJjAbWg73D8SHHd4FuTLGnjNnjTXnz/9JwlE4nQZ833L15rVcQ2c1yqtKagPS+NNcbLEhEPf7cxnBcDoy3N3j1JSXVedckXirWiuuCRgv1ycPEzFGjK20189wTUedEiVP2CbI35yi5IxiRLZjDC40kqjxV3h+/5s7/qO//88ZU2ZKf7Vf6zLLLLPMvz4/GohuLzfc3Z8w1tBoak+sVkFnxWso9ZgrTZlkHVthvxuwFF6/voTQMhwn2tZRKxxPhZU3tK0RLGUd+92eu+8/4sOKL//Ol1y/fsFquxZ2aSpUJw9k267ZvHottZkhSGi7VaYmaYC6BaPNORhxghcsd7/4Q05vv9aw+MI4jqQiIdbeST2hs44QPE0rK8BUCv2bz7n+8uc4i0TfqE4Rp6xL0XxQayVWSPWGh9tb9r/+lhon0bIhMT82yFrQ+6Dsope1dUniyHeBOJxom1bNJJKXOWsJZZVuqFXCvasyublUQtvQdCsNYv+BHva8ogXfNpRcyEnAeIoR13W0m0sBtylDozKHs04TfX9z24whl8qHr75i//6dMHTBq44TYepUK+mCxFJlBV8WS3dzyc3rz576zatIJk2tkkXaduAK9XQUN78688f7O9Iw4Loe3wvLKFWvVjvj5RBgZnCXVVNaK77fYIIY70qeFPjqet23ELR0IEVhs0smjQfGuw+E1UaNVQackUQHBPyXlM4AZry/E1CqiQZhtWbOAZXu+FmyocYvih6kwJTMdDqy+/ge7zzkSowSwO9CgJowGvJPrcRxxLeqrayF1faS7uaVvPeS52Qm5q0FGGVmkRgla6nOUsYTpumwXUd6uJMUgYsLTE6YRt3jzp5/ruTaGo67R06fPhFC0HsSckyyWnfuDORE3yv98nEYKbZy/bPPYExq/pvvFbnH0vFIWK3BWabHHXl/wFjHtNsx7A9yvYw0pjmLSkDk94jzHt818utgHLWhq9JeXRD6lURGxQnbWGzXUI4nNREmbFU5T7ZgDePd7Z/pl+tvcnKp7I4T/95//rsC3ufv5jLLLLPMb9n8KTSiR4J3mJqpWJJWDXprcM4w5cpUCqFKePQYM6fDSBssl9cbUjGkw0DfBXKGGCsXjaFtHLkaYoH93QPHhz3bZ294+cVnXFxtMNYRD1Kt6JBGlnB5yeWXP6ddb6glkSfteTfIGllDxImia6QUTGgZ93tu//iPiLt7yZ4ssh53VtbDXSNrVoMlNA02GKZpwviWzedfcPHZF7LiHU9npk7MOQrarAHjJXewylrz8dNHjh/eEUKgaHyQdQ7ft5QpSSzO3CijGsoQJEbK1szq4oI0RoIPYoaqVXqzSzkbnOQfAaixJNrNmtBvZMXotB7TeaqzGHU5G+8EEBbJViwY2m2P7zcKXgqEVnWREl1EUi2pdQKmDMQpcvvVLxkeHujaRtgw56WBSKO7pOdbPpKiqQO+CXSXl9x8+XNBEFp9Oq/goaquU1pvxBQlZQLT/hEo9Dc3AopLJqcoK3iMapblEFKyBrQrzW27Fa7tBSydjlAz53rQppPPImvMkObOljgw3N/i+7XEFRmEJcUIgIoTeRgwPmCdp4wT6XgkHo80/Zp2faEZrU5X6KpxrUYikHg6LJEz0/HA/sN7bIWs93KKUhgwS3OtVdNWyYSmpVpDqZn+YsPq+oVKEYQFRa85RWoraTTPc5okFzf0lOkEPuCalvy4I4+jlDEUwIv7XlhqQy2zeakyjZHTx1t8EZ0zeiBKx5O2hQkKrvO2ogp7OcbIy3/nb+MqpFpVXl2V/YZ4OGpzkqVMielhTy0FHwzHuwcoAsqNQQBkzlhjRf/prLDyqVJKknQIZ3D9SvTkKUrCQi20zQW2FKr3mKaVrFlE/lBL5nT3yP7TXx0gehwTpVb+3f/0f2bBnssss8xfh/nRQNRZZG3nA6WCC7rWozKmIr3vRRzAj8fIOE5cbRtWm4aiTu6mFUaSXFj3jhQzY5LT/f7TPcMp8vzzn/HszWu69QrGJFrHkikWioP25hkXb17T2Eo97oSxC5085OZ80FrVaGLEiGAcw/0H9t99K9E5PpCmKHrIUiil0nctxonJyHpPtUaI1b7j6ud/i357SUnTOWtQ+sBlPV6j5B2a0GCajloy6XTk/ttvmfY7mr6jRNFs+q4T7FQKYbuRRWVK6kAWzWAcR6yVcPyai5iTZAesNYgCArGzLtWQS8E4WG0vcO1KDEre6ZrUnHWngGrjCkXqlCg10V9eEppO9JEGAU6z+WrWKgRx3UszUWWaIre/+opx94APTh7+VZzsVc1iReOyxFRdMbni28DFy9ds33yu/625N16YRmE+ncZHFUzTKfNbiIcdJSfC5lI1mIP+Xac6y9lVL5+N8Y3qU0UDaZtWY5XmhiZlin0jTF9UA54xInEYDpTjnnZzKaywsVpuIEajXCSY3nYdxnpKrZThgGtabPB025szMMd6kUBYJ2t9BWq15DNhmaaB/e0HzZuFGjMxF0zJlCi5l8YaAfoKlrGWSqbbbFhdP1emVVbgRv+7VWOhpFlKosuMtdA05GFHyRm/2hJPB8pwxDaiuzQ2UMtTckFV4x5V4sROnz5h1ehTsnyXSo4Y4wjOqGlM/0qplAKxZG7+7Z/TtD3peAQnkUq2CWcm3hqD73uJSDvspZq06zgejqQp0fUdc6oGRhIZZFNQMMq+Ywxpquc1fXtxAQXSOFFqodlsccGRDifcao31DXH0pNOJnBLWS+KEseHP+3v2zz13h5FhyvyH//X/waf9+FO/nGWWWWaZv7D50UC0AsZrdqWBOEZxvxqwWGE5kmGaIsFUrp73hEaC74uFWg3BW4w1xKmScsUGzzhGdu/viJPh5tXnPHvxgr5rqVHMQqVWUsr49YqLV69YP38hOZfDHmOcGG9mY5KxAmoKVI2bKRUO9x8YPn2AJCxinObIJAE9TfDn7EZjpDazGkN3/YzLzz+n6VeaF1l1Ja2awzkMfNaeGtELxmnk7ttfE3c7rbIUU5Zx5gzqfNsKUJsSOY4iN2h6ifexHuMcSVeb8wPXWOnmNtbpjxaQmKnYxtH0K0D6y2f21JwD0es5PL6UMtOT5JxY3dzgfZAwcvu0emXOwZx37M6BEXA6HA/s3r4l7fcKlO0ZTJWY0LAdvLNUXc+aUgl9y9WbV6yubkRCURKa2wVWQLNgbmUltc+95sz4eC8ayH6lLUnT2ShU52gfI2FepqiruxZJE7Ba8anmnErFri84Z9vUSo0TzEaxFEnDkTSKyajOhqxZaqBtP8Y6jT5SNjaPuEYc3LZZi2MbhYRpetqOh0bfu7B5hkoaB/Yf32u+ayBPhTwJ6Dfa4mUbAda5ZIpqsq2rtKst/eVzBZqic6ylPGWvVkmDEGe8gvAQKMORmjK26cnDQDoeZP1v5RBTNJfVWKvXWABwjJnd+48wRtq+l/zSGqWGE4P1dobBuq4XfWimcvHFG9aXl6TTAdME0jDgu/b8Xcql4Fc9tmkkuzRGustLxnEinga6lfy8+fdSHp8ODy60+BAE9OYkRrgm0N1cYZ0n7Y/yHVuvsc6TTwPVevBBIqicxzVi7pvGScoA7E9rVvr+/sR/8g//gN//5u4nfR3LLLPMMr+J+dG/YQuGNjhyFi1eVdThjCHFzBQLwxjZrgLrtcSlxARt30AWtm9KVQCUlZzQ08Oew/2JZnXJyy9f0jUNrhryEKmIacF6x+bZFRdf/pxueykGmKxMl7a6VHXDU6KaUgRsxSlyurtj2N0+JQwhJotcq8QSGfBdEPY0J/n33YrN61dsnr8QYJpGYc5c+MGqEVnLWweN6OJSygyHRx5//Q11HGlacbbXnDVoW7MTg8baTIk8RY1TEo2fVcbNlKrslxWmD0OZ4jmWptaCMVXW+T4Q+u5seFGft+oppfsbYyVfUbu1AXJOxHEQwKtNSsZ6cEF1k+UJOMmFo+TM8Lhn9/4deTgRGi9GEaPmHUnjx2IUyz4F0YcucPH8Of3VjTDWVvWV1ahhXJz9ZRzAOEkGsAKG4v6BUrKYR8aBud60lgqoS1oPIqKXLTCNEuHjPbZZc65W1ZB4nKEiYLjmiEEOCiUnxsMjtWT8agVV3P5W1/5VV822aXEhcM4Xna99qth+rYHxs7lLHftz6H8cNX81g3Ok8SQRTVlMO2UcZf1dBUw+ueNVW5qrXKuUaLeXrK6fI21MRg48Vatb9UAhcVBVgXTFOEcejpQ44pqePA5E1eEKONdQeKOmxLk2FzkYHu8eMDHTrPpzAHytGa9FBVhL0gORqbJ5yLWwfn7F9uaGdDxIKH8VvbSxhjJHermADY0Y7Iyl2W6ZYmR82NNqjmnV5IWai5LbopN2QWpD8xTPK/n2YkNYb4iPe2ot+M0G4z15moR97XspPzBRYqpWK9JwYng8IOH5P40L/cNu4F9+d8/v/P6vFxC6zDLL/LWdH1/x6T0py8q7lqemmpgKwygPoRc3Pb7x5ArTmOnaQEqZpDWa0qrkSMPI4ThgTODm9ZdcvnhG2whzVKLo4XItuBDYvHrF5etX+M0lGE8tEUPB+JZKoeQoD8iUqClqdBHs73ecbm/Jx4M8mK0hZ1kXWy9h8NbNveWSm4m1NJcXbF6+ob+8wqAPRmPP7T3nMWpu0TB/0fV9ZNp9AgV2wj7NuYYO7xzGC/OaxkgtkpNYlcVy7qnVRnJA50rKJ2OQsYZSCzkLe+n7nhBaWRVXbVQyaupRVoy5n10lACVncbDXinOB4e4T9tlzQrsWcDQHn2OUGauAJZ6O7G9vGR4eoGRC22qoupqE5rzNiq6xOTNj7apndX1Fu9pqUHxGsjSfXp98hkmutwKndDoRj3t5b86rC1vY0zMABAXhTyHo8u8sNjTYpsNaJ9fR+iemtyRAqy5/oL2Nw4GcM+1GQu5zSupaV7bVGlzXPyUy6GcjZjWD7VeY0J7z0WvRA4TzcoAr9en+cZ40Hjnu7ojjCVurALKUpf7SGDHdeAHlOUZ9a5K60KxXmhPqz9KOc4yYrsTnmllAYpyqVHLK/deR4yTd8SFINmqFchqUmXUzxj4fRA4fPpH2B9rVSjJTYyINg5YTVJXESKJDnWUSxtDeXLJ+8VwjoSolyWHH9j3ldBTGsvxQpoE2dB3Yvf9IQPTO8+Gj5nKOfoNKcJJLmjRdwJhKs94Q2o48TpScCRdbyTSeJvLpoDW5ljxLMjDEaeJw+3CWg5g/cRr7zc9hiPyj3/uOX77f8z/9wdu/1J+9zDLLLPOXPT8aiPq2owwDORVizGcxf5oS3sFq3eGbAEVc2E3joQpLCAhTYivD8ciwn+g3Vzz77A2rzVpAoYrZapHw6u7mhsvPPmd98wzbaC5kPJ2BS1UTh6mGarTjGss0Jfbv3nF4/z3kormc0mNdSsV7h9OgajHuVGKewHv66yu2r17LirtmYV2coxonoKfU80PJGKhG+tmPHz9wvP1AGQYN7i+UkjW2SNuYtNXHFEhzxqgToG5rxZ9Ds+eKRwGh80Z4bpqiSpZpwdB0K3xonq6FsVgfpJFIndnGCYNMjlhrmYYjeYxY5zVqC0qKjI87fLfGWK8RPaL3lAgsxzSM3H/3HcPjDu8DLohNOSfV5JaKCRokH5NcH2soxtKuN6yur/FNc17TVtUOzrmu80WVcHUBivGwZ9rvz4ce6w3WzxmhSIsUaFe5or4sa33rG1y3kpByXd+fe8Rn0Dmd1Mgkr6XkSBoHKtD0awHIpT5liRrO4e8lZTBZtLQImy5pCL3mxmo1Z4rnkgEwTwypMVgXyGnicPuBeDpIDJZWZeYkJQw+yOdkG0+eRG4yf6btqqe/vjlXYmKM1rXWs1bWgjCUcAbceRqoNWObVpqYjkeJZLJOZRFRv2fKajsHU6IYz/7jJ8a7e2nawpAnOQBWPQSUWp8isIxReUymvdqyvrmCKYqkIXjy6YRfrUWvqu1HZhxFH4sA6NPxwOPHW2kS808HHQPklLQ2VOtsdRMyyw9819Jut0IgDydMcKKtTYkyDJRppIaZ/TfUHEnDyHF3IKeimD5j/5JMQaVW/svf+VccxsTv/P6v/3J+6DLLLLPMTzx/ihzRF3z45itKzlhrSClTcqFpLKttT8qVGEXPZp0XOaWTlaKxhhQTjw9HrO958fM3XD17Lt3l9alVpuQMPrB98YqLz7+QrE5FYjWOZwayTqOyaoY6V3D6huP9PQ/ffUU6HIW9Mu7MYlElON55L5WYw0hOUSKb+hWbl89ZXd/gm4anmCJlFK0yaEYBjRFQU0tl//1bTh++VzmiuLRL0g53ZYf87KZOUdjDtqUUw/S4p2kbuUZmlp36s6av/DAyCQDJSDTW0vUbvOY65hylI90qoM+ZkiMVNbSogStlMUwZ6540pDjJgS2V6binu5KKzDozfLUyHfbcffsN6XQi+B+E1M/xQFWZYQ0jZ24asoZuu366rqCZnoZaIrYLwmTOBjAvh5c6jsTjjmkYJYfUOa2W1DWzAkm04tOedbBFciZ9ED1o0AitmYE8M59R7rkZ5Wdx5sfDAeMdrulEFmDAYHRFLBKDHCNpOFFiwncdvveUEuUQ0LSa0+rBOQFoBoxtEB2rMmsGTGhIcWL//TfCxs/3q1WQi8U1HmvMObKqZklBSHGiXa/pb57h2+5J06saVoN50voqA1q16azEkUrG9ivIhXQ8YDQBoybNdjUaWl+L3rcZG1p2379nfNjRtq2urMWwZWeWVzWeKFNtnSfHSNhu2Lx4gauVPE3CfJ6ixGsBaRhoLi80Aq1Q8kTxjmk48fjuFofB9x01Jwmk98KWGyOu+lmfnJIUWNRa8H3L+uULrObKGu+wbUsdJ9LxUXJ4jaUaI21P40SJI8PjnjzJZqFoYoTITX6z8x//g9/nOCb+8R9++I3/rGWWWWaZv0rz44Hoi1fcf3jHlPeMJ3HRrlceHxriKA+HUgveW7y1WpUpD8RpmHi8P9CvL3n2xedsnl/hcZRpdgtbUo64rmfz5nPWr14/1QnmRIkjJrTY0FLTKA9N1fOhzvfHdx84vftOGK1SqUhmpVe9oHWO0AVA4mBqKRRrsf2K6599Qbe5UJBUzg+5qo50qUKXbMrZhhzHid3bt4z3t1gjrtx4OqpT25GGgeCdNsgAJWGNuKtjlIDtJgQF6sqW1kqpVbMdlTU7m4cK0xRp+layLAuUcdKfJ+amOfS8FqhJ5BIom1dSEue4E2auUBSAaO2ngWm/wzQt7fpSgvmN43D7kd27X2NKpWk7ZZbTeb1tDIS2ETe6ZmHmLE086xfPWV1cnYEiynSWXCSw3HnVimoklGZTjo930jbkgnSoUwXweA3y13B946UKtZakq2O5D91qI5pejAAjXfPWFKVyc9bQGisxXnnidH8HwROaVllOzitpCZCHdDoQD0fScAKDxBvliHNONL5OtL2zuYqSzzpmqcaUz4jgyCny+PYr1TIKm60vSljtRrSVxhppDUoRF4IAu65j/fwloet1/V/1XhUwi7YalZQwM7ttKnk6ScbmagslS0SSke+tqMDlWjmvjnljqTHhVise330g3d/RNC3WWJJm2TonbVtFdQDSCy/xXylnaBo2L1/gtPnKNa3KCwqh20jsVYU5DxfnqePIeDry+PEeayyhFUlLSpLxa9RoZ4wUW9imIU9Z5AEpYhvL5uUzQteRjicpgWhbydg9HUjHAZzk8pYYYZoAaX1Kk2wSasmyPXGBOA5/nt+x/8b5z/6Hf8Ev3u34o+8flyzQZZZZ5m/k/Ggg2jYNm8tr7m7vcbbSrxtCaKilElpHnApd45EMPoMJgcNxZHjckafK5fOXPHv9ktXlFletAiNxsZ+GyPrZNdc/+7dotpfCPNYCc6ZfvxK2KEUNJvdidLFSEXj/zdeMD3fMLnHNJpeHJBLlEhrR0BV96JuuZ3N9yfbVawmPl6cq8jeNhnAbARIla0C9RMIcbz/x6Re/oMZRtKDOkeOE9QZTrfR9BwEdOSeqLYR+hfUdp/sHaq74psfNRhBlOedQdFnlS8IAGJJmbPq2IfRrWUuWGYwFTJB1ek1iuKnG6oq0UmphGk9Sf6oZjeRy7j6vVR+8VZziw6ePOOOwLrB//5bT7Ud80+B9YDoNope06CpUjSY+yPo3S6RPNZX1q5dsbp4LmFHdpwA7ec2CpMvZ1W+olBgZbz+Qpgm/ktV4TUlAeuNVBlBEsqD94VXZUWsNznlcv5FoLcwZ5J5biwAaXf0ro1pzZHz4JAAQJ8yerWDmOC15b/GwE1OTCDZw3gvHaayE4xsVbTTayBQj1hnmoPrzbt9JiP7u3dcI+ENJdjWjOYdrW63ETKIFVsZxPJ5o+46L159JgH3JkuuqdaM1i9nmrGis9WwwynGiOCOxV3Ei3t+pDteCKYqTpSChqCGrxIhfbdm9v2X//Tspd8CQc6LMiQ4YOVhgzmtvY528ZFO5/OyVaDSHo2awOvJ4IHQdtRTSJL30tVZwnnBxiTmduP31WyiV0KjsQjXUs6GNKocIcfQbYMKaSnVw8fkbfLcinUZhTNuWEjNpfyQeRZ8q5LoVmUATqNYRp6PcK6aeNxTTbwiE/nf/5Cv+4T/7hrvDRMxLG9IyyyzzN3d+NBANfc+zL7/k4fYDpk5q/hCAUAv0vVN9p+gqx5g53t1jaHj55ZdcvXxGp3pQpklilGIkV8P61Uue/62/LeCjqgklCgg13VocuSlSp0EfFAjQvbvn/qtfUoejrONCI9oui+okK2HV49sgJpTDQDWe7BxXn71h8+KlVrEYzWIs53W+0qCivXTicq+1sP/wibs//leQioaUa6d1Fk3cdJpwIeBDIA0j1UB7scb4htPDg1Q6ukZyNq2hVCNNTepuN0gwuHOybszIurnpV7jQKnDNsqZu5MFeowTUV5QlFahKKTAd9rpm1ZVvzhAcVsGtmMjKuWEnHY88vv+OkgrT/pFus5V18KgmGWOky7tmaQ3SNWmZRqDguo7LN5/RX1zKRlPXyQL65L2Ly12arkQAW8jTwLi7p9SCW630WuQzwC1jpGoeqTXSXCUEa8ZgJbC8WwNGwGuS6lPbrfRNiuwDazApQb+mDCdOn95hQyDYcDaKUZ/afaiF6eER1wZs2zMeT9Ra8V1HWK1UnyrXRYxeDXUahbWzjQA9p8BXAeH+3TcaxVXkfXoxh+GM6kqlHKEAaUpi0MHQNIHtq1eEfi0Hj1mxXKv+PKdaWaBmLWeAPI2k6YTfXGFqJj7cyusOgRIz1ncYNPDeAF60n8Y3HA4HDh/e0nU9uRRSjJQ4YYwT3WoWFp9SaEIgZdFWRmu4+PIN3XpN2u2otWK7wPT4SBkjZrOR73FJGL8SsJ0kDu5wfw/TRNNopFNGvpvOC9Ps3DlRohph+ykV62D94gVN10tWaIz4tR7cxoF4OJzNZVVZWNs2GO8Z7u/JMeEbj8FqWP9ACArW/wKm6mHof/y9X/P3fvePxPy5zDLLLPM3fH58oH2/Zm3g9c9/zruvfiGqLN+QkrCMOWemAptVQx4ndh8eWG2e8/z1a/qLNe3FRlp8pgjGkKZItQ0v/+7fZf38pZo5BAzWNAojGjrR7+VEPR2gGkwrD+WHt+94/OZX5GkQosmIIckacZXXDO2mxzWNRk5lqvWEzYbV8+dsr66oSXMj57X7HIpvLDNbZUIjq/Mcuf/6az599ZWs3LsWqwH6xiLNN8bS9j0xJU6Pj7RdS3t1RS6V4cMngg+YMAdxWzGIGCMRTiVjjVPisJCS6iGdpd1cUI3TB24GK+Yx4zxlivKAi6MYo4p0mZdaGPYPOOOgeq3yTJhScMGL0cfMmk3Rec594OPDDucCoe+FGU5JWFPjqM6AEZaSnM8B+4aC7zq2n/2MdrPVbXTUilX9x3kBZN5JlSZF8kBjZDrsqFRcvxFNn5pp8jSJjCIXjA/UXCkGTJXVuwFc1+GbXsB9FLc0xWCaDqyuiucNfUpUHyBGhk/fY13A+lYNWlqVSoEskoD4sMM6i92uqJN8xqEJhM1GjEklP7G6VbXMNWHaXg5TtuphxlFqZffd16Q4YopkyOItwTpqrpJ2UMTZXmKVuCrriZOE5l+/+ZJmtZX7VjW10ncvvfFmzoc1VsoHcqaME/F0xG0vsd4TD3tME6QWNwrILQXRXVovRp5pxGDIOXN895au7/G+w4wTw+lIqYaua1WTXChJ3l/KhZRFL7v5TLJCx9tbckyE1YqaI3WaJKg+i4SllipZqThqnTjtHhkedljsfF6RLYEFgxwaDWCc6DvTaVAzXsKtO9qra0rM5NMR1/ZUKmmKxONBvtPBYirY0OFXa0qFaX8gHkZZ8xvRyE7TSAhq/FOT2591RJ9d+eX7R/6Dv/e/o5L1ZZZZZpll+FMAUXH5etZXz+jW3zONA2PM4uBOAvLaxjLuD5yOmWef/5zLqxuavqdZy0qPasSMUaF7/pyLN1/SXlyry1V/OadJayd1tWqMBIGXAk1LjImPv/oVw4cPOGPE3EMmlYp3GtzuPe1mhfVGmZFEztBe33D1+RcEr7FBuWptpLqNS9HVpj4prGg045T4+K/+bw7v34lT3TuclwzDnCtpLPjgwFbG44FcCm3f0W7XAtD3J5q2Z3bCe+8V2ElWoyzgnyKJcpRIqmbd03QrNa+IE92EIGyWF4YRK6A2n6JkIXqJqYopEdqVrNBTIUcJf7ddO0s1FXTP7UqVpMApNA3WiIEppfh0PYoA9eqMKBmM1JtOMRHWPZdf/FxWxjmdY4LOCNBabRWyoiPMUUDPOJKGvaykm450OgmT6b3k1SYJQjdaUSn4pOKqZMm6RnIsS5xU4qDM01mGIDpJaTGqVOfJw4np/gPGesmrpCpTW6mzVrIa0v4R4wzuckvNlWn/SE2RZrPGGqc/b9YN86TTbHoB3KGRn12lJOHx/VtyHCWMyxhM43CN1mgi95txkMdEnhKu9cQ0EZrAxes3NJsLAdVWzF7GSKQTrsXkiapyC5yVw1upxNMB23a4tiMfD1CS/EyVS5RpkmsQVNeaJiqVaUycbm9pQnuOIqu1irnPO6QYAQGBVkoepmnCGkN3c8X66orp/kGA++UlOSXy6UTYrnFNIyaokskpE+/u8X3LNI4Mj0ecsZKZ6qwE9+cMBZyXtbwLDhc80xiZTgLqbetY3Tyj1kqeRvxqrQkWmXQcqDGrPEQ+6/biEhMCw+6B48NO6kJVC56mhLMG5ySTtOQ/X47oh93Av/9f/K9/rv/GMssss8xf1/nRQNSUgrWe/vKG7vI5n776JTlX2tbTBmkBOtwfcWbFZ3/773Cx3UjncxuE/VD3R8HSP3/JxZsvpLFGQ7NryZAku9C4Rjrj1YkuACIwHQc+ff0Vxw8fCW0QLWA1gMOrs911Ad90+hCeyFPCdh3rF9esX74mtJ100FcFOEZXktYJ81GL5EsaA9VxvP3E3de/JB8PtF1HAZzmkGYrjlvnLSVnpsMJ5xz9ek2z7jntj+RcaLseMGctX1EWK45SNypVnAKgShSnbug7mm5NmSbmBiXjW/mz1lDjHFSPALoqus84StlA0/bUop3mVJwxEqSv0T85ZVyQ6KKSMtM4kvNE23VidKmRUis5CvCxyvw9reMNeZpI00S73XL55guJoFKTl7FG9bzIv0tRgvrVoFRTJg8D0+O9mHO85MtSpXEra+yXVI2KNtR4L2kEpgqgd0HMOUUNT07/b37QL1+yRnABrqGOBwGhzgugd4Y5CL5Wqag11mn1pJNA+yxGpTycCKuesNpoBaf+Y5zoM2vBrDYCLBX4gsQKHT6+Iz3u9B6Q0HmL6omdamyNHJziMOC8pxhoVz2b5y9p1heaCjBn+Irx7ryOd16Z0aeQ9zieqM4Q1ivyeKRMA7ZpqFWkDXUaZL1dMqRMjXLv5Fw5fPqEwzyBUCTKyFthinOM1CLZqtbNFZuJcLWl32w5ffyIdZb24lLMVoeDNhp5+WwQ5lfKBhymCcTdEYqRtAAJVxBzmrL8OU8472maQNVECzFKFTbPXoiZcZok9aDpKFoRm6eJUoqUSTQNrusl33QaGO4f8Naqhho1jj1FduVczgUQf9ZZQOgyyyyzzP/3/Hgg2rRY54ingepW1GLoWkfwjvFw5Lgf2V4/5/nrN7Rti3NWcvu0aSenROjXXL55RXd5Jb/olQ2sxkIUU4Bx4YkJVd1kjpnD7S0P332LyYl+1UmfeZ4bg2Ql3XQtxlnRxGnwuetXrF++Yn19LZE8tQgowYGXiCVjrDqNJeAcayi5Mjzc8vj+LU3fEkslHwfJzzQSXzUNo6yDqxiv2tWapvHYtmUYTlQFoeJoV8c0lVKSuHUVpAGUWkijgL92vaZRkC7VnAbTtLjQys/KCkJr1XW8GGiS1mK6ECg1iQFGzT7W6epVtaLzWjunRIwjmIJvWv2ssgJi+XulVNHQztFLygbmUmm3W64/+xzfreRBPi8dNYfSaN6ssU7d/5maI/E4MO33svoE4jBoSLvXCB6JAjLqAHeuwXovIK7Wc1wVtWKaVjDnFFVO0c07XXGwA9RKPj0SHx/EXKWh+ecKzlKoVQxi5/Dzlb4n7ZVv1hsx01jVBmPkmoLqQ73UhBoxEFXryOOJ48d3xOOjtEKlOcC/QC6EvhPQOYykMZJGvaeoNG1g9ewFoVvJgUydTXauNZ2DCKhqvqpnKcK0f6DWTLO9EPlGnLBNp0lEoj42zmslKtQYBYRWw3B7T6hoJax8t1Kc8MHrgiLjvFE2dDblTfRXG9bXl8THA8ZZ/GZNniLxcKBME2HTY62TDUqMYCzNZgNNy/7THXWMBK8SFGeoRXNsQTWxSCNUrNQ0EoeR4vTgkAouJmoqhG1/lmPUOMnvGSO1uq7rz4ev4faOmiqhbQVMlyLfIbS1qWiawNn9tcwyyyyzzF/0/PjVfNNy2h+5+9XXHL5/T2s9JSced0dqslzfvObqxQ1N28gDrIDJAvqMl0ig1dUVTa9rS6csFFVXtg7jgnbGFwWihvF45PjxA4d375X5kqdv1aBxyQcFozmVcZgEhHrP+tkz+pvn9KuVNBTVzNwtbuYQcIw4i3M+5zBO48Th40fyeKTdrEANRDQNNsjKejwcyEkYHWMNzarDN42sGocBZyxhtZZ1vDq8SyqkmMQbpcHspWhrDwa8pW1aQt+d359rWwHd1sufLUkBrJhaZj1ojpNcMy8aR2Od6C+RbFLrtGc+CwAytRJzJldlEHHaUlM0IilpLakwuaVKAYDTaKJSK6urS7bPn8v7nE1mFdWFCgs5FxAYo6AmjsTTQBolykciq+aIISuyhFolNsnJet00AYBqRUVsvdf6T3duthJWb4LgBXymeNZuUio5nkjDUQCxmtDOfeVVjWJVmL18Osp1jRF4KgYIqy3GNfoz6zmWqwLGN6qZVRWj9ZQ4cvz4lvi408+7nGUOUm3ZijFmisRh1FgjqYFtVh3r62c0q40eOgrn0Hrz9LmIuUlkDqYRA1c87slxor24kHuk1HMEFTMQ1YpQ6738/ZzJBY4PD5RxxDeNHPRKPb8uY62Y8IOllqT3viVNE65tWN/caJxSK2bGXEjDiTgM+F5YSkpVMyDn2K79p0+cPt3RzCyyFSd+McJikgspF8nNzZVxf8JY+V1w8fKZGMoGMYi1l1foyUIBeBTlgAuYRiQt1MowDJSCbEh08zLfe3KdpDrY/uuNassss8wyy/yFzo8Gorvv33P4/nvGh3uC84ymJQ6Rvr9ke3lFv+ox3qlxYSZvpC2lv35Ov91gSqLGEbMWVomizKdmTNY0ik7NQEmF46c79m+/Ix72zA3qkk1q9GFTVXepNZujMIKhX9M/u+Hi9Wt8aFUvp93pNoiRw4rLv85tSVqlOex2HO/vpAu7CaKBnZLE9RjLNEXiOMhq21lC43FNwDUt4yCGoaZvCPqanA+SV1hFb1myOsGrMr4UMar4hm7Vyfq8Vqq6yiWiSILIMQanD8aqzG79IQjNgKnnTFFrPcYZBaCy8q9ZqhdTisJSdy3GeLIpEshfCgaJyrHWqSxA9IHWO9BCxW57wfbZDb7rhSkFfYAXqrXnalCJqJSA/RIn4nCSjy00KgFQQGieus0xFlMFhMwr61qytAQZi236c/j9GZyVrCao5syioaxWOh7IaRQtpDHSHT6DjRQBqaQ0tpKHk0aLaaGAqYT1VoAccn1RsDmzheesUPS1OEfOkcOHt0y7B62dLZgq621jODOxlEzcn/RAIvd4u12xfv6CsN5KNilVwuYBFPydvzPK1uKlmjWd9mAr3fWNrNRTxLbCdNeZCQVx3BvJYC1qOjvuHph2OxrVUBf93sxpaiWpzIFJZBrek1Okmsrm+Q2+7Z9anGohHQfScJLvR9dRNH5rPkg553i8u+XwUWQAc1astY6KGA9B0iWarpeDSSli3vKV1eUVXS8MZ2gjKU6kccDanhoj+XSklCRxcs6d9bzxeGA6HDGuwYdAmaazKQ5rtTBB7nljjMZDLbPMMsss85uYHw1E9998pQ9ri28a1hcXrC8vaLqGtm1wzjFNSVfVldp4musbVtc3NE0QM0Wt0G4keicrWFB2qqZJQQXE08D+3QcO799Djmf20iAPP9loKxidydOcKUB/fc3m5Su67Vb0bSkJ0zlbcLWvr2ojEHOLUYXDp1uG3R0WCE0jRock1Y2mlZrL6XSipIjzjtA2OO3mnsYJayy+lwB7ewYMAoaysk4GiZYyQDEI6HKWppc+dMmutLhG1sc5Sn2iNUjYt/a01yJB/lUBpgGtRpyZYmV7UfMOGk1UEqUKmxTaRhi5nCXCqUhSgPceqwxmzuUcCVRiguBY3zyj317imkaD+MsZGJ11i6rhKyljSiKNR6bjScBg02gCgEbyMAey6zvRPEuj10kvqEYluXNV5wz8qt5Lwrjp9dC1ctzvmA6PuL7HeodB5QqarmBxwugFab5K4yjgq1ZqtTSXNzjNz5RrLCxtnYP1VfdLnaUMwlwfP3zP9LjDhkb0lVlW4KVUTJW4IVRbXM85oxIL1d88w/cb5uxVYZQTGC9bA4PoZkt6ymJFAJYxlmZzRU5yKDNtp/dg1r/zQ8kElGkC5znePRB3O9xsLKuShCGaVrBOgH8cRjWTOagJHGyfPaPbXkgSRC1SGzqciKcTrm10MyCZncWgemXP4WHH4/cfBIRaqFYBozHUok1WKQoA9fKZl1yottKs17JdUUDsGk9jVwwPj+w+fCAYKwdfKkKIekzjSZOw8W1oOY0T0QU0xVYOGFXgeqnCABtjcQsQXWaZZZb5jc2PBqIlCmviQqCxFt8GrLN4ZwWMlSqNSrXi12vaq0suX38uUUGa/2n7tWRHZgniluzANOMlwHLaPfL49jvSbidxNMaSShUwaC2mVGGgrDyMs9Y2Yi39zSVXn39Ju94ARUGoMqHoOt55/d/C3Mxk2sP3b5ke7jTGxlJypUQ1yTSe4XBgOor5wYcGHxy+66QmNCdCaM8tStZ7nIatJ3Vzl3kdqUabWiWFQK6jsEBUYcpskNzSPI6AxTaNvp9MKZlqNPLGGMleRB7axsyd6comUs+JBBhhgLPqb70PwlIq+wcVZ+W/4WZwmESraK1VjOnYPn9Bd3GFes9E1qDMkaJlYemigkPvKVNmPBwlB9QFTSwoZ6bQGqNVlMg9ZkWrKfg541wjK3EFUEbD+p8cLQkTguoCzTmsPO4fmPaP2LbVNbgjRzFElZyxoSEOoxiwgpMosJJFguAd7eU1tu0Ae2bFZvZTSGCpiUTvZaOf7/7DW+J+L85vQZ/MsUpmvv9qIQ/xSZ5SpSFrdXNDs9qc2VI5HIj2U+57i6lZo8dQvWkl7h8gtLiVxF+VccD16ydZhKnnXnb5e1BixDQtu493TPc7vLXKiqO64iD3pNj8iWpmmll6jGV1fUO33kguak6kcSSdDtLEtV7jeslxLZOkPljn8G1g2B/Yv3uP16zTgtEDxvzLQBu4zqH5We7dnPArT3+x1j8mDUtzO5kPDcRHPt7uuHl+hXOOXLKkR+TIdDzhmhZrAyvfMJxOVOMIfU86npSxNjgrkhrnvehZl1lmmWWW+Y3Mjweial6gFmX1rHRAeye/5Clka2gvr7n+2c8ITYvvV5RppGKw62sBHnE8a+yoGeIobAmG3fff8/jue2qa5AFlLTnls2zLzj3YTswGaZLQe79asX3xiv7mmay24ygvutYzCJV6Tvv074pAotjyAAAHUklEQVSEwE/jxKdffUU5HQltIxWWacJaccZLHueenDJN10h+J5rXWQ0GR9MGrPVAwQZd9yWpDMwpa0sTErruvaz7S6FbXej6WR621ltZd+YkTFWVB7epVRiuXCjGkIbxbDaaQeg5B5VZQ6gmG6HUqKUyTZNoP60/N1tJrSN41U7WCinP4MfgrMgK+otLti9f44MASeP8+XVTtP0IbffJWVhNJyzjsLsH455igyzCyNWi6/8yox2c86IxplJLxDUtTjNCzSzD+EEYv1ScNk+Ab86X3O+Y9juJLgqqH55bcnKRusxxkrz5Nuh1qlKbaQ2+7XFq3sIgANI86RuFKQxynXJSqUDm/puviKdB0hBUe1jhrEeVPHbpiw9B2r58Y6nV026vaLeX8pkoUy+GKLkX5dQk8ha9OTBUpuMjOI/veso4QpwEhFY1+VjZIFSrWmhbKang+jX3Hz4y3T/Qdi15HOXPq/bZeivgtcI0TZIH2vgz29xdXtFtL6g5k457KIVakaB/J1rRUrLm5Ep+rWsC0zCye/uO4NyZDbbGYKtVI518P6gQQgfWMA4DOU6EvuHi+XPR3KZ63pTUqox9rqw2GyiF3e6RzeWF/JxaGR4P2CrAvJQsutZWGsPSNJ4PVRiLsxXn5Z5MeQGiyyyzzDK/qfnxZiX0oaYPYmdmpswI7gmB7etXXLx4Iw9B66hxoIwHTL/VCsuojJIwQrVI20yKkbuvv+Xw6T3eS2C45F9mTKpYinSAq16rxCgOcwzNxZbLzz5jdXkj4GsaBCyHVp3NmgFotR5QY2ZM03G4u+X2j/8Yp47aUiCNEWetxAlFMT5ZbzC2USZFjQ0FDBkf/LllyvWi8Swx6kqds+bM6toxZWFnutVGrp9FgslVapCjspR5rhnMVA2tz7lIRmI7u4IF/EnloSoQDGp+qmczS46RaZRqQ2ucajOFCXUaqi+gpZKLSCt826hDOtJdbLn6/Ethh6ZJDhKhlc8xJ2ELixQPiHvcylp1GjndfgQqzWYjZqisOZRJZB51fuGaU2u9dpdn6Vb3q835fZxpRwUL1QBNK4AsT6KrtY5pd8e024lLXGtZS0z612ZWXCQFrlspaC9nA5TzLbaRqCy05QjroYhpZwbAoGYhKjVndu++I4+jhqIb/cwyJRW896IPrpU4Jppe8kutNcQ00W4u2Lx4Dao9FWZ3ZppV4pGiXOMq4f7USjztMT7gV1s12yRs14iUV007s3wDjSbKU8S2PcfdI9PHD7Rt93SIUVmDdU5NSgLga6k0XhjsmiPh6opme0E6nsgxEtYrfKtVp85AQQ4dKQtD7eQgkmvh/tdvZT3vGlKcdHuQqUhLlmBwi/dOjEtaNOGawOrFM3zoRNJQxbWfk/wuqYgEJk6RzfPn2MdHbt++Y7Pd4McRU63Gf4npzXmrWvGCDY7T/ih5vykKy+od4/7I7n73Z/4Fu8wyyyyzzL95fnx8kzJWxkETBLyUWimlUpzl4uVLNq9/Jg/6CiZF0uEROqm3nHuwhY3UdXmpTFPmu3/+z8nHI6vLjQZLy4O3VGH02r6jzlrLmASQYeif3XDz5jVhs8XYSjkNahZphCkDXds71VdKPztNx+2333D4/juCa3RFDFHDxr0yZLlkfOMI/Zp4jBL+3TUUoKYoneDK3LogICoPEyVOFCTEXOKXBHDGFHHO0m0uhCmr4lo23kvTToxnvaNRk4oAHVSfemB9fUOJSTR7alZCQ9zFaV/OpgtKIY8TKQk4wigTDZii0VracW8QnWytRQChs9Rq6G/WbF99hrFBajxncJSjgjFm/5KCNYmGKjEyPnyEUuXzUcORaxtSivJ6qtRDWisFAWIuEjmFDwG/uhAQOjuXCxrCr+9DwT1F456sJR32DA93NNtrZWkR4KbGl1k7W8YR13fqfK9SopAz1gWMtlZJnBfClCUpGRB9qMoiiq7mneP2u68pw4A3AtbSEMX0QlWphdyLcZrkfk4J0zWkcSKEhouXnzNHTs0ebWPN+eeUqhsEY7RyFtJpTxoGwsX1+XtlvKdOsnIX6ajDpKirdHGG26ZjHCMP33zDer3VCtgqvesGnBMnvGibk7D3TcA7xzBGbNOyvroiH0/UlGgvt7iuE6Drrd7bugkwukmxov3dffc9LoP3LQVlig1YG/QeqaSYz2v6mgspjsQ4sX3+gn69IU9RSx4kXqzmqqUVmWn3SNheSCFE8Ny8esH+/oFaPF2/kvunoNsROaCEvqXVg0JOEDa9fLYxcTo8SlnFMssss8wyv5ExdS5AXmaZZZZZZplllllmmb/EsT/1C1hmmWWWWWaZZZZZ5m/mLEB0mWWWWWaZZZZZZpmfZBYguswyyyyzzDLLLLPMTzILEF1mmWWWWWaZZZZZ5ieZBYgus8wyyyyzzDLLLPOTzAJEl1lmmWWWWWaZZZb5SWYBossss8wyyyyzzDLL/CSzANFllllmmWWWWWaZZX6SWYDoMssss8wyyyyzzDI/yfw/oTdI4Fe5yskAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqIAAAFUCAYAAAD/Il5qAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9Wa9k2ZWtiX2r3Y3Zadwjgkxm5r11qwD9H+lFEiAVJBQgoAToXfWzJOhX6OXeUunmbfImk0ySwWg83E9ntpvV6mEus2OncQ8PklFZUNokGO5utptl28zOGXvMOcZQtdbKuc51rnOd61znOte5zvU/c+l/7gWc61znOte5znWuc53rX2adgei5znWuc53rXOc617n+WeoMRM91rnOd61znOte5zvXPUmcgeq5znetc5zrXuc51rn+WOgPRc53rXOc617nOda5z/bPUGYie61znOte5znWuc53rn6XOQPRc5zrXuc51rnOd61z/LHUGouc617nOda5znetc5/pnqTMQPde5znWuc53rXOc61z9L2c/d8Ob99wAodXhE/vIkmEkdHn26zV++6sl/T8/2sfPV4xafe+wX26pXTvinHOfV7T5nm+eLeP73x20Pb4lq/6mnh+Bkl8N2bUN5L+uzjZ6d/8nBf7yO567l9GTtyfp0u9MdlDxfT7a7u7/n//H//H8RQsAY0w5RCTFBrThvscZCVfjOUius64oxFmM0tVactSilUFoR1ojzFmMMCkWtsrxaK6VWaq1orSi14q3DOctuP1EKXF9tmecFpRTGGDrv2U0TORecs+SUcc5irKwzp9yOp4/rLqVgrcU7y7wE7nc7+q5jMw54L+cDiDGRUibFJPtR2GxGtDLsp4n3N7dcX1wwjn17jY7b+wdqLVhjAEXfe2JMdF3XjiufEwUsayAlOXbOhVorxmjGsccaS0yJ3W7Ce4dWGmM11hhKrYQY5e1SCqUUy7rSdf7w9hFCZJoW5mXhyy+u8c7hvKMCOWe8s9zf7zBWrtk0z4xDT9d1lFJxzvLh9o7Oe/rec3/3wLyuXF9dYozl7u4erRVffvkWozXzvHBxcUGMgW+/f0+the1mxFlLLoU3V5fEnPnjN98T1sAw9HzxxRvmeSblQt93hHVlmha++vINISTefnHN//p/87/9vA/8K6XUz/Vz8FznOte5/pddnxPe+dlA9Gk9/mB9DkzbqX/i8X4KUHy59afO1qDMjxz5x89/uJjqY9u9WMxP+eXzEowe111PVqfqs31eO87LM6sXdwgvgfzrH5bDuk52Vj9+1V9eTUF4Tx4/gMyTMzweUT15/rCKUgo5Z5SCXDJKKTrncc4eQaS1llortVRSzvjOCxirAnyUURhlCCEKIKoVpRTOWUqR/bx3R/CVcsJZR04ZYzdcbjfc3j1wc3vPZhzQWgAYCi62G9YQyCmjtSblDIA2GqUVKWZqBa3VEyBdgMvLbVtDQSnYTzNaKawzWOvksiswxlBTZd+AoTWav/rqC0JMlFJY1oAeNFcXW+Z1wRhDCImUCs451mWlloK1hlJOrrhWeOfbe6GYl4WH3cTQ90BFaQ1KkUvGKUPKcv29c+Scj+/RNC2Mw4Czso3W8inwXt6XkBJ3Dzuury5ZlhWjNb7z3N/v6PuOzThSaiGmSEqFUjLbzcBuP9N38l6XWvnh/S2dd/R9x/39jt/+9mu+/PIN1Mq7d++w1vJXv/iCDzd3TPPKZtT0vef9h1u225H/5t/8K95/uGVeFobOY7Thw+0d0zQz9j320lKVYtz0lPY+nutc5zrXuf7y9ZOA6Ot39s8f+2mg8i9RrzOh9RlU+tz1vNzu+ZH+svUagFdP//nqPp+A4+r5tqd1YBnbs+ozqN4Xpzg91wlL+vxMH7sT+sjDCqgfwbkHoJNzJoQoQKpWjDY4Z0kpUSrUkIT9pGKMwWh9/HxobVhDZDNYnHNMy8LQe0ouKKcoWVjLaZowxjCOPTEl5mkVMLSb2IwDFxcb5mVtV1KjlKbWAlWhtaaaijEKa01bc6EqcNZQAasNWmtKrcQYmZeVzWbEO0eMEaUUQ9+Tc4YKKSaUUk9YVKUUsYFPqIzjiPeWNUR++HDLl19cNZBYMFqhVGWeZ7Qx5FxQSqGNQqHRtZJzYl2EzTyATIXcPORUoFZiiFhnSFnYbWu1sMlKkXNmGHq888zrIjcDVHl87DHaEFNkXQMoxf3Dns5bQgh0Xcf11aVsnzJOW1LOdN6Sc0VV8NZSgXEz0nWZzWZkt5/ZTzNvri9ZY2INkaHzbDcDtw97Hh72gLDi8zRzdSms8cP9Hucs1hrGriPlglKVzdiz30/sdntSLqR8z5vrbQPj5zrXuc51rp+jPhuIPmLQvxQoe86Hfe5eP3b+l8+rkz3ll+uBOVQnW3ysLf3aIycM5umun8LpL5b1+PqPbOsp8Xiy7+ss7DMAe9o9f7KFLOxVZlg9ruOxPf+ptb9y7U8e+jEKXr3kPV8epr5ka0+300ajlABoqzUppScHSSWhlLTEY8yUUo6t9847nLLUIq1nawzrGmTdCowWcKu1wRhLzonOe2qphBAJIeHdY5t/nhf6rsMYTc7yPh7a0qUICDswtSlllFY454gh4pSm8w5FxVpLjFHGC6wll9za6E5a+VXYXeekNR5TJOeMMRqthaUMITDNM945+t4zTQs55yPw1FphtGaaJpx1bDY9KQvDaowhZYN3Gq3l/6VUUBmoWGsIMUgrvTGbRmsZF0iJw2c4hIRzBpdtG0MwaKWlna8VSSmctXSNpX542OO9jAzEmBiGTpjUVCBnKgqtQWmN9+7YSu+HHq3kg546Ty0FZzW73cTYe9aY6L2nVBkzGIee7XaDs5Y1BFLJPOwm1jaS0I89OcmYgNqOrGukA0II3N/vSenMiJ7rXOc6189Vf2Jr/sfqT2VDP8amfgzgPEVKx/FF9fTZUyD2fKb19LGnhO8pYPoEa1g/tuanh3k8x+cOm/6UedYf2epkrvP0Gp3i53pKk744/Y8NP9TPXMrjOoT6fAY6n4HQp8BW5jZzysQGPp1zhBgpteCsw1oLDVxZY4ghUYq03mupApoUbU7RYq2mVk3OiRATQ2fae61kNrQIwLLWUJSG2uZI0ceZyNRmQWuVmcvY5jiN0cQoLWvvnjKY1hhSTsQkM5CqCKgNIdB33XGO9MCOHv7vrEVphVKwhkCpFWcNBoNWipwLy7qy2QzULOA15jb7mSqutwzDwLKszPPCZrMhhID3HqM1tVSRL1awxuCsoQBGazbjSGjnNKqyhoA2so8wtZW7+x3X1xeNhYaSyxFIx5TQSmG8k3XF2BjgJCxrSsxzpe87lAJjdLu2jmHoZaQA2O0nnDVYZ3Ht/zLXWqgb0Ma0j5dCK8NmM5JzZl0DCtiOI0ppeS2lMk0LcEPfdXjvQLUbhyjnFqAcP+fDfa5znetc5/oT6icA0Z/Slj955KCIOO5xykJ+fL8fW4d6wWC+tt3Hn1dPF/UIGE/+ccqAPseb6snOx82e1VOA/Poan4LTw38/Lrx6etwDeD7uXdWzrX70ME/fCiVzqc8O9eq6+SQAVUfhz8vzPue1nx/n2b8fkSk5F1ITJ9V2ARTSGlYIOxiRGUzr7PFczltCSJRcCAh41Vra6sbIvOQaAgolDGcS8FdKoe86AcFezlFrFUbOGMIaUQp854WtRcmfFfq+o5RCKSJSOjCfMk7gmKb5yNh659p8qGJdA77Nr5ZSj2MIlIyuCmMNGzceBUZaKVIuOGspoTzOXnpPrztiSkz7mWla6HuZs0w5U2vBd56wxnZuQaGHOdbSrjfGoLViGDpiypTWutdKoZwh54xzmq73LMsqLLE2lJLIOdN1Hq0EWBqr6a0VoZcGjRIGsvMy+5uLvNb6CMRDCFhruH+QOdIDQ621xmiZRd2OI8M4CCgtmTUknLMCfo0hxZn7hz3OObrO0XmHtQaopJTJpaCNbiDcklJmP0188eYKY/7nGzM617nOda5/afWTGdGXbd/Hf31yp09s8pzJfFmvwb5nbOiP7Hd8RL18/CDmOarGP4a5PxsvP93wMFtbG3h6bQ1P9jqwk8dN2slP2+8/gYF8nO1VVHVyvdTjKQ4MqTxXT3d/5fxPQfNHz/4xEvn5v56D0PbnK5yptOW1wliLApZ1bS1txxwXqBXVKaZ5FjGNd005DkMDhsaY1jaX2chaEVDmHNZJ635tyvxSCzrnk09bJZeCdVZazsZAA4NriBitjwBUG41zlrBKK/0gbJK/a3zX1taA11rysZ1fSsFozbIGBuXJpUB5BN6uAakQIsqY1qYXUVRtIDvlRAnS+h+GnnmeocoIQs6ZeV4FrCOjA1qLiEkbEVZpreQ6aE3fdaRS0EqTa27Mr7TwbWOEtVJsx5E1CNtZq8yFxhhx9sBeZiqVcRxY10CIAWu0zK1qBch5KxWl9LEFL8BVE0LCWt1AqGZZVwH4OaGKYrsZRdRW9szzQtd5+X/fkUtht5/o+w6tNLXSrsvSRgvi8Rpqrem8J8YsTOm5znWuc53rZ6mfBERP2a0DW/Y6//aIPD9tXfIKg9r+q45Q95SdfHasZy3ep088f+QUuNYf2fYje38WMfICZr1AZELkPV/D4/Tq57i9HJnQ01b78Vo8PcAjfn12nZ5jwOeX8hR4njwueP3kOqrDu/M4AvFRgHrCbj5d2wkAPm5Sn7z/Ak5Ua9smATfWkUultwZtBJwccHxM8dha11pjjbTIcykycxgi1mrmZSWGNqfYd1hr0cZgnSFnxbqsGGuOivxSCrVotFNH1X0FOu8JIbAs63E7rWWeVGmFQWGtbUyciJaWNTD0HcZW0pRIMTOOvcx1tnnYh92ey8sLUkyNOVTM80JK+gharTVNIS+zo957UJV5Wo/zpsMwUBtD65zDO0uMma5zbQ6ysiwr49iLVZPWHD5Lxhj289Tmaw1KC/B21lJypSoZL/De0XU9to0jlJob0IeSc2OfZXbz8nLLw25PWAPWmSa8Uu09rHgvny3vHfO8YI1hMw4s6ypssDVNdCRMs7T/5X0QFlYY7dAEbBfbDZUqILpUrBUG+GK7ESYVmX1V6hGI7vYzm9c/yec617nOda6/QP1E1XzDDy+66h9hER83eAp6TgDPQXjyZNvPnTE9OaD65Bpe3+355i/XcYB1Hweur8+XHp771Nleq9OG/PNW/fMjvVzrq8dTz7Hfj9LPvEr/Ppun/fhNxMm/TknUH2GUT1nYevAcfXZspTTGGtSqjjOHfdcRYiSlSIiJi+0G7xxKKabp8YQpZRHg1Ip1YodkrCi+N+PAogPUysNuwjvHdjvirANkHnWaFi62Bm8tMURiTNL+tpYQE8u8sq6rKLHHgRgL034WBlNB33UCjhowjSnJp7ZU9o2lu76+ZL+fiSnhnWNZhY2s1srMZ8x4L+DcWQsoXCcgTECctNTneUU3FtN7d5xbtdaQksyv6qLEC7RI+38YelISv9IDkD4IsWJMj9ZYRRj9ruuPDLBSihSTuBKskZvbHV99eY1z7sg0phixzmFyaYxywUbDOPQyT1rEBzaXIoDW+daGL8Qk/qf39w9ybu8F9Ed5H+Z5oZTKsgZqrlxcyHfZWoO1HfcPe+ZlQSHzwcPQsa6i4F/XiB3FV/XwlTDGMDYG9VIr8ak917nOda5z/Sz1E1vz6hPq+cf286HlexCxfBqCPR1QfN6N/tSs5CfZ0hcA8MdZ09efO6jtn531s9v07YgvKNXXGeSX5ziFoo/rOwI3BTShzNFs8jl7+dpiXxNZPd/22SV6AkJfBbInzf3np3ze7X92ipM9n/x5wK8iuElM0yIiFWuYlpUQE32bQTTaiI/lKHdMm7EXw3UU3otPaIiRMM/EGPDOYYw9sowpJrTRlFzYTzOhtZRzEfB0e/fA1dUF2+1IPBFNhRjofUd3ecHt7T1dJ+KZfuhwzrVrVwgH8Nm+F6EBSO9FaGWNQW0VH27uRNhUC6UUNsMIqrKElZji0RaqH8RWKIR4VOz3fX8UTVlr8d4fxU+inpeZSmetAENriTG1uVRLyQWUouTCNC0YK7Od3jveXF+xrsL4hhhbS71ijaLrPfv9zLys5Jx4//6WN2+uAJkzjaWQm4I9tfeRy8a2ak1IKzG219B5QLEuQUCz0fS9Y7P5BXf3D8dZWgVsxoEQrfh/Dj0hBH73h3vevnnDdtMxzQtQ2YwDa4iUCjlXrq8v5TVYCwoRUK0RbfLx+vR9zzLPP/Wrfq5znetc5/oJ9ROA6MuWL3zqoeeMmnr6+I/1uj/60/9zGcaPU3Avwe3Hj/l829eSpA6tx+MpH0cy5QiHLvZhtvK1ZT1rfz9F5E8fFyDzGrg8/OfH2dfnQPfUDvTV8KMnh1RPTlNrfXm1T1wCDkDyybmfHLwen3/esD+057WxKGNJpbC/23N5uWUcZM5wPy3HFvOyhgbqNOsajrOEuVnwdI1pzLkQaqRWUUQ7Z6jNlkm7k6+FEqAnHpOzWA69vWrm+oXOO6oTyyVvHFfXF9zd7xhaMtA8Lw0Qim1TrU1UVMsR+FIhrIGohfH96su3rCESQ8B3jhRlJnMcemmz9x0hBHa7iYuLDV0vgqOH3Z5lCThnRMTTmFDBvZXSbKG894QYxPxeaa6utghgzBgrwiS/ccSYxVu090zzwtrsk66vL1nXlWUJoBKpZHpnubzcst2OLMvKze0Du/2Et67ZQRW89zjn2ojD/jgzXasIwtYgFlEpi29p5x2qzbPudhPX11dcXW7JubbWvWcN4cjeppS5vNjQ9x3LspBiQGmZG1VKUWVagVIK7z/cYq2hlsoXX7yh1n1ryT/+lIoxcnG5bcr6c53rXOc6189Rf4Z902tArz4BMYLDXjTAX+zz+uOfPt3nJSa99uznzKx+fJsDYDsyda+tr/L65eEl0HqkCl/Qj8cTPmENj6iXV67ts7b5cZD0xcV7/hdejhw8e76+eJIDUDxprJ8cRz0hZ1/jdStiAs/pvOwToC/HzvOeuz/+hu//v/9v/nX8jm/dpXhxOhHsDKMwYbVWrDFM88xm7CWmMyUqAkCVUqScGXoBLbUWlFFM84TPHu891imWZT2q3EWo46kFtpuRZV25ub1HaxEiHVrna2vX933H0HXU9r8YRKhUSsF5x7pmUsrHeVWFIuWENUYY33mm7z191xGDvHfOuRZVaug6T47C2ClUO5bMSiotx9vt9vR9h28iIhEw1TaaIFd+6EWksyxLs3A6xImGNndajwS73PeIgCvGyMPDA8MwsN2OzNPCNM+sVYRP8xy4utoyjgOlVkoWVjemxPsPN/zyqy9QSh2fT63tXStHK6a+88LyAvv9XhwQrOHdux+4vLyglEJKCWNkVACUgG9ruLy4YBh6pnk5vo/zshJjZDMOWGvZTzP3DzuuLi9wznHfWNaD08J+L1Gt4zigjWXcDJzrXOc617l+nlL1c4JAgdsP7z5jq0fG7/PzlT8F/j7nOT6xzefWpxrGr82vHlim9oj61Eof93+80q9s/ZJSfDz44emPAsiTbV/d5tl2r+DPI8h9fTEny3q6ro9Gg9an8PT5eZ+wukdmVf5TcyTNe+Z3f+DuN/+eu9/8B9Ld91Ay1Rruo+ZdvWK3/StW01OVxjp3PP5+mum9E0V7E6xorQX8NG/LUstRlR1TOrbIvfekmMiloFB0naOimgG+CKFCiNLmb+rw7XYEaouh7ChVQE0tIrpz3rKugXlecN7hnQOqzB7WSj/05JgJUXw6AVlLm7GMUYRExhjxUY1JfFCdhUOUqXMsIdD3HdZopmlF60PkqQQBWGPEviqm5qFaZdYyiVDr8H6EEFH6AMhFCR9TltelxbM0xMjV1QXWyms7zKimlgZ1cbE5+pq6JvRa2nYKmZm1znJzc0eIkVwKX7y5xhjDGlaosvaYEsu68uXba/a7mdJGEEIIx8+MsSLOWuaVmATU931HyomcRBi1xijrMLb5o1be/fCBcRy53IocSa6LEZ/WJbBvAqkvv3zD/+5//398/fvwGXXOmj/Xuc71L7V+nqz5T4pOfkSR8uomnwJjn9r3T/zhfhwJeGSHPn28V/vooA7s3vMJ1ddfwNNH2z4n7fDX1/jKwx89A09fz4sO/TMQqh4ff7mGz7g3+cQQaH327+N5nh+jvc5aCiUF0vzA+uEbdn/4B3Z/+HvWH/5AnPagwDpDtYaUMhc68cZ+YEozt+ot77kg6AuU99QqghTV1PO1tYRjjMzTQte5o3AqxkhKiXEcyFk1+x5D1wmIOaQp5VJwzqC8b5GZBkURoU2bLfXNmzKm2ARJDfDmTC76kc3McqzDOqd5gQqbzUCX/XHeE1oak4JS8nHO03ce2/LWjdZUVVGlMK/iHRpDJGuN91Z8QWsll8x+P4l4xwiLK0KichxdsL2wyjFGhkFM9bXSxCjMpPOWFEV9rhCgvN/PbDaDzOg25nEJgdzETX0vYqeD5+g4iMCp5Mzt/QPXVxdcXV1we78jzQvzPOOcP65NbLFEnHR3t6PrHE6bduyeUgvTNJNDBhTD2NPXSlzT0Yop5UxtIQIHh4F5FY/Rt2+u2e9nsYBqrPLh5sK3G5mUMx8+3P749+Fc5zrXuc71J9VPB6LPWLtHXPPYkn21G3/acVWPgo0X9Smw+RpmrB/ZpZ4c7Hnb/HOA1ovFPDvpR4BrrQeQ+XjCj4PNk+55e+w5Fj8dAXgKXNWzrZ6e6/XVtROcnOHpudRrcPFxy2fjAy9Sqo7Y/mlD/unf2hpyJoeFON2x3nzH8u53zN//hvXmW/K0o+SEKgU/iJCIBsSME/9QrRSuJt76O/7NULi18D5v2WVLVBBzZug6YoysIbTll+Prcy2v3RhDzZXOOdZaCet6ZNs674FKylUy0qsoqg8JTWGJzfsShtodRUJGK0IQIU3Xd20Ws+XQIwBT8uKlvX+I7DxcT2MMzhlyEvYyNwGROXxvFEcmtHPiRZpKaaCzNBP42CyrpK0tc5PSqqZwtJdKCIgrVXw8D3GoWmnGsSdGezTYt42hVUoxeHc0/F/WcExEGvuebDOlVkIIwjpbDUpuOLQCZcRr9eAO0HuHkjaKsMIlN0GaxSoRUyWVCTEz9sKsQmUYBvq+Z11XShFxlW4JVCUVSi10nW8eqY8JVX3n2e33lAJXl1v20yxAtdlgQWU/zeRSuNhujnZb5zrXuc51rr98/RkzovXZv15LA2qK81Pw9FrL9keA60dPrT6y7fP29Gst79NZxlfP+ZGW8yuPvQSaT1/Qa4r5A7h8CexP1vPs1E+Yxo+u6Wnr/OnBToDhK234483ByRzA06v1cZj64pqfVpuFrKWQlh3h7gfWm29Y3/+B5f0fCHfvKOuemjNoUUlrbcGLeKRmafuWUikZtLX4ocP2Hr/Z0G8HfqUUD7sH7ubK75bCD3mg6o6sm1m64tiSpoJqAhqjBaiJ+EWENSJmyo0dHI7+rJL6U4TN9MKa7fYTAOsaBLhW8INn3s/knNmMAxWISdKIagOQpVY2Q0+nPGVdW5pPM1RXipxKm6XsWRYZH5imCWttm4+UVKhDRjpKiQF7Fo/MNRfuH/ZsN+PRF9QYfVzrPC/tGEWU/VXAvXb2ONf5CBgz87I28A5ziMc1eO8xVvxOD0yw8+74Sa6ltfqVeKCCIrZWfNfcAiR+VfxPDwKmnAuQxXxea1gD2il850HBNC/s9nsutpsG8sXXdJ4XsnNY6+i8JaR8TGiyjZU2xjD0A/tpRmvN0HdHu6daZS3eCbstYq3uY5/6c53rXOc6159Zf3bW/CmLdvzlA7RB0SOAenVM6pQBfA0ffiZxWZ9ivB9d8SefenX/Z6D1R072seSkzytBgq911Z+eryHGZ9fttXm0j3p/npjSP2W2X0Zw1sNJ6qOdVX2Nfn1CsRpQkNeF5f3XzN/9E8u73xPuviXtbyjrRDkkCaWEAkynsV48MlG0+MpMCQnjHOObLf31FX7sjq3vEgJhXii7HWOM/BsNX+mB27jjtmy41yNZW7xSx3lBo01T0kfGsT+yZRVhS60x5FJIWdKOfOfQpZByOQIWpcW2SJTYVRg/I6DWOQsV1hAlHUiBaRGah/a7aXOrNqfmx+lEJAQSWaoVaX2cWzQtgSjExGh6NDSPzxZLWjJGawqV7XZEa30USmn12CKX+cl8jB8VllM/ttG1PgqbZHbWoqjElCXbXjV3geaJarRcD2PM8bEDmDyIpGIKR7B3WMc8ixWXNroBRLHOWkI4Ku0ldEBmTEvJpOYpeohIPTw/jsORCUZBShGlxB/VO3N8H8QSS+ZMc8nNhkpYbqUknlUbzeAsffXcP+yPDPm5znWuc53rL18/EYi+RkU+gyzPab6P4bHTVu6fWs962K/jyBOG8MdO9uT5l+jqALNfELjHQzdjfZ6PLLzSoj5d1gljfPj3Ezuo4w7PmM1aXxzvJbivJ6v/2KjBs5f9EZL1hMd9WYeHW357SZHl5lv23/6G9Ztfs37/W9LuAyUFKJkClCIATlNxncX0nXhbGtVAUMU4xzB2aN/jhgHnLSpncoqsux1hJ0xqrYWSEylndC5s0kpfb3hbHbdqywf3hr29IKGktW5BaXl/QhRj9gMbKRnoImha1xWAFBtQrQUQMJVShiopRUrpI5hRSli2aV6OyvNlkXbywWR+XVbmeTmyefvGrBqtUW0dhzcjZxE/GWOojsaqpqOaPOWELEUAcErCNh4SmnLOoDke03uHimJblUttYDVhrTuq52sDbKXIKEHfd9icJVlJa7Qxx9GGnDMli51V33dM03w07y+qoKuwkfOysNmMzbuz+YtGScgSEFpRWh+P6b3n7v6Boe/wnRdz/BgbYy7gtRQx6qeCc47Liy0xpfaaZKTCtGStnAWoL8va3BM8OcnNQ98cBlLMzUVAGGSjxdD/XOc617nO9fPUn8iInoKiE3hUnz7yEtOc7Pc5rfefVB+bb1RP//qxY/+J5/zxQ32sHX547BOHf9G7fzS6/6gQ9wDuT2dBX2UuTx/7nNiAkzGHU/Dc9tfWUHJmvf2Bm9/+PXe/+Tum739D2t/iVMY5DaW02b2KNhLJ2Q0drnfYzot/ZxHLpVKyCHs2W4Y3X+I3IzUEwrRn/nBDSQ1IhURYgkQ+loIGapY2eGcUXY1s1D2/0Ct36Yavw5b3bJmiYeiczCw2pi5lYeCcFbW995ZliVAF+FnrpD1fQgOlAspCTGitcFbASym1sbnC8HWdZ2gzkarNKlpj0NaQSqbEcmy5p5wZnJjoHxTgvpM4Uq0UwzCIQr1KhOnxBkPBsgZiSi3Scis+qkaM/mnrzUWiQw8uATnE1h4vzMtCKY7Oe6yxZF1a7ruMNQx9d5wtPaQ+GSsAzxoLtbIuAtwPTKWC47lsMSzzyjD04mkaBLh777DKMMcVqy1955imhXleuLzYCgANAWsMu2mWqNPeo1DEmNhPEwp1VOJrpVDWtPeqsO4jXSeRpjll7nd7Aawxy/ww8l7JvG9t4LwcBUs5v0z6Ote5znWuc/1l6s9szb/eqn7hJfq5ffY/tZsNn0R0p+3qT0w5fqLUyX+fPnbKhb6+12tVP7rVC0b5c3atLzc49cc/ru1VE/yXrfhHLu6kpf9818b8QSXubnj/D3/Hza//Pbs//D3h/oZaMloL66idxdBiNZ3Fdw439PjtIG3rWikxk9dEjom4RnJKwqilG0pNjJdbwv1OmK5YSDES10haAjmKZZC2CtVZXNf8JWuFUskpU3cPuP0P/DJULvwVd+MXhO6X7JJiWlY6LwAspUTOwjR2xrPdDMzzemyLH0BkrZWqwNrHmMx1leNY50Qo493xPTJGk7LMiNZSKEBtIpqUM0bXY2b6GgLOO0iShpSSWCvlKulSzlp2+6m1/2vLq++BfPTiTC2C9JBEdbBTKo3FtdaSS0U3AVTXd7gWBxpzRuVMRa6ddZaU8pFltEa8VQ/BAEYLWDvky+c1YFqO+7GPUCud7/BO0p1iS42ap0UCB3Jht58wxnC5Hek6x8Nuz36fGYce7xy6zcE+RooKK9oPHeuaKNSjdZfWmtpCB3LJLGuh8x7fe8Ym6KpVEpcOjgQyTgB9/8i+DmPPMJx9RM91rnOd6+eqnxzx+chqPoUuH2cjP9HOfV5/Vp/+tQM1ic3HvC5PtpFH6skjr6K8V/Z/tnd9/sjz47x23I8D0yMkfHbwWp8f5/lrfrb9x85+cOdv51AnV+HIhdZHsK20KKDzsmf/3W/48Pf/lg9///9h+v47ak5Y73BWo63DeoszWhTL2mDHnu5yi+sspHyMW4xzIM4rtQE9bTTWD7hNj3UaSmX6/oNEbcbMultYlwClYqz4exqj0c6gGtsXV1Hdz/vAuiZSLjIz6A1Xfs9/PRSSW/nGf8k/Plhu7wKbUQQ40mLv2O3nJmQRf0ylFEYr8ROtMjNZyuM12u9npnnmzfUVw9Czn+ajYltr86RzMA49JRduW+s55oQ1IpiqRYzed/sJrRRXZisRlDGxLoGLiw2990fGdOjbjGuF3EQ/MWURKZWWeV+h672MARxiUp1lM47HRCPnLBVhMJ01hBDJyDG7BnA776mIZdShJS4io8zDbs/VxfZ4HPm8gLGwLAsPD3ucswxDT9d5Ab0p8f7DLdvNyC++fMu0rKzN/uny4oJ5Xog5YTD0XYdr7C3QRhYKRjVrKSuftYOA7DAnK5Gl4sV6f7+n5HIUJKVUubwcj8fT7Saj85ZlCcSY8e6smj/Xuc51rp+r/gRD+9cbzx9v7v7ITOJn1dNRgMdHP8ZGnp7zU+c/ea4xXI9b/hgQbc8+wZrP11lfOf3nK6uevjMnrfHD9Tg5b+VEJPVM8f76wR+3qK+u8/G4KLHzKWllef9Hbn79P3Lzn/8tu29/z7qfUVpjO4fVGmeF8URrrDMYZ3GbAb8Z0E4si/IaiEs4ttVLzmgU2ltc73Fe5kQPqU3rw575YSHMAgwM4itq2vbWarS1lApxPxGmhZAqOdVHoG0UbvB0m05axrVAzqQ1cB8939YrvtXXJL9lDYGry634dDZRkm4CHaXUMT9ePDU1IcZmsh5ZloVlXek6SWpyVjLuh0EiPw/zhral+Exz277NmWqtHhObKrx7f4t3BtXU3YfqOy/JRQ2UWStt5/08c3W55YcfbhnHXmyb1pVlFuumy4sNuTxGqgoAdUcB1uHDUevhfVfNkko3k/uAcxJZGlpqlIDawzURwC0Z7wJq+77HtMjVQ068VoqYc2OgRbC23Yx470gpsa6RlCLjMGBsm0Ot4KxBKc1+P+E7GZW4urrAaMM8zyilxeN0mlHtusQYj+Kn3ARQtcp7si6BWsVrtu8lQlXeZ45s6tD3/B/+2//zp75Nn6yzof25znWuf6n1ORDzzwainz2D+Vl1AqDq4Qf4x7i8lyysqk+3gNMxgY+B1ZNxyVd+XxwJw9MzHwDfkal8ftaT8330mrx+oT5+vMPzJ6zts3SjQ7vx9Towd49/fxQ1nexzFMm046bAevsND7/7j9z/9u+4//rXrPf3GGswTnLQqWK03vVeQGnv8eOA7dxRhYxSkh60X4lroIQoyUNao62h3474sYNSyC3ZqObC+jCRVjFBr0hCkOscxhqUVpSURfSUEsu0kGPB9SJ+qYgCvNt0uL6jAClE0ryQYySua2vhI4DSbXg//JLvuGCuHtdJG3g/zeJ32XlyKdJKLqWJbERxrVuSkm6G72t7fd4LQMtF8tSde5w5NNbQec/9/Z55WfBtbMEa22YUBcQeUp5iSm0W0pNixjjdmMXMNEmsqdKKeQnH1vRBpZ6ajVEpAqzHocdYQ4q5CXrkJmJdo1hcIXOzIigSlwHfScs7piRzml2HQj5zqUg603YzSJoRInICUdMPXY+xYnqfUmazEZX7fj8xTTPrGukHz9D3zezfijl+LlxdbljXeJxPvbiQ+df3N7c4Z+mco+86rt9c8f79B0JIvH1zdQTOuYhvq9aadV1RKOZ5JZcsrX0vYwYoAfgp5SaEKry/ucUaw3//f/2/feR79eN1BqLnOte5/qXWz5Cs9KkWMq9jp6cS7tf3O939KcXI8SHqC6D4ZKv6/PQHUHvgS0+P9Qx0vjJCefr8iyb88x78y9U8/vk8Q/7VI35GPT/nyQIfidFmxfPKsl5b89Pr3a5PKZQYiPsb9n/4T9z++n9k/81vKOss11JZvvjbv2a8vsAYw3R7T14WlLHYQQRHxlpUqdSQiBWq0qQQSNNKieIV6jcd2ij6zYDxDkohThNxCVQEOOUQIbeYzL7DOo3tZA4xBWnR59YyV0rjOs+wtRhvQQsItS1JKa+RdVqIy9LyzRUlgXYO4x3aGQZruNbv+ddqz3tzzddhJOgRYzT39zvM9QVam6PlUc4ZoIHFeDRF18bSeXdUhdeDsXpOR2P1Ugr7/UItlc2mb7OiBYXmkFO/n2bGQeZoT/1DQ0uE6kxHTpl5mglBmL3NZgAqMUb6rjvenNSm7j/8UBA7JBEjjWMv4DIJ2D+wr6l5nx7mYw9sZi1yC7jfT3Tey5xlFgZ36AdKqeymPb5zwkKmwm6ajsC7awp4qC3PXdN1SYRVVgD9sgbGoWdeFx52E0PXYa1lXlZu7x4Y+47ee0KMLEVeL0r8WvvO88P7G7bbTZtllpnSvhfbpxgT24uReV4aq1vYjAN39w9iS9WspS4vt/ztX/8V79/f/vTv67nOda5zneuz6s/2Ef2cejp7+Qkm8rO6+K+JgtQJ4Do5qPyuezar+fTcz1f6/BwHUra+2OZ0u5fPqhePfKROpwNO9j1yw690zdVhlODHD/nybuRE7n58V0omh5m4u2H6/vc8/P4/M33za5bbH1Cq4seBzeUX+KFn2GzwQ48yAjy67UjYT1QKShvyGkkhk0Oi5ErNiZqFhbOdw11t8dsB4w01FUpMxL203cN+puQiYNMorLeiZi5gOoMyhpoLMSRKFOCimtDEWo0yGtt3mGaoXmImzis5rMR5PUZmWiutbj3I3KruPNDy2LXhqvf89aD4b8LMb24XvokG4xXrsqKsZeikRZ4OaUjNezOXIubyyGdOTN4V1nRYK63p1Nrv1lo6L3nuIJ8zowU0liw3EzLDmASAzUtrnzfmG0XOmaw1w9jhvCXGTIxZLKGsPR5XZj4dxmqWdT2yms7IdU4poZXC95773cS6BBEHGd1a+gJGOQLiLAb0WhNTZFnFmimXzL1SXF1f0nddG/kwKC/bpZTEpkpxFAnlnCR2tDeEEISN9AfmNbPZjKxLYDdNvH1zjXMSxZmLGOePY49tanhrDFpprLPYZFnXVXxKtSHmxN3dPeM4NBGTCJVijHy4uacWsZ46CLmWZeXDzR3OWsax//R3+FznOte5zvUn108XK70GGj/299PtXmzwytGVMJjPz/l6y/wAOHmCKp/YhR5P9zFW8jVh0Ok5Trd9rV55/LXDvgKwn7fITy/Y6XOnZziZ4HttkcejHGY+6+MDJxu024GcJeXo/j3L+z+y/+Ov2f3xNyy376AmfOe5/PINw8WGfuyx3qObOCWnRFoXai3ieemssJ9LZH2YGwjNrX1vsYOVdnrvME7iF8PtnnVZSauY1VMrGGnrW6fbMiu1VHJOpFk8LGvKoAQ0KiNG786JUh4UOReW3UReV2ot5JBQiF1U19qzSmvs6LHeC4j0Hm0szhu0seSYWKZAmife3N1T3u+59FfM17/iXm3IxWCMbcBME4MAOWMPbffagBsSm2m1WCRVHpnJInGitBlM8c08qL2lxX8wq1cNANZaJYoTGuOaRXGPpvMeYwqlSGTnQQmuUDI/uax4HCGklvjUY1ob+mBsfwDS6xqE7ey75gcqa7TWoLU6ph0ty4pSuvl2FrGZipGpibRyTjjvjvn2Gdm31MIaIpuxpxR1HB2wLXY1BPEKXUNEG4XRGu8c6xqaz26htOuca6HGSOc7Ukr0nWcNUURVVQBnqfL4fYjMy8rQd+ynheLkNV9cbMS+al7wzuGc5NYv8yqvUZ9b6+c617nO9XPVTwOir4DQJ/qY11ATz6M/n7GNHznFx+v5ST49InDMtecjDOHHzvLR7T4Opo/7VPU5L+RxP9n5+K+P8qsfWdPrbO1JHcBnSaT9A+vNt+y//Semd79jfvc14f49NQVc57l8e0m3Hek3A90wNM/J1ooulZIjOYi9Uo6ZuCbKmqglk6IYm7vO0W17nLfSdgdKSKQ5st7PhP1CXGIzWZd2u3FWvES1ouZMTpllv5BWUcdro6hVREq2d2jvxaicSsm5iZ8CYY0CUrSIiYyzMh9oBZhpa9DO48YBN3YY5zDOUyuEeWJ398Du/T3rNJHWlVoK28Hzy2vD8IvCbCvvp8A3+8RDtGB7+qEnrIFaq0RD5nSc55ToyXAUOtXK0QbKd17+3t7ilDLe65NxA7kJOxjll1JFNFYksUhr1cQ+8g3LRYCqs/YIdlNKKCMCqHVZZbuUWJYVa40Ikayl711jOlMDxIppmum7js1mkMz7lFs6lID/w5pzynRtBGJNiXUN0AAwVbXXo4/fj7F5ocZmwSQfUdWYWytpWaW02FTXZlWzeKC21w+gtMzexpBgKwB+HD37eW5jA06EUVWDVzK2UKEc3wu57TXGUJRCcVj7IcLVktKfPfh+rnOd61zn+kT9NCD6Cu77CBQ8qb8km/A01/3wi/3ILH5siPS1B18jd1/Mmb6+hs9aZ4Pfj5MChxnVV6nix/1effhjAPS1MYH2d0X75Z/J8z3L+6/Zf/OP7L/7LdMPf2S5+QAl48eO7eWG/uIXdJsR50QIRGvphjk0oCzgJ6yBdVpIs8x8pgZkus1Af9FJ/vh2wHpLXgNpTYRpJs1B/DZTpiqFbUb2ql0b01rJYZoJ00oMkRwSUMQSqvfY3mOco2EXSoqEZSUsa0toErbMWFF4a21Ba9Aa4z2273B9L8cbB3QnyTrz/QP7mzum2zvW/UyKWRjhX3zJcH1FN/TYrsN2nqsUuEj3jPd7fgiOD3HLTm+o1lNLbUywPQItazSlzZN675tnZovd1ML8riG03jzHSFEUWGPbXGazjwK0FlaylNLGOeQzk5sinCrvW85J5lmplJBbi1py46mVUmsTMCXWECmdP8ZtxhgletRKu/zwvSpUkpK52Fwyxhj8KOr51Ez9D0ypMKmOWgsofQwOqKUICDaaeV7pOsmbP3Q+lFZ47ym14L3M15ai6fqO2JjSUuXaaa1ajj3M80Lfd4QQ6DqPtYZ1CXReBGb75lHaeYfSWlKnkszI5pKPj83LerSz6vuOvu/Zz/PHv+rnOte5znWuP6t+uljpeav7CN5e6T//GJnwE8iGJxZDz07zHHEe8GjlAAlP13l6zKfnf9ry5pHpfXbcj72A58D4NEnp8eEDa3pykufnfvG66gmrqz5yyQ6IVzeLpB3LD79n9/V/Yf/tb1jef8t6d0PJEdc5rr64ZLzY0l1ssL4TJrIWaslkxNoox0zOldzAZ1kS025Pad6Y1lu2by5wQ4cfPNo58hogZqbdzLqbSasouJXRGG/pLke0t5CLtNkp1FSY9wtpCaQobV6twPcOP3b4oZM2ei2kNRJTAtMU81nGA4xWqFrRbf4TZE5SW4ffjnSbAdd3GOdBK1KI3PzuW+6+/0CcJqCgVaXfbBi/eCsAdBywzkLJhCWw++ED8WHHup9wy8ovKoxRcRMcu4u/Jl9+xRRFmW9adGcu5ajMzynJNWp2RdaIP6Xks5fGVoo3qVwb+fw5bdGN3TxEWh7iSLWTP0tjWXNO3D/MbDcjSmWsk3GKsEZqGxmo1hDmVayX7GOKE0pa/iUX9vsZ60Q4tK7haB0lpvMa5wQk11gpWYChbd6jXefJOTO1tv849jgr/qGH137Iey/tBsdaQy6PwipjxIRfZmYzYRXbqKWxpP4wVqE0pWSWNbIsbf41iNeqMQbrDDmUowgpxNi+RTKDO44D9w87GXlos6sH+yitNdSKOavez3Wuc53rZ6s/I+ITXleEH7aozU7pEz/Ef0LH61GQ9Ah7K8/B4YnM5wD0nlgaPQXQjyuF56yjOlEPqQO1+eKEz17A6XBqffbEi9f6Iw31Uy/Q03nY10pJ9naJkfXuj+z/8J+4/6e/4+G735P2D1AT2jqGi5Ht9RXDxUba4EZTD8lGh3NYg6qVGDLT7QPL/UxeAikIM2qdY3x7Qb8dMM6iUCgrv7Dn2x3zzY6SM6pIEpB2opDvtgO6iW3SbqJCi0+sLNNKbn6ihUq37RkvRlznwRhUycQ1EueFnKTNi1Foq7At6lGhJBq0FlAiQhquLvDjBjf0KGPIIbL/cMvduw/s39+KQr9WfO/YfnHN5u01w/U1duhQxlFSYt1PhPsHwm5PDoE0r8SQCCES14BOlV84y5f7hWn+hofxKx42v0R1Q7MKkkopE6JYEHnvUNoIK2oMzhkq5pgW5LxtGfHlOBcp7XLPugbWtbGrRtr3B2N727LnjbWEmMQ+qrbZ2dLa46XS9wc1fQEjSVG5CZAkOcm01rs6zmKC2E1tNiPzPFMrR89NZ93Rliql3Gyq5LOxmybyYf7Se0rJAlqdzMPup+kYB6qVzPiWKjGvlSqxoi1GtZQqwDk/OhYYLXnwSul2QyJ0+f3DnmUJ1LqR0QCtwDvGfqDUyv5hz7ffveNv/+avjsCayjHy82B7VWoltXOd61znOte5/vL1F1TNn+rEX0qOntZHqc2T5z6KuvgYgj2yis+pzsOe6jnefJ2FPMWar7XvD0+8fqyT9b3qFfX09b1kQg9m4yfbtSFCdbqnUihtKTkSbr7l4ff/ibvf/nvmH35PmXftF7Vm2I5cXF/SX2wx/gDaRM0eY0Z3nbSvqyx3fViYbu5Y7vfERdKObO8Yv7ym2wx4r7Heo4yAhjgH0v1MWiNpWgX7O0c3dvjRCetXKzU3f9BcyDHKMbS0n7ttz5QTaV1JuVAUGG/Q1pKmhWW/J2ewRqONRVndAJy0Z1FQlaFYg/Oe4fICN/TYvkM5R1gD919/x/2337Pc3JFWyak3VkDy1d/+iuu//musl1nRkhLL/S3L/S15XqhFWtEpRKZ5JsyJ0rwylRG7qM1lx7WtaH3D4iPv6ltuu2tu1yLrrpUQIlQxtO+8gJxSi6jDxwGj9TFK02hDruUY2XkAec6JjVOMgVKMgPmUj/ZExpqjelwSiORGzDSgR4UQglgyFSSPvvmKxpSkXW0FRDprccYwTQtrCJis6fu+xZqW40c7poiMjio2mxGUEmN7pRj6nnlZGqNaj6b2m80G5x7N7/veS1JVLi2LXljMZQn0fXc0u5/nRT6na1PzWwGQMSa6zrVUp8o49nz4cMd+P4saHrFkSkGu08XFFutFXHUw7O+6roFaJcA3F7YXG6Zza/5c5zrXuX62+olipedMH6/iwucq8Nfq0JR+NGM/3edxi6fWTz9y9Cf/UIcTPD79xKP09LGnxz0VKj222x9PUp8wnvXxxbxcBI/s6HPIWR//PDCtT050Ml9wYIKVPm4X97c8/OE/c/v3/5b5239k3d9Kq9JarPVc/vIrNpeXdM2nUSxrRFhyMJhXRtqwYTcz3z4w39wT5wjNL7LfdIxvL+i2I1qB63tySswfbkVwFIsIibRCOUt/vRUAaBXKGhEdrYkUIiVFyYRHEpRyysR5YdnPxLAK4axqU0lLXvlaZKbQeo83BqWNpC95i66VkpKs1Vq67QY/jNi+RztH1Zr5fsft179h9+4DYb9gvUEr6DZiVm+cgLP08MDDt9/Qv3kLtbDc3hJ3U3trKmGNrPuVdVoQEY7F9mA6S78d8JsO1zlKktfbTXdc3XyNXRV++yvuL/4a1W0xxrIuS8tozxhjxZS/FO7vd2w347E1vYSVse8JzeszhCAJTtWLgh6oLSXIOkkPCiEwmL61urW8P+3G5pASpbXGKnO0Xxovt0eWWStDNRxnNVNK1EoTrBVSzCSTGrNZWlJUPH5P9tOCawlNpv0pDLBvn34xt/f+MBussM7RdRWjDcN2IOXEvAj49078WJdlJeXMpvRtNlQfZ5iVku/5MHSsa2QcNSrB0HVcXmzEpso6GTnJBbRiP8+oZeHyQqJTnbPcfLjHO7HxyinTeyd2VPcP/OqXv+Bc5zrXuc7189RPFyt99LHnMOtpO/oUZ53OcL4kPk+R7Wf07j9KoL7WDj9lTZ+14p9g4NMW/2vw8VXk/eKYh9fyFMd+BJjXwlPweQK1lQYqaXpg98d/4Oa//DvufvMfWG5/QKuKdg4/DIyXWzbXb+gvRmz7ZZ9TYpknckyYThgztCKumeVhZvf9B+K0oKpCa3CdYbi8Yrja4DqL1pbwsCMrERJNN3tySGhrsJ3DWCv+oIMXkU5K5HkBrcgFwrySFhG8aK0oFKabO+K6SspRktm8rvN0g8f3vbCeLQHIDE7a86gmQmpKJWPww4DvO2znQBsqmrBGpu/ecff9DfsPdxgrQNl5g+sdzhq0d2J4X0FZi+mcAND3PxzBp9KK6XbPsheQHENEUfF9hx87ussRN3bNMF+TYyTMM9PtdJy/vBodV/WP7G7fce/ecj/+CtVvCTGKsIhMDplaC8MwsDZhkHeOznvmZZU2OpCVwkMz45eP0SEOtNbK0HXElGQcQGlyOnx6FDFFGl6UfHhaSz/GR4P9lFAV4pq4XxcuLzdtXrKwrIHNZsAYzTSvjM0rVc4tYrOu6+i6jmVZCTFyc3PHxWYEKoIb1VFgRIV372/427/5JX1nxHEAuVGyxjD0A9M0sYYgiV2doy6Fh90erQ3X15csy0qtVdjUzjOOAzFmfnh/wziIP2iIkbv7HX3X0XedqPBbWlbOmWVZ2O0Xrq62XF9fHr/G3jv6oTua3X/z7SFV7lznOte5zvWXrj+rNf+SX/z8OoWbTznOp88+IzWB+pGwop8wcFqOE6YvSdhn6/m4bfzLtZ4+dCpaerHU09f25InSnleoWsQHcdmxfP817//+33H/2//A/OEbKBnjHOPlhmG7ob+8YLzc4pryvGpYHx5Iazgm4tRcUGuk5sJ898CyWykxybG8tMfH643MfmpJzwHNOi+EKbA8TNSmLvZDjxkcrrMoJTOlpMSyX6hUaq7kJDOKqf0yLzmRYyKElbAGVHsbrHNsNj3DZhSP0VyoKHTnME5jrYICNcvsgLYGv93ih7H5mlZKTsy7hft3H5jefyDOs+SSO4cbnNg4WYtGWDgaGHKdQ/cerQ05JmoRP8t1N7HOKzlmvHWgwfaOzRfXXHx5DaqSliAWUdqgnWO+2xP2AaMV/bYDXWXMIGa6MvN290+M+2/YXf0rHja/4nbKhJLYbEQcE4O0llPOLMvKdjNijGKeZoaxByqd9+BhWlYR3oTEsgQ240Chsqwr1hiUKpLZnkV8plAoLQBL3qp8nJtMWfxZrbFopbjYjmy2A7Wp6kFhneXu/oEv3l5hmz+qtYZlFjN+bQy3d/dYLWbyzhqyc0zzTMpFBFAtgME3a6khRP7h17/j7ZvLZtwv86lEcQG4vLwQkVKI7Pczw9A1hrUwL2Lub62hUpnnlWVdubq8IJdEiMISX11IElaMkRgjQxsr2E17EYSVynYjIxHTumCU+NIuYUUbzTTNOCc2Tuc617nOda6fp/7kiM+T5vXJn4cMozaHeDou+dpRniDRU1j7EsD92OTox+tUrHSKNF8/0muv8NVZz2Ob/+SYJ56lT45RXwe0L6dDoaZAXh4It98x/eEfeP/r/4n7P/wTYT/jR89wsaUbD+znJabrJJYzJWKLfqylkEM4mreXEFnud4RpheYJ6juHvdjSXW3pxx4j3kfkXAipEKeFdbdQU0ZVMNZhh6Ep5LuWU56I80JJkjcv5uLlaGOUcyaFQGyt6EOr1lonPo19j3dGFPWdqNkPvp/GCciU1rvBXQy4iw22H9DeU7IY6E+3d9x/9475wx05BLpBhFHGGlHJGxHoyP8L2jnc0KOVotRCWTNxnYkps86SCqUqWG/oL3vc0DO8vWS8vjwmMNWUyL34lWojRvbdvx7YXd5z9833pNhuANrMY60Kd3HFl798y9Uv3pBU5t1D5T98E7l5SHTbDSVX1phwVpT087JimlVRjBFjLNO84L3FNNuig9p+XhaM0UebJaUU6xpE0GQtoTGfRmtyqS1zPdB1Dq00awriAVsLve/EQqn3R7GhbXOT9/d7aq3My8LV5RZjjPil1oKz5jgXqk2zR8qlGcJrBieJTKGIsdnldtOEUCKCUkW35Cjx+FTITYpqzgOqMbdaK1KMhCCJU9ZqxqETH9gYccYfAf1+CfS9iLrEVUDmghWKceiY5pWbmzvevLmklsyaEr6lea0htkjU0uylznWuc53rXD9H/QV+wr4yd8mjZdKTzX7sSE9mM5+3xRtDeUJi1lcR7Stzlq8uQHEKGz8ahalOgfbzY9WXoBqOzOYLVvVECS+goSmXcyKve+Ld98zf/gPzt79m/fAdNa2oUugvN1x+cc3m7RXDdiNMnlbU2gzNY6Q0RTZGBBzGb7FdhzaG5W7Hcj+D1nSbju5ixHpDN/YoFCkGUqikNbLul/aytTCJg8cOvZzTih9kiZk4zeTYwGUR1X0phbiuxDWQQqSmLAwpbU2ttW6MwVqH9cJ6KmswzkvspjECOqgoY3FDjx83R+/MXCvz7R3TDx/Yvb8hPOxkpMBpfDfIOo3BGRlBKG0+UvUe7UybL9SUmAhLZLl7oFR9BI7WebqxZ7ja0F9f4EZR3ButSc20XmuDdR7VyfHjujI97FgedqS4kmPCdZ5+O6B9z+arr9h8cS357iGg7h+4mu/4X623/P6msJZfkTbXzNkSaqWUSkqrJA0BSWuskb/PyypG8YjRvXUWapUUIn2wJfLEmtjvZ7x3krZUafs143hnqQWWZcV7YY3nOTCvMgcrAqMe1djxzThKiEEppJQILU3qoC4XY3qJNU0xCzAWFy1yA6Axip2UUmCKwXtLiIF5nsm5cHV5QcwJow0JMMia+04Y067rKEXM/g8jCYdwgFIKxojvqTgEiD2W2DZpuUlqn9Hr60sO4wnvP9yw28+MQ0/nZUC26zTG6hYJa35Ss+Vc5zrXuc710+qzgejTdKL24I/Qk8e50FPi8JRUPPx5guaOm3/MGurJ6OenfkPIyY9LPaQLHU9Yn53/Jcf79CyPCVEfVcvX57xnffrXBj6plRJX0vRAvH9Huv+W5YevWT98Td7folTF9R2ue4Pre4zzx/m6Y5u7tb9zMzpX9sAkWlw/oJ1DGUVNGa2AmskxtfQiLQxqSJQGGoWOrQIKrZG87kFmIMUaKhFDpKyBkoSBPbzeGCJhXliaKtk0Y/MKKG1wzmG9FeW21dLOPsR5dg6qEvsdZ2WOtRfzeGOd+JmuK+s8s+wn9rd3LPc7cmvvO+dwvQBzpTUKAUDKGLSTKE5tJYkJjbzeNRKXwHS3I60J2/X0mw7bd/SXW4aLDW7sjx/W0phcZYRNo3l6rsvCdPPA7v0HppsHtAU/dHTbCy6+ekO3GemurjDDQF4WHt59YP/DDfff/cDuwz01R94qhVtX1OVfM2++4v1a2SXDEoWV6zsvYDTn44dfG4U1/mgrpI3BmspuP1MddF7GOnwT+tRSG9Bc6DphPLXSDJ1nN82UUrDO0vf+mCykW468c9JWzzFKaz+KWKnWSkH8QJWStKhx6MV4v81gOucwWhK0qGKNZExHzAWtm5gJjpZNuRS5PSyFmIuY03uPd56UFkDiUQ8pU7UevFObwb3RoB/HbrQRJJxyOprgx2YDNQ49V1eXwugqYV0lYhSmZWEchNF1zvLpnzPnOte5znWuP6c+nxEVVYL8/ekfT9vODdTVk22PiUUfBa6PYO4RLj5nOU96/K8KnB6P8xRYPh7nc+I9j/Ohr6z15f712XP1+PofD6geAU1ciA8fCDffsH74I/H2W9LDD5Qg85faWvrLS9xmwHpRR6MgR2lx5xilxd1mNSUfvcP2PcYLwDzY3deSySGRQ6CEgDEKYztKRVrla2jsEmhrBexaAylBLRJIVDJxF8V2KeZHoUwppJAkMjQlwrQwz6uIjrzDdx7rHDTGzHZybH2wECoFbQ3Gy3mVEzN828tr0dZScyLsJvbvP7De3xPmhTgvbQ2q5cs7rLOtRS2gV3nJNTfdAXwaSkykZSWHKNZNpVCpdGNPv93gx5HhcsQNw9EQv9baZokVSlWq0ihtSSGwPuzZ394y3d6z7idKLvihY/vlW7ZfvaW/2uL7HqU1MURuf/e1gM/3t80SK2M0jF98weaLN2wuBvqxp5rEzRT4+ibxrnTcFEdMovYeR1GL6+ZnW1UlF2n9W2MYhp6LC82yBmJKR4ZysxFAJWMRYpUk1k1iKzX0ncxnZlHnd51vKnsjllU5450jhECM7cZHawyHqFIaEDQsywpK/GGXJWGMZhyH9pmtXF1tgcd0KGstMcVmyyRpWv3QHdnpWmoTdtXjdy825r8ibKm1kk4VYiIVcSLw7TMhkalifh9DxHvPPM9HEVLnPb/8xVc87HbHWFVrDS6X5vkKtfmKnutc5zrXuX6e+gmt+VMfyxMI+io7yAlgPOFSK0ehURupfKXtdQruDv8+HOE1JPschL5s07+I/nx+hNN1PJsDfcK+Pu/6H0D302W358UiqcRAenjP8v5r1nf/RPjwR9L0gRpmAWTO0Y09xkt6kO06lNGkEFl2ewGgIYnYSBWUNtIqHwZc12GsRRkBYiUKWK1Cm8n6a6VQj/6dNWZKiqB1A7CS2lNKpoRADvH4Ykrz/mwSbUpLNlonUbyjJA2o5Eo/DvSj+DC6XkYCShZRlWkm60qLCAtnMZ3HdBK5aXwn3pVGk0IQ8Hl3x3L3QGiMXUVYum7o0Vo8RY11VKVBG4wXZlQZSQPSRrxR07wSHsQ1oLabKecttvf47QbjO4yz6Ab6qbT2fRubqPLywzwzPzyw3N2z7HaEaUEpzXh9xeaXXzFeX4uC3zswivVhz8O7Dzx8/4Hl4YG8rqQoowrOCVi6uBrZvr2k24zknJkfHii3d1zeT+ioGbngwV5wp7dMi8IbS8oJ5ypD3wMwp4V5XdBGWE5rDTFESSEK4sHprRPgZjT7aWltbiceom2GNqcipvJt1rTUgneONQRijA00JnkNNZGtZhh6bJsTlXHezBoTm6FvllMJY8Qgv5qKa6MSAjAF1OZcsIMIj3b7GaXU0Qs1te+V0ooUEt45nLWElCRato0oaHNIdQrkqhg6T4WjLdbRMkop+r7n/mHXggECxmpJeMqZdRVP0XHsOXyzFbA239lznetc5zrXX74+G4gKmHvGAB7nKF9s3TZ6/uQJNape2Z6nmx6fOj3Oi00/zXK+omn/6HaPx3veZq8n/21/ezITenIUrcUs/uEHpm9/y/L9P5JvvyHND9S4UHMSEHS5xXqPdh3a6CZMgbisxGWV9ntKEqdpFK7r8S0RSVr1jWVNibQcwFoBhCEqIUpcZBD2U7wiwfgOtxnQzkAp5DUSl7W1+RMlC1AQMCYCHxTCSDY2L8eM1tANHtd3YOwxD75muXEQm6Vm19Pat0pp3GbEbTbtNYC2Tvwwdzv2N7fMt/fEaRHVvVIYDdaLqEZxYChBO4vuPNp5SXhqDGCJiTAFUnz0Qy2pCAAde7qLDd04YPoO1YBMBZSzMp/aBFK15cEv88x8c8dyd8+82xPniO082y9/wcUvv2LzxRtsS26qYWW+f+Dmj99z+833hP2ErtIWt0bjrG557AbrLXmNPHz3jntlWNfA/mGHrmJ3NFSFywvX+Ya/6i75EK/ZqbeEonnYTSzLytB3DH3HbsridRriUWwj7J4lhkQtAsr6zjP0wg7mlMXrs0gyUoyRnNUx6tM3oZDvHDnJ/GWtMOcVozUhyPk243DSvlYMXUehttZ+Pn63tFFHE/zU2uEXFyP7SWyY+sbMLuvKoAQIagW5VDqjxbtUUg0Yh4FVi2JfzP7TcX05Z3b7SeZJawUlsaRjEcV813k677i72zEMHe9++MBmHBib3+66Luwe8nGExBjN5cX2M36CnOtc5zrXuf6U+oliJfXyny9Q3mMy0eud8NM5y9eGTR/V98dHnjGar4vYn57ssaF/AMwfmfx8tkYZIzhp6x8nAj4GZ5UwkqWQ9ndM3/+W6Q//ieX731Lmex6FS5VaMrUq+mFkvL5CKS0RgiGwTpO0OkEiMhX4ccD2Pc47jHWYvj+yrHGeSSFQYpKZP2epOZPSIgxqSM2CScCxv9jiBwG9aVkI9/fkUKR1XcRaCWTeEFOpNYvYJxfitIoCPCaU1nSbXpKTvJNZVCtm86VmYRe1QhXJIKcWlLO47Ybu8lLAt9JUbUjTnuX2lunDDfPdPWGWJCdRoovlkhitK6gth5yKHjv67Uaue8pQs/iXLpFlNwvwbO+4sgZ/MTJcXeIvtwI2SxKUY5wwsUpYN3Iip0CcZpZpz3z/wHy/EwuqIOzu23/9FRe/+iXD5QWmk/Z7KZU4r8wffuD2D9/w/uvvWJdm5TR09EOHMUauhVagDTklptsHCpVaYJ2D+KZ2Dt97nFJ4d5h7nLjKe0K84dZc866/Zpc1MReshb6TRKiNt+we9jhrmSaZ+8wHZXqbjzRWt1lIsWFa1oDKCeccOWdiFPuj1CVyyTjjjhGjomoXOzCtBTzf3NzTectmM+I6x2YcmOdFPhMKYswUrdBVVPUpyYwmFJYlcHWxYT/NpJwZN/3xy6sQ43nfkrGGviMmifLUWjGOA+saCWEFZCa57zypRZWGNaDaY8ZoUkysq3zGjTWUKuD6IHr67vsf0Frz9u31UeS0rsIGnxnRc53rXOf6+eonANHn85CtXmEoa2MwTz3ZZdvWnj9lFD/SNT+EOP2IHuoTqz2ZKf3IeV4Dys9Z0Jd/byMCTYxT1pnpm1+z+93fsb77J9L9e2qRxB9jDcrZJqwQAQ0V5ptbas7YfiQtEzUleU6Bdo5+c4EfBox36LbwgrCSeV0o60rJWZgvIxY+y90DcV5aC1/LHJ53dNtNy0635GUm7Pcyg4cSBjULM6Y7J5ZLNTcRCDIjmTOqtfi1NfSbnqEpyUuWtB2NwnqDQlNDoGpFtQ4zbuguNvixRzvfVOyw7Hbs3/3AdHdLWiSPvZaCpqKcwXcWrY0AdUQQk3MhtRlZUwVAe2fI0yym+CgUGq00ZhCBVXexobu+xA+DMJZUqBmsRH/qNjesaqWGzLK7Z7q7Zd3PpGUlTgspFUw/8Oa/+iVXf/s3uK7FpDpHSYX59pZwd0tu78m4HdC/+pKHuwe8E6GWMpqDl1nOiWVem6VVRWlYQwat6ceebmjtfcRkvpSCVpp+0Gx7+KXd8a/Kwu/2Pe/LNSlbjLHs9xNd5/nFL77g7m4n+fG5kLLMeTpr6bwXb9ea0UZSjg7Z7LnI2IDWSjLfUyaoSFKpMaY7us5L+147YhSrI9QgYrVmIJ9SZuz7x8x2Y47K/K4J5XLOoGCaZrTWzSZJRG8o0KayHcejPVRKifuHiDYG74RBN81D1lpLalZhtGx4rZsfRi2kBGGNlArj0FNypvcdzsu4wnY7klLGOsfDbs9uN9F3jr4Xg36ArnOf/4PnXOc617nO9ZNK1c9R8AC3H74//v3Te5zAx1PG9NU2/ukGr0HO+vKfT9jWlws5xHgq6ssh1BczqfXVZb1yVAGfQp1RU2S5+Zb91/+R/e//I/HmW0pYOPiIliTMpu0ctm+xgWsUYGqNgJLml6itxXQW1/e4vsc2kYsGsUUqheXunrQsAoCsafnqmlKz5LMvofkkCmzVfUc39tjOSVu2teZLrTIDWgpaCegjF8K8kGIQJbxSGKehVuK0EtaEsR7feZnds0aurRGrG7Hp0eJyUKUF3l1f0V1fYYehPQclBMLDPffv3vPw/oY8iem8Vkqy2LXCWo32DqOkZV6KiN6q15RcSXOk1IoquSn7W8u++VyWlDFWM1xf0F1eYsaxvekS7SiqeiAXOHis5sx894Flv2Pd70kNUFINbrzg8m/+mvHtG+wwUnNCIW4F6929sMrLIq18BTWXFmUaUfWgdaoY7whLYHrYk9ZILaLAL6UQlowfOsaL4ShwyinJKIUB6ztsL/npNQgrHddADoG5aH5Qb/ne/QI21yzLysWmRzXhkFI0u6UsM7VG2D/vhRG9vXvgzfUFpY1iCNMpNzEpJlIWx4VCbYKoAZBEpRAiIUSxUmpgsBTxPO277tiWN0YzTQtdA3fDMBytuB4e9jhvCSHReQcV8XMN61E89Ob6Cqq0172TOVWx/xJBUtf5tm4lDGkUpb81unmSijArpsR2lKSnnDO73UQtlcurC+ZlgQrWyaiCd473N3eEEPnlV2/JOfPf/V/++1d+Pn1e/diM+rnOda5z/f9rfQ7E/ElipXbY1596BvAO4qSPg8nXW+XwtPX+wkv0cMzTYz/7QX9Ujrd9T3RFCPisj+r45xzoCxq2gc+SiPc3TN/8Fx7+6e8I739PWWdptSqFbgxUyQXjhGmyvYNaKQXxnVSgiqxduQ47OLqLLX47YrSDImxkiZFlWcihWSsVMF6iCYuq5FLJ64IqGXJFa4v2VjLZBy+zdWEl3O3INEAXo2xrFcaK5c18uyfsF2pKR/9OqMQpUwt0Y8/11TWqCqBBG6oWcchh1lEuj8b2A24zYofNUXhUlSLOK3G/J017Soo4a9leXjC3eVjXebyzqFLASGRkSDL3pzQYb1EZ3GYQO6pYMLpHK2HytNZNeOXpL7f4fkBpI6xsmxFVDSyrIkxv9Y4UAvP7H5g+vGfZ78kpoZSInsYvvmD7xVuGy2t0N1Bzoq6LgP5pJ8lNzcWglkrVmhICNchogWoepkZDDIn9D7ess0SFrkuUWVkLzjv6t1vG7YAfJY89xUKtmm4r+fWgSCES5ySjGLU0oAw+BX4R/oBbfs9u+CX+zd9y/1C5uNjQ9yLYySmTW7u6Frn5WZbM5cUFXef5/vv3/OpXv2hMpWTXe6/pe0+MmZQTnTXMy0Kp0LV5UO+Fdd7tp+MNCoinqPMO5x3TfsE7h700zPPCugasMXSdKONr+zlgrRFQHoUBvtxuqMCHm3t2uz1vrq8aGyvjGjEKSyo+opm+8zgnLhMu2KOd07pGKpmSM9O8kFNmHAb63nN1pfnu+w/80+/+yNXVBmcNYc3UCp3zXF9dsK4yLrEdzzOi5zrXuc71c9VPYETf8bG5yqd47jnD+QxIPqlnIqBPLeVkdvPTDMNLQHv4x3PJ0eOK2txqA7j1sH0OxN0t+z/+muWb/8L6/vcy94mSGcPyCIS1NVAqurPCKJYDe5raGeQcpu/prq/pr66OGdy1VkpYCfuJNM/indmy1m3XUTSUKHOfKMBoKJkSkvh0bkaMlTnVmkTpXnImx0COGdPU4jlX4rqwzjNxCdRcsd6ijUJVua65ynmH7YgfOgGxWeYNTedBaZSSuVvtO9xmxHe9WCUpABlZSOvK+rCjrPPxOtXGyKZlpZSMVsJSVgU1ZVIRIVRpAikxwbcN7Jr20s3xvdPa4Lcb+jfXuHEQ8Nt8VpVcXJmFFBULtWTCPLG/uWW6uWG5l7EIqsIMAxd/+1dc/uIrunGQj7Sou8hhYfnhPTmsoqRXmhrFGis38FRixDTv0loKMSTm3UxYVmgemSGI9dHF1Ybt5QXGW1H8O1Ho5yjtZdt1GGcEQB58T9dIjYmqKyVVeS5G1mUVo/2YSdqzu/hrdm/+Fn3xBeI82jLljYwtHMDmZtPTec/Dw0zKiYvtSKUB+2YUn3I+As5KZZkD0FT/vjH9zerINucGo7WIl45jOFK55KOaXyuFb9nvKWfGoW+q99gSoRx911GBH97f0Hux/1K10jdGVSlJihIAK1ZLvhMhFjQmtLG0xhictcyrMK1933F9dcn9/Y79fmKaF95cX+KsZbefmquB4/bugZQyv/jFF/y3/6f/7hM/cz5dZ0b0XOc617/U+gszoif1vKP+6nlee/BjrXReMJHHFvvJY+qF2v71U7yY8zwBl0/wsTrdqlJzooSFNN0yv/sD87f/yPzud8Tdjaipq+So11rFVNw7UWxbLa3f3MBuhFoL2lTQGuM8frPFbTe4cUA7Ty2ZkjJ5vyfsRSme1oi2WiycrBE7nKYg11pL67CC1hZlrcw+tkjFnAo5iEq+UKXNXoQdjjmRliAzpiE0S1iFdgIatZWkI201SouoRLdYQ+ub/2cDdlppdOdb3OeAcU4U5g38pnUlTnvyPMt7qK08HqSdXJP4paoKqTHAVSmKErU/RjdLIQGfWhtqKqhaJZnJaFzXYYee7uICO45oYwWEFwHc2jmBw1XM6HNKhId75ttbprtbwrSQ10wtRWIkraO/uKAbtxjnZOwhZ3JYSOGOOM/UFFFaUZKMGcR5EQYbsa+iNpZ5Wph2E7T5T9MCApTRXPUdw0ZmH6vWyBsksZW1GHTnOYjrwl58U2UuOGGtgzb2EWMSgBoTpWZQMuM7esMv3wbGX+xYNh3v1o6btec2wroG+q7DaBmn2O1m6qailDgaxNa+PwBwY+QznVImxIWL7SjRmSkTUyaEPdvtpnl2ttSrBl67zkvSVq3HhCNn5UYihIjzjmVdmeeV7Wbk8NXUWtTxSqkWwVq5vNiyrAHfwgRySjwsK513OOek5W96AZT7ic7746hGCOE4nx2CRJ6Ow0Apmf00N0unkZQzt/cPbMaB7XY8vo7NZiDExLKuP/JD51znOte5zvWn1k8SKz2BkU8Iz1fmPF+0uF854hGEvtz/BYvwgkx9PMEjU3rCsZ4s9lEcJYBB5NRNBJQjaZmI+w+ED9+yfP9PLO9+R9rftjlTERmVUiAK8FDWYDoxY5fZwAotk11bK0DIueb32eP6AWOtAK6cWe7uifsdaT9TY6TmIgDMt2ztlClxER9O30k6kDNoZzGuxXuWTE1JWq65yExhFaW6tG8TteW8pyDnUCDAsQIt/Ugbi/cOtKIqyfc21jT1vMJ0HmWcGOL3Pc536PbLvsREnGbSsoiFVAjiUZpry5Yv5DhLFj0yD4qxFMTCJ9dy9PfU7ZxKSRqS8c38XilwWtq/40B3cSH2U8aBFhFQSbHNAx7Sryq5tf6X+3vCwz1x2lHae+Scl/e2ShKS0pq6Bna/+z3x/oLhzbXcdJRmP1Tlo5PniRwzMcrspLaGuEbiEglLJISAKkUEVdbieicJWX3XPEZtE3hFjHb0wyAss7bkmIjTRFgkIjRFYY5rBT94ShIf2BBzY0ETuQrQHS4HLr96w5tfvmF4c3X8XH/pV97VO36nKnemp2hPRnxDaxXgmIt8drJNKGUlEtVIq72mJIx5A6SitlcQE3MI7HZ7NuMgkaqnqvtVQHtMCWvFAumQUiTjHBVrWqb7GqhVPpMSNVqY55WZla6xrt7b4+iARoCtgMxyjDnte2FYQwj0Q7N/MpqUZV5Xa9OM7DPWGtY1Mgwd1lp++YsvuLvftZZ/bsc9iPZ0Gzs417nOda5z/Rz1+RGfr7Xj5ZnPAp2Px3gFtH60dfXKgZ8c40nvXY5fn/37dMdjxGYhzQ+E2+9Yb78lfPgj4eYbwsMHEZ/UIqxKS9g5qHSN9dLitKaxbQJCtdKYzuM6j/UdppOEINvJL9ISE8vtrbRyl4XYMsuV0s36SFqztSRKbGCqVrRz+E0vc45tnk6iNsMxX75kUZsLMyeg4uBDSikcvDeNa4CgImDPOWEcDWgUykiikLHSwsVI5KYbN7ihF9ulo1djIs0zaZooy0JJYrgPLcGHJtpJIhIy3h/b0zm3tvvoqUuA3NZUNdY4WVcTm2lncWOPH0fc0KE7jzIWlHl8o9vdh0bM53POrPs9080dYb8jhVXYPWrzDTU4q9BKGNSSCtopjLfYXkQueZ4EiCtFiZEcooDdIi3xmjJZIa3xaWWdg8wHH5T/xtBfjAxjj3HCLuuW2a60ZthucJ1HW5kBzTGRp4l1txMLq1LQVuM633wyMzGG47xnreA3Pd1mw/btJRdfXNJvN2hrKFUJoN3tCfsJN838bci8peehvOXBvqEoexTFOffIZiol4xKlJRnJDGZisxlZl1XsuFTFWsPV5ba15RNxWhrIVM0EP1JyuylqWfBKKXKS76B1ovK/aIxqykXez1pF+ORktGIJq3y3tD6a0s/TgvOWje3JRT5v87SgtJIWvlYcMuhds6+yRqykljWJkFBrnDOsjTEVRwHHOPSsQdT5XVPsl5IJ4WzfdK5znetcP1f9aa35Q9WnzOOTUs+B54udP/ckpx12nvbUX5v6fGQ/G0+KUppaM2XZE+7fNeD5R9bbb0i7O2oOlJAEABgtYhMag6cVhioAqdLAY2tbt7a77QfsKK1qRZtHTIm425FD8/ycFzSIqKgTC5qSxT7p8IqUElZSaYlzxGqohVoVuSIxlWuUVneMGC1xiso7ckrs73fyOtoYgbEa23LetZVjFtSx7W2cxegqXqK5NGtNJ4lLnWSvm65DIYboYT8dmc8cgvidtvnBnJPMWypoaBdlxWMzhXhMeFJaN5ZVYVLBug6lbTO9l/lU4z2+AVA7ji3jvcpsbJsrVbUp35FUoLSsxGXPfHfPutsTm4+kah6kSssYRc0y86q1Au9kxGKQhCrdbgqokq2eQ6BEaeEfxhhiSPIetLZ8XAJKQb/xlCzvhx87YVoPgFqDcRbbSeKUbr6zJQVSSKwPe2m1pyRzxsYcbyxqkVnfFJO0ub1l8+UbLn/xJePlBuv98ZqkEFju7lnvH+Sz0hg+cmYoK37dsTHv2daeO3fFvrsmaSfjCYhDQ661xWPK5yg1C6nOS7tdoTBatRAGYRZ1u2YxZGwDjDlnqjXkLEKpAxhdl5Urf4FScP+wa9ZJFtcU8ZthEDYWmOaANRZjNLFGrB3w3glAbIKplNIRfD7s9nz15duW9CT+rFSIqc3AVkhZHAmWZUVrRYxJgGgnLL815onfajmY/J/rXOc617l+lvp8IPpce/SqHdNzcPkSbMqv5k+D0KPavaU5PZn5PAG3x3z3g7XS6VqViBtymAm337P88Dvizdek6QN52UNcyClSUhF1dTOFP8zsqdbkLTLGJ+3ZImDIDhv8xVbsg4zB+A5lLTVH4u6Bsq7kZRFVdc6SU+5EdFO1EvyeCpoMaImpbL/klW8pQVUAXHiYiFF+kZMzqoE556X1bzuPdgabC1jL/P4WXUsDmQbbiRhJrolkhNcGFLUqjf206M7SDT1u6CRy01jQmkwlTzNxFtU7KcnV1wa/2WI6T5x2pCTWSjWVJujhmGFeC0c2WqGw1aAK2G4QAArozgmjPPTYNnuqj7OUjc08pDTVAloiTdf9juVeRh3yukrCVBWhk3bS/iVDTQK0tDMNmBtM12F8mwlNhZyiKN/busXWSEBezpm4RpZppoSIaoDSeIs2VjLvlTrO0taYsOOAH3pM38ucaJW15RhZdzt5j2Mkhiwm70rSrMK6UovMGZecKSVjjJa4VOcYrrb0Fxv8uKEqJSB8nQi7iThNzWe2kLM4LBTBoigyfb7H5Tve1HvKNnDXveWH1bEUK9vn1ARFAvqdc8QUKaUKe9nEP77NJRvdRkqAmLOwlA18bjcjqW0HNCcExbqubDYj87zIrOiysBkHYkws88LQi6reWbGbur19oPMO38ZGrLXcP+yOoilhPFUz4w/NqF7YezHCT8SY6DsPeGFgF2nxl/Zd2O9nfEpYY+UYud30oI5eq+c617nOda6/fH1+xCcfZzifPvxK6x3kh/rnkqCtJBLwyGu+ImZ61qJXkrySw8J68z3rD//E8u63xPt3lDhDjpQcZfNmZK61Qh2slVRjUZC11lqgiMm8HWWez28vjkBJ1SwpR7t70jyTQxRhkVIoXQU4YaFkVM3CzKZmv0NtivkChyhEZyWyc40iqEmptZsLzlt832F6h2ltat0EPiUmVC4MY48rF8JMGvEixTRfgHZtUJBroqJRQ0d/cdEiKkWsJFGJSnwkpwcZASil2RJZlPW4YdOEShalDd3VG0x/w93vf0dYxe9UdEPqyC6jFEYbtHVotIwNWAFyfrvBjf1xXICDvZZpqnlqi+vUVDIprA2A3rI+TG0GVuyJjLNoNEpZdG3jFSW31CIrYrEmvtJO2u9hmolzEJumlOWzpsXwP8SMypDiyv5hT5gCtnNs3lzTbTbkZaaukQPMrrXSbbZHW65Di7+WTJr2rPuZMC1N2S9t8JJrm9eFTCUlTUiBg9es8x3auuNrqyGx++EHlv0kKUDrSsqJEtpnz1nCulIKaGU4fIu0FfP4q4uB/qJH6cxf61vm3vHHyfL73HOT61G4ZK2Ma3TeSbu+3QimlMQ/ts3wOmtZ1xXvLLkUWYM6MIn1aOfr23EOAQXDMNB3He9v7tBG05uOmkWMVZrTgmnWTg/7iVIKFxcbuq7He8+yrmKGj4wRXF9dUqrMdx5Y2sN3fQ3h6E2qlESX1lLpOrnh2Qy9WDwhdlA5V2KKDH0nNxfnOte5znWun6V+4ozoR5DkaYv+dHb0yTanrfXTx+QX1dP2++GYj6xrhWfxm+0JfbBJiqw337D/4z8wf/tr8v495BVVhcHLIcn8J+rYHtctpUU1kFxzglyoWVLbTdczfPmG7vIC572AOS2rzPNEuL+VecwkOe9KyzxbVVBKU5KnjKagagNnRqGPq2+vpkrMZ3zYEUIipXLMZ7dG47ylvxxx44Dt/DFSNM8TaV1QReYStQJDIVnV7IuEoTv88q20DPLNBf5iixsOfpwy8JpTZt4tlByAcpSCoRXGDvjNBtv3R/sclCYuK7t371hufyDlSM2VsASUE09Oqw2+axZA5eA4AP7yiu7iAtN1otCvMqYAGuVEZQ40n1ZLNZDjSppnlt0968N9S5IS4UtBGG1hKEV1X2ISdtTLrKnxHqVVE3XJ7F9JrQWfi7z3BWEZY0QZAYrrw8S0m1vE599w/Te/YvziS0w/ENeV3bffs75/Tzf2DG8ucMN49KqtJRP2M8vDPXld5XqaSgmVvCbcpsfaQp4WchLgfvnVG1LOLPsZisI0Sl5ZEftoKwxgXWZyE94dhHVxbTcOpcrnq4J1mn7bM2xH+u2ItlZmXnPC5oBfH/ireeGiOr5TI3/MF+TuSly3UmYfI33f46yl6MKyBlG/OwuIuK7rOpZlFRFallz72CytSqmklMlFsxlHYow87HY4Y0ErLi+3GK0IIRFakpdqMa8gEaaHzPv7+x3er3Rdh3fiJGCtZbeb2O1mrq62zWFChGFGG0lbajdEyyLZ9sMogqZpWri42KCNYbsZCSlRaiXGKCEOxkpq07nOda5znetnqZ+mmv8sy9GP+Tk9Miovj6tO/i5/vuz4l5NdFRhDzZlw847p6//C9If/RLj9mppDY6Forc/U2sPlyISYzotHZKmoqtBVAFt1mlQi7mJk+OoLuu2lWClVUdLWdWHdTQIAl5VSpGWsrEEbT8mBZb+TeE+jZaa0CKhV+gCq9FFElFJm2S+kNaAO1yBndCmYFs/ZXY4tv12LcXoK1KWIdVBOmGYnVUo8tv1N57BdD8qiVGtJW4/te3yb/5S40UytlfVhR9rtWhKQFhDgHLrrsN2IcR4DDfQL67c87Nh//x3L7R1xvz+6C6AU3dihbYfyDts5iIkSE9pZ/GbEDT399VtMP1BzpASZZ9TDButsYwJ1Y9IKcdkT15U8T9D8R7vtJShLnoU5NMpIUpSRWU4M9OOFzKNqqEWAbgmRFFMzUxdPTkwTcoVETquY22tNLYplt2eeVr7813/Nm3/9XzG8/QLtxGUArfHOc/W3hnTZoZWRG4Jmpr/uJ/Y/vCfc7eSz3eyRjLOYscMrhfOWHAJm6EW45hy5yOdg7PsmxsoUJBBKWSNBCUVuHsRSKjE/zKy7cNTjlSoiHeMs45tL+uZbWnOW8QNVSRTCfpFRAK3Y6Mh/bT7wV9zxXdzxvfmSXRHBz/7DLWE7Mg6DzF1G6SxYayhaoYoAyrv7HUbX1s2gMZui0leIpdLDbsJoTTd2POz2ErvZ9zhnsUYTYsJaKzOapR7b+ONmYKOGY6oTCMtaa+HycssaAnd3D8SU6DrPl2/fMAw9pUpu/Dj2jGPP/f0eozVzWBnHgWVZWZbA5eWW68sLcs7c5Ay1Ms8z03y2bzrXuc51rp+rPtvQ/sMP377+xEc68c2s8sh6PnkcOPbrOJUfPZsePVo0Pe5TK8TpjuW737D/7b9n/vYfqWEvzJ+1AmEPHp1tN62VzAU6gzIW610TsbTjNz9Jt73AbrbYfhTxRlgAyGEh7GbSfne0NKo5t9m7Qk2JHCOUJFYxRzZPN6GUeJQelPJpjay7PWEOKG0xVjVxV8F6R391IW1d65pJfZTs73mhxIC3FmXa3GpG2u9GS9u76zCDqPVrEhZNVOdDU43LS87LIn6fOVHWcFR0m85j+gG7ucT1PcT42EZGsdzesXv3PcvtDcQox1SKFATw9xcjtu9kDCALS4fR2M7ht/JcrVVSnoxlubtn9+GOWir99RWbL9/gh/Eo5hHGcqHUlguP5NuneaWuono2RkzkU0y4zYB1GmWcsKDWkFMi7ffCoLb41VLa504r0LT0ooUUJWUKDX7o8eOW8c01m1/+EuU6AbQosJa6zuRpBzkdraTQEsN6+8fvuPnd79GlYn2HMrq5AAwYb8nTgqKgjaGkJFGcuQiDXnWbY5UbLnSFEFHWC6vdXB2q1s2iaiItsc39yhpc3zG8uWC42gpwbt/HGlfCtGfZT3LtnLDRcQ5yTYrMiapayXbkXdnwu3TFTbLM88r15Qbn7DFLvu878Z01ukVowjSvR8uj0m4ASxUj/JwSIaQmfIKuOQMopXBtrlk1IJ9SZhwHQozs9zMhBq6uLo6CovuHvcTDGo13EiFakRnolBIozeXlBmsM87KSc6HrPCkmfOeByn6/MAwdtdQ2Syos7sWFpDvtdnt++OGW//v/8D+8/vPvM+psaH+uc53rX2r9fIb2p/Xaz9gDwHxtAYcfyrU+lyE9Y0sfRUiSyLMwv/uGm1//O+7+8X+CcM/QS6xfMaL6LrMARw4pPICyGjv0Ym/jLDVmaaMrRU2Zai3D9VvcOGK6XoBjTqT9A+H+QRjIWlr7nSZkEY/PcmjpIsyMck6EQADGohprW3MilypikiWQDyryCkZLUk+3Gegvtg3EqdZ6l/PUmlE5YWpCa0PJUeyOug7lNMpq9NBhlKVqhTYWoy32aoN2Hu3kl26Nq1gOPTyQ11nAIlBzRhmHv77Gby7Qzh5nZuk7ws3C/O471vsb4jRJe98ZCpaSqsxmaod3CmucAFAy2jvcdsAOQxO0KPK6kkNkvX9gvX2Q9rPW9JuRvH9gKpF8fS1gsaY2UiA3C2mNLPd78rSKu0Fj0KutdNue/norgrOD1CwXwjwT54XSMt5RipITKQuYw2p5PxZJDVJG4S9GNm/f0G+39NsLucGplRoDKCMAeXpA3O2TzKAqhfIepS01r/TXV2xrpTzsKGvEbjr8ZsC0tC3tDUo5ikL8YBeJk3TOHucvq9Ho3mOUohovs8BUqtKEJRL3i6jSY6YitkjdpmO4uKC/2mC8a3ZaMqO67mfW3Y6chVXWVrfPdmpuAaBqwflORhhC4Bdl4jq/485+wW/9wC4GdLNTKkXEStYadvsZkDECZy3LGug6Ry7lqLqvpaK1QanEZuib3VqlthvMUiopBqw1DEOPNpI7n6Kww85ZSU5y4J3ji7fXTPMiIykNDGul2S1iv6VRzNPCMPQoYF1XYpt5TiUdze0fdjuoCmcNfe/Z7SfybUYbUdH/1S+/+Ek/Es91rnOd61yfXz8NiH6E/Xye3f6y+/56q/6jp6nNtmadmd9/x/3v/zO3//gfWX74PZRVlOrWsdpCJYvFTi4UwDqL7UTk4vtOGJ92vtK8EHOSOcza7IdMv8VuL8jrQpon0jSx7h4gZ9lfa0quYl/U7GKc0+2XamM82jVRh7EArSkpE+aZZbcQD/6Q4q6NMRrvLcN2aAIai0KRGlCD2gQ4zaaoNmV/ZzD9Bt2sgGrOYnjvPco6rO/Q2mKcASupR2ldxLR/2ssv/lJAy+uy1mHffIUdeoxW1Jgo+4WcC3Fd2L2/YXr3A6om8cRUGqzYRaU1oxFTfGNV04VUNAq/HbCbEeO92ADtJL40pyy2QksAFMPFBtt5GScYB2GrSxJT/pRE+FQq8V7YW4XCttlBtJjg++2A671c2yJG9CEE0hKPIMs6SV8qtZBohvpzPIrBlIKLL6/pLi8ZLq/w40Zmj6GNjhjxZo17ShJ/y6q1uDM4i/Yiaqm1op1n9J5+M7D/cEN82Imyu7khoKBYLwbsux06C8taMihd0b1trgW0G6NKSeK+UEoh7PakRaye0OB6jx86hi8uGa6v8H0nYGteKSmTYiIuEzEsMi9rvYC+JULNoNyRdS2loGKEWinN9J6S+KJ+y1ejZ+q/4Fu+4LZ03O4T07JwYbeMQyeioCg3Wc4JC3lIa0pNAKW1ZhwGQhTv1UMSUoqJdQqEKN8vVMVZh7OOmDKFQt93gKQzifixCgPcvvcxSALZZhy4ubvn6nJLKZVpmo8/tEqR1CQVFdnn5m2bGfr+aGA/9ANAs4fKP+ryca5znetc5/rT6ycyoi+R6Cnr+fgDu56Ik57i1vrsUYV0NKmS7Z7mHdMP33D/9T+y//ofmN/9njTtpIXtDBgxrbZWY7LEQxpnsGMvKuyuo9uM0vlvaUgpJipisC3KdlGwS6SlYv3wDpUDqmRhx0qFQstmnwXkxizJLlodgaa2pl3CKrOgqRxVuyUkScYpBY2m7ySFSRmZUz14V8qoYm255ZG8CssqCmlEba40OIvr22ynlYhPbQ1m3Eg2eVNWK+uoKEpYSQ8PpGlPmvYNkBlp3fcDZthihxHXzOZrCKQQCNOe+eaW/bsPrLtdSxCyaOMoFVLI5EkAoSjaxWxfWY3vO/x2aDOUGgoNNAkLzMH782CLNIhPqRs6rHdtPKGKUX9K5KVluacCpQir6hxqkHhVbQVMa91ARgwybrDGltuujyb8MSbCshKXlVwSGHOcSTT9wHB9xebNFdb6pnIvAjRbwlBdd1Dy8RNcNSjr0NajDuC+FiqVvEbCwx3rbo9WGmf10b4qNVeEtKzUnNClUJUwu+Lh6kE7MEYu4UFlHhNxDseZAuME2Pqxw19eMLy5wnauJTfJDUzOEm2aUwAn/qaAeM0mGROpRfxyK0nW0a6l+OeKKMpYhRs7VAWf79iqiQd9wfvthvdJE9ZVfGmtIbb5za4JfQ6z2kpBKgVVMqBaO5xmSl+42I6UUtjtp2Mr3trIdjNiTfMjjTLCoJTcSKgWRVor7TstIrplXek6Twjp8QaxyhgAgG83zusa2Iw9Dw8T67JinCXEJOxtLZTmzLGuZ0P7c53rXOf6uerzgegrs50f3/bHDtZU3LVS0kqc7llvv2f6/nfsv/kNu6//ifXh9tgC9uMgUXtei5m2EhCktOSeu6HD9l7YkTb7l9ZESaJazzE1sZJGobG+Kbp7SUpStVKm6Zgok9dICpEcEilnXEslMp0R1bsxqOY9WZuiNodAXiMxtpQa5Jek9V5a1L3HeCeiJTH6ocRECpGSZdYxJ5lPtJ1vBuvNhD6VZuouc6faOmzfNeP5XmZJa0uyWfekZSbe35CnWWY/rcH2o8y/jhv0uMF2vbDO80xaF9b7e5abG5b7e/KykkKQ69/30uauGl1qM93Pzfhc4b2l63uZae0cgBju7xdKTEcLKpTMsSotgQHGO4x36L4HWmJRY9NyiKRVUqMOIifXORFZ9R3WNkGQUjKrm5KMPyyBuKzi0ao0RUmkagyRsCwskyimjbM4axmvrxmvr8TCquukbZ/EqB6tqSVRp0XiVJuVEtqhnJcY1zZselhDToH1YUd42FGSJPTgnLx2VSihUFYJAjAamXtVutlWCYuv2kytsko+T/NKXmT+FqfEMguN7TxuHI7WV4oqNzHtc5SnibiKl602qt0oRWqVNri2DmM0JYoQL6dml3RwHZDZCFSpVKOOBvG1VmzNvDX3vO1W/vbiivcYvrsPhNrjvOd+98A0Lbx9e9USt+RnRmhG8Vpp1kXhrGNdV7TWrDHIOI0xjNaQUmaeF0IIjUXt0UazhnBMWhLj/SYkrJL4ZJtYTCnN/f1OLJp68Q41prbYUUtICdsM+a8utzzsJ8mYT8LiOmtbslLBu3PE57nOda5z/Vz1Ewztn/bjP9FYf/L8k72aQXRJK2F3w/L+j8zv/sD++9+x//4bwsMtZGmvOWuxzmCsxGDKDFiLqrQO5cVX0bWowpKE5UlrINcqv2CjsJvKaAGezrZkG5mjVBryshLmILY3WbLPxddToa3BeYPtHKbN1CljoRQBqWFthuNQ2y/0ij6Ko/zQYzqH8V4YLIWYpkdRbpeU2/+F3bHGoTuP8b6xraByRjuNHUds12E3G0zzNlRoSi3ERZKbclhlrnSZoRaUtdjNgBk3uPECN45oL44Bcf/AcnfHcvOB9e6OOM3UnNH2Mc9eWslino9SAioUOD+grMF5ATNaC0sbJ3EVoMj11+29Uy1lSTk5tunEdkehyCHLexZWapBWeUntxsFY7NjhhgE/is1TbVZhqqnkYwykaY+q0pY3xlCaICzFldqM6HOMOGsZ3lwyfvGW8foavxlFWFYOPg0aNDL3eeLjWY1YZmnr200Iwo7WNuYxzcT9jrS2EYxcjqAbBNyWnNGIL6YySjxSc5YkJX2w0MriX5qrMM+zpGgdvDm1tbje0223+M2IdY6qoK4LKYrYKCwrcXp8/7VRR9usij4mOx1mr2sVJ4FaC6b3x7nRWuQ1YGTWNseMPlwjJSxy/+aKL7Yjf4Pm7qrw/X7hw+pQybEPlWleMFo3ZbvcuKSYjrn0WqlGmFZCiMcoTmsMfdfhnG3JTpWUC7mE4w3sugb6XrZRCta1zV0XYTKdVfS9Zz/Ncq5DWlUVMVbfeaw1TNNCbN6/07JgtCHF3G5KpY1/EGad61znOte5/vL1k8VKh1b8Y/pRe/xV1ZJ4MioUNa3Ehw/M73/P/rvfMr/7mvXme9K8l3ZpkhlIY/X/j73/XJIsy7I0se/QS5SYmbOIyMzqnpmWeQE8FgSCx8Gb4EUwA4j0DIpmZkQ4MaLskkPxYx9Vz0Z3Y6KqMn9Bj0hIV2eEu5nSu+/aa30LZx1GN9XzOkT2XhTGzjYVUPrGS67EaSG1NpoSRIWrpUpSe9PfLr7qOkxW5MIdE2leJEDUQjdaKxkenb0pmNpolDZywZwabglB5yhtZG1sLcZeO+cbz1LL0FprIU9r6ysv1Aa2r0qhrMUYg7Ht5znX/l7d1p1tjT/00kRkNOTc/KyLVG6meBu8FQrtOxlcd3tsP6JbCKvElfn5mfnljfX1mbRcyM0+gHXieW1Bd+skNFVyQRklA7hX2N6150UwVCUl4rxS8kycZlJIuN5hegGFay+Dp6z3jSiNQA4r8bJ8X9tf6y2dwfbSsKTb+r2RlmSYsU7CT10nSulux/r2yvr8TFwDcQk3JVa3qlTrHcPTA5sfPjK+e2o+Wi3VpgVqCdQUG8+2NBUPGSZ9h1UGXCcDd1lbuGgmTs13m7KoojHKwNh31GZjLVEen9IGM3QCIYsVg5LVfy3UGEU0VOITlZ72LAO31litcZtBIPnjIDcqpr3/15XleKRk4XeWnFG1UHIlhUXCetcaULQwaGMU5bitno01mK4XpBmgSqHUJAN6Ea4uRfBTbren329xfSdM2/YY3g+VIRzZXSb2yvLSDTzngSmLz9JZe0vS55zpvGNZA0sI7LcbeR8lSaxXKrkFwMTbK98usXlYTbsxDSGI5aUKGUNrfWtRUoNiaIGotXFPx7GnlIIzMhjHEDFafLebjWCh1jVgrWZZI85qur5rA/j93M/93M/9/C3OvwJo3y7OLZCkrv8n/8X/cVvDKoE3kuYj85d/5vLL/8b0+Y+sr19ZTkfICeut1FYqcE6q+2znRP20Bjd2uL67DZGgmrKoyCG1ATRQs/g3aylobbBOBkm/HVq/uISZci6UkEUtu8y3C3GtMgAbZ7D+ClPXbeVaKEGR80xOiZKrrOmtaStXhekMrve4QZTMWsTnmFfBLZUkrT+itjXV1FhZszYwvOlc45FaVOt7t10nIZhrAr9CvJxIxwO5db7XUqhGg7LYzZZu/4DpB7Tr0H0HxpJDZP7yK9PnXwjHMyUEtFVYrVHek2NCldLg9waqaoEmcL0MwsqJP1VphcqJPC/EVbrYW40S2lv6oUP5psQauZG43azkQp6DDJ/LItSCIjgl3TyvdpAh1HgvfsWGNLLdiNuIKqwa1F8GVEl7pyjr93VeuXJFTdczPj0wvHvE7XZik9BGbgTQlBAp64xCmpcoQhCo2qK7TmwUvm/DFlDF5hFeXwjHE2ldBezQSAUC5pd6UGqRm6KYQSmxW2xGdM6kLL7jFMWXXMQkLRxX9HdimVLYoW882R22lyCaajxZsQEcyOuKajdmqqXPa+VWP6utacrjVcFdSK1r3W5GTO8pCkhFlGUxllBKC5Vpgx4Gtj98Ynx6wijxxAqWTLBXy+GN9XimV4offOCpLvzUzfy6dnyLPUlt6VyPMVL1CdwwUNM0M26GWz1rSpmuMzeShoTAvjczadOGzphY1oB3XoJ+UfihSSmOxzObzcA49hijWRq+yTawvVKqcYAV8xIYhp6H/ZbYWpm0lm2DVpp1vSui93M/93M/f6vzb0jNNz6ouv0P38+1QnK9sH77I6c//mcuv/w94fxCWmbSvKI1jNueYbel22w4ff1GvJwxzqOMbV5K22oYDYa2qhVpkjDHtoYWD2fJpfnaDHbbyzq8rYNJ+QZqr0W623NKokZmWdlrrXCddLIbY9pQkyS9HgVsrptKo5XGDTIkS4WmEp+jdxhvKTHehqycRJmTjWuV4IzSKNuGayt/7xX/pDsv4aGuw3Qe7brWT29Jy0p4/kyaZ2pYISdBOGmDGQbcZofZbG+BJbT8vnG6ML98ZXl5Jp4v5EWahKgVZXvCIughTQusNCXOdB43erkpcBZjLNVoSpThKk2LcDxbpzzWYFvgyDgr/smuF6W21TyWEEmXhbzIYF7ae0lbhe0FTZTJGKVvvFNVQHcj/qGXcJLituqP08Tl8xfOn78RzmegSKq9gusHNk+P7D59xO/2t0FYaUd1nrIupPObWBGUsDpl/jKoXryI2ll5P2sFOZHDyvp2IJ1P4vOsooJrZ+X9VSXIVrJCXVuiapU62M5hjEIVGbyt97JCXhdKyIIba/YFaoPRb0e67bVGVTBTqheY/PL2xvzyTVRcKzcANVVK+zxobTD++wqeUsg5UlIhrvJ6iGWkBaJikpughlFCaVxvqdWhvKd7eGB4/x7nbfMLS+gsXybm11diWFG1CB6tgkYxGENXA3555UOC1/LEr8sDdZRAWCqFse9QekNoAULTiBMxptZmVG8MztTsGs57hqEnxiQw/avt4MYkrrL6L4UQRGG11tD3HWGNxJQY9hvxllZpoNrtRk4nYRHbZv8Yx4Fpminle1r/fu7nfu7nfv7659/GEf2L6k2R+RQlziwvf2b6+T9z+pf/zPnLL+S4opWoDsYY9h8f2T4+0I9DU9c0/W7D8ZdfKTFI53lLYlOkcjEWQdfkLCESAbw3z5q19A9b/KYXD6dRLdWuxa94OBOXKIqQMzf1TZRJ6DqL7a8985qKIq6BtMamRnmkkFOSy9qbNmw5+f2VasU3ifXtQlqDNC6lJD/TtN50o6Wrvu/RzS9aWsrXKoXbbCS9Tm3KqQU068uhddiv5OUCsWFrjEEPW7r9o/g+rUW5Tl6HsBAuF9I0Nc/ixHo6UVKWdqI1YrSBElrtZkuqG7BD37yoHuNk8K8pksJKXBNhWiGVFhQC5QzaGbRzAsH3TuCtBcq6kCvEaSHPM8TSgmPNt9s5MJpiFHm+kFfx2KYQMb6je3onCiZKsDpWBtS8rkzPv/D2p5+5vBwaLgrQCtt1PP30gYcfP2K7oZETMlgHxgv39XyEEm+w/aqaX3PcyOo9R6CgSqKiiXMgng7kaSKHIDWgVLAOM46imrea1VKTDOe1guvwe7mpUCCIsSAEgBxban4tko43uinHCqyj34243qKVeG9BUbViObyyfntmPRyxXooZrtuAnFolrJVmLGqlJlEecxaVtsjE3Pro5YbK+A7dDaiGTFOoVjhQMEPPw9N7TCtDqDlRlplaEuFykVatJUp6vbdYB7lWUhJmbg4BUwoPVvGgvvIxvfC6PvHKR16iJdeCM1ZA91kGQ2stTrn/Iqm+GYc2T4vN5YqHug6rKWfpjFeifK4hsC6B/cOWsK4toOSkVS2LwmmNudWUpijp+pRlGI4xkktms9mwrAvjOPybvibv537u537u5//4/OsG0es+vq3eawqsbz9z+pf/J4e//19Ynn8hhUkS1tbQj55+s2HYjfiua+qaDCA3TE/JjO8fbhWcJWZpEUqZEhof9KpiVhkG3diz3Y648dpTXkXNay0zYQ431M0Vc6PaqtNYi3VOVpAalHOiToVIWgMa6ebOSTiLRosv1fZGoPd9D6imyErzTwkrcZpASUDFbwdqknWv9T2mH1BdJwNMzhKm8E4U0L5HOfFB1lIISyC8vUkv+bpIo1EMlGVF+wG32+J30nqkFFRjwXnSsrC+PBMPB1HKtPTRqyKA8jVOaGVwfWOARhlSjLf4/YZuM0pIyTmxFmRpI0rLSo5ZBkRncYOX17FzoocXbit40kJdCikrckzy/LQQV2n+RfGLtq76BqXPaJTKdPst2x9/ZHx4koBULWA1WvWE+cz521dOnz8zvZ4IswTFjLWMD3se//CJ3ft3WOdlwCwFXAfGk0OkzEdUTRJ4wkGJVG3QXY/1vSCYlnNrSIK0zKynE2G6UGvzKiZJgOuhl4KC06n5cr+TEKqqYgMYesE+RbFlCL3A0e+3TG9HyjS3sgUn6qt1uHHEDQ0dFOItuV5qIby+EY9HNOBbT3pcImGVwUtVaVPqNr34LJN8jnISJVQetyjfyii0s/TvnzC2k4rVOaJaOj6FgNs/0n8QvqysORLKaOK6MH19lv+/1fhNR1qDpPtBkFvz2qwOBWPl81NyYadhzwt/UBO/1JF/Ouw5+w3WeVTjeTrvGIYB5ywhBJZFWr+M1WKtaSzY8fbfxBauqmgvHfNCH1DY5r9Gqeb9NDhrcd5xvkxsNtLgtYYo8Hot4amu60gpEsJKDPGOb7qf+7mf+/kbnt9c8fnt6y+ylsuJcPrG5ef/zOEf/1dOP/8T4XLB2KYdVuh3W/YfHum3I9Za6WPXWkIIKRKXGVJCe1kjX7EyMSTCeaassnanSpCiAtob/NjjBwmpGGdRtZKWwDov5CA1hXltSh+AVmijm6dT/kFpQQoVWYnmmEVd1bSqyIYSqpVu00la2zmBm+dCDLJ6B0nol9TSvtZRSoPLu4Zg8l7+XLMyaGNxwyDcT9tqF7Uk8ZfzieOvX7h8fcZ6zbjbYLSh1Irpevz+kW67E5YqNOB4Ja6BcDwSjidqCljvqUqTY5DHmSvllvrV5DWQYkR5R7/b4Mf+liiWkAptsFhYThO1ZIbdBuVMa0iyNK8DWkkYCCXtOCUkwmUmZ0mAX2tDEViVsDdV82HmSimSZva7HbsfPjE8PooqSb0xReO8cPz8mfO3Z5a3E2ENrGtEO8v26YH3f/d7Hn74KGva9jj1uIV+J+rdfPpewam1/O7GUCm3MJM8nQLCT8tMPF9aa1YFSqsBlVV9zJV4vlCzrLhVlRID3XUYVbCdkyYrbaSZqo2o1ntBZxlDrYW4BuaXN8Iy47ej2B9KkVW71SjrUMZBjKzzhfXtIGq0FRU7zIH5PJFCxHmDca1FqSn5nbWkIDYIpUWdv3pwu90W4xx5kfIEbQWanxprtWTZHNhhQ//pE5unR0qYCW+vhNOFGFbhnlp5bVNILJeZdVoxWuF7g/G+eaoLuoH5rx4JZS26Fo7nwB+fM2+7v0O9/4mMYl2k191ojXPS0OSspdQqHtFGEfDe4Zpa7LwTVThnrJV761oKMWbsX6CXcs639XtpwUTnHCFE5mWh7yTE1vcd87zgveDILpeZ//P/5f/6r/1uvZ17xef93M/9/P/r+atWfIbnP7O8/JnzH/9fXH7+e6bXZ0rMKG2xxuAHz+Zxz/bpUTrKyzV5LKzEHAJxvpBTEo5k30t6eo2EllxP8yor0yLQcGM1futFibRGLumtxz1eFpbjhTAtxDXeErbG6gabt/ihwxglKfMkzM4rn7JqTQozTktISSF92MoZ+u2Aa4EYqvAZw7yKwtcGEJDrquu6NnSAd5J+L1WhrEf1nbARXSdeQetuF6UcZD27ThPT2xvr4SB+V2uxvqNaj97uGfd7fN8sC82ekGMgnE/EaSIvqwQ6jKZUK+iZLPYCpVqa2DlhYaaM3/SMmydMPwCKWhLkSE2ZGDNxTdI4VauwO/1GhvFBQPWK3HiahhoiJa43v65YJypGKYrS5JLQRgJhpXkm660MwDFsRjbvP9A/7tFO0s+1YXOWw4HL8zfO316Z3s6kJGtj4zue3r3j8Xc/sP/wAeuaIo5Fb0ewTkJcb9+gRJR1gBErgfegrRAPampBp0otQk9YTyfSPIk6WpGQjpf3QUqFNC+Qk4R1WshM9T1ut8WQ0e3x1QI1ihovffeNJVoquUqQSWuDf9zBWVNDIMRZMGW9w9gOZ4QtSqfpx5Gwe+ByOHD++QtxWSmtD74bJM0v3epVmsVKpcYW3BuEcKCswT/sseNAjaLmC55KkzOkkIjLQo3X10kTLifSHydYP6JKJl1migJjnBQ3hERcI3FqA60xaKspGEhtKPRibant5q6UwnqeWKfAdLjwDvhwmZnqK2/jDxQ1UBuxIZdC5x2VSpgDKSW5WWy4J3lRIaYk2xKlb8OmQkJRlXprQ+s6L+QMrXl5eePxYUOohe6GipLfcVlWsQs0ru/YFOj7uZ/7uZ/7+euf3zyI/tP//f8mmJgUhfPpPW7X0+83jPsNvu+lDrMKq6/tKylZAkIlZqrWaO9JITE/n0jnWVAzVSDotVRRyB5EiXQNWp9zJq9RciNVEaZZPGgxo42s2rURO4D1VtA/SgbQWisJzbok4rKiKlhnhOnohCWqrMYNvfy5tlIsMZDOqyCe4rUq0jRbgqhWxjpByVhpV0JpsOJ5s71UXFrr21pUCXQ9BNbzxPnLV+bDCW0Kior1FmU9frtn/Piefr9v0H7VkEJS1bleLsTzmRrDTVm8Mj7jspLbACKeukSGBoTvsA/iWaResTxJFKYQiUsQELzRt4CMtxrlHKb3oqg5AxjxXTY/ZzzPlJYq1k5U3kIl10wmywBcipAJnMd1nv7pkfHpHd1ugzKC55HnJrJOE8vrC8vLG2FdmC8rVWnc6Nm9e+Tpxx/oH/YY3zV5FTBW/lFQwwSxqXzFir/UaPnvXS8honJFE0mN7Ho8Ei8XQERq1dLm1TlpqLrMqCIBpKqkylR1ku7vd1v531uVprGiBlrvBcDf3tuC/yrkkkhxJa/Sba+pFKWFFOCMsFNtz1U+1trKz9SWkiHMC2WNgjTr5PGVUnBjj7UKjfS569ZGpHuP221xm1H8retK1aYl9RvuaF6oMYrvuZUjaGdw2xHrNNRms6hF6A1AugSW00xcBD3VDUK3yDVBSahGeiilkpe1DbyJ+TixzIFcFc6JP1urym7+wq4ciLsPHMxH4vCey1oIuVDhNkTWWkVxR0JdrimgORdQwpF11koLWoPbO+duPRy1VmKMbEZBO439QIyRNYS2oND45lnVDV+m283v/dzP/dzP/fz1z28eRNfjK0ZbxscHus1Av9vQDYOEcrQELWppHq5SoWYJrRRpJ0oxkaZIvFyIl4UQ8k1JxVjc0OM3PW7opAmmCu4nhch6nkjLCrW1GdUCSuF6AcZrLXWd1jdPmDGEaZZ0d0yEOUoyWCMsw9r4nZ3FDR3GC/6l5kyeVuKytDYmGZButaS1YJx4JFHS8iQIJg3GYIZRKiu7TlibXtK2MugJ4mZ6eWU5XVC54HovA2vv8ZudeD+3e+E+lkJJgbwmyroS54kUQlN+oChNWGYJ/+SKqkouxI29WhvQ3HknKf1OfpeaRP28cSdTplYEjm6aB9KZG9QeZyVRDZCLMEo3u5aMP5GD4JhKyiiqBJAaqL/mTLEG03m6zcjw+I7+4VH4kwpq1TLoTzPr6chyPBBXYYvGJUCFzeOe/t0ju48f6bcbjJcBorYUeClFakjFIUAjorcWLdfCPrQQTqaWJMPlNJPWmRqlRrQivFrtpF6zVCjrSo2r3Aigbn5iM3YM+10jDQjYXhkjPuKhx/adrNWVFr9uVZSSyWElhVUCablgegkb+cct2kkwTqn2WTLygNZ5YXp95fj5K/F4wVhLt+lbk1bGWPkMKWMwSHJdmJ9SBuB3W0w3QLk2UFXKX9SM5kX8nLo1QElphJXHIG8p+VyvgRwLeY7MF/lsqSp2FvGWigfYGoMb5CahgqivUZ73ZQ7kUPC+o9R6UyCVsXRjT7/t6brED+ozh+mZi3vHm97yPBcw7pZoj3GRm9OUyTlhnaPrujZpyqst6XlpX5rnBXMdzJt3upRCTJXzWdLyWl2RbDTwfcEYh9Fa1Ob7uZ/7uZ/7+Zuc3zyIPv30A77r8BvpJ1dcsSlFPJU534aioiokaRyKa2CdV0lPhyTwd6PwQ4frPf1OLtzGWGzvJLAzLZQovfBplmFSVUWpGTSYTnA+0uqDXIBa4Cisk/g4w7U+UxRH0wYi18vPNW0YombKKspnbszP1GopTeNzKuQCrRDAeM1QVRV8j++w/YDpvLQGOYf2HblW1uOJ5XBkPZ2I57O0B1XQztPtR/rdnu5hj99tsb6/KZWCgJoIlzPxeEJdfYotcBLnQJpW0rzIwKn0rcmntgIA4wy2d+IPREmNYwiUeWkWBAmOlVxbj7tBG3cLoklKXQvH1Ans3o6b5nMUqL6xnhIS8/lCCCsqa0lf14rSBj+O9E+P9I97hu22gdU1JRdiTMTLK+FyYT1fWE9nQfS0oXh8emR8emR4fMTttmgjfsDSYPJpmgRnlRNmHHGbLcZo6TI3DtX1KLQosg3tJOrmJK9FiqKUOodRhmokRFZSooYgQy1QjWk4owHtpatc1UINkVSb+qgt2lsBzTsZCmvO1CRhvFoTpWRJ1Zciz6uT8J7ujaC6GnLrihAN68L89sr09Zm8LJSQ5DkwmlQyCiR40zU/KogNQWn04HDbEdOwQ7U0T26SHvq8rMJARbUCAylQuIbRdKM9SLuV+I1TyqyXRdbwrQ3KNLSZthrj5cZOK/m7qtLEeSWu0iJWiyTirROfZ40JNzh87xi2A7731Cz+bOLCNgb86TM9I517z7HuWUqHHbYSZCuVXErDMMmT1nnHGiK+4ZtSzmzGgXEYJNDVKBcozTC4G/zee0cumZSl/tM5GUDneUEphXfur/Ntez/3cz/3cz//1fntg+jvfhROYhFwfE4yFFZK42Uq4RQuKzEkyhpYLyvrNMsqu618u52k3W3ncJ0A4EtM5GkmTgsx5oZ+ibJCb6xGe62GbM1IopjmNkAmcmrJ9yWSGjBbG43vnfys3ouC6izUIr7PZUVZuXDmVG4QcW1sQ6XWdpFuCptqwRTXCTdz6PFdf6vkrEBOmcvXb0wvB5a3A2ld0aZinKHbjvj9I267p9tusf0oK+OaG4N0IU0X8jwTG7ap5gJaVoQlXbmkhZLEEycoKeFMuqEXJVbpFpRBcEFr435e8T2dDJzi61No5xt7tRmLq3h/3f4Ju5Fgi7RTGRSVtK6E01F4lq9vpGURBQlR0/xux/juPd1+h+sHjLeyok6Zdb6wHA+Ey4V4OVFCIIYiLTd9z+bdE7sP7xieHrH9II1OWmoq0/lEOB3Jy0WsHij5d7PUk/rNRmpcu05ulNJCCUEe/7qSllV8yCULAF5bstJCCAhBQk1tANXOoK1DG4d1cpOhaDc8jdKgrcUOA9bKa6CsBI7yEiglUXNLvmtQrnW4V2So7weM82hjb0giSmWdLqznM/PxQDieoRRsKz5IsamvCrpBvKcKwGhM3+EGaRyTBiuaT1tsG2FaSJMo6DRFthQZNl3n8bsR13e3z5TcTGjiGlnPM3EKUKoQJOSDLxxSK8xVY50E5LJMhTktTKeJHNKt7lYpJV7boNhuB7r9IGxSreUzvEj7WGqKbcmZQR/p04Vd7bjogZUf0WZPsA5TDWtYySkRZO9OLoW5YZhyzlwuE5txFJB9ywyl5oPVSmOtqJ+13QQqJzt8126+jqfLfRC9n/u5n/v5G57fPIgqI17NUtqaqoVRS8wSGJqiMBenSRSQLBcG31n8ZsANHdYaSZV7i7aKWmA+it/zusLLWS4mxih01zHutyhjW8uJkv8uy4WjZGlJirMomrVUWcn1Htv772tpK15QSiUv0giUo/TJVzTGtbpO2oodhaot1a2gKOGH+s0G0/cyRHgvvlSlyCkxHY9MhxPL66H5V8XT6kZPv9/S7fd0D0+i3PlO/KS1kteZdDkT54k8z+R1gdavXbI0+aQ1Skr52hNeK0ojw8fYqjBVg7CX3AbzdBsoSoiytu9c8z86qdR0TelV4l8tSmGGDe7hEbfdoX0ng3jrVQ+nM/PbgeXllfV4FGZqlvDSsN/SPz0xPDzS7fe4rr/uyikpsxyPzIcD4XiUWsyWqgeF6zybjx/YfvxA//goVomrp3KV8oJ4uZAvJ2oUb6WgsqRQwPWjrNW7/ubnKzmRJ/HTpmUhx0huN0x27BvyK7amKzDXlXwWWLv4NUUNVUCNEsZSRgv1YNNhfCfKcQvX1dv6XVikIKEfqpYaV+/RymK0FbVSG/GeVgiXM/PbK2Ga5PWbVnnuncXttgzeMz2/yGDqPcZ5sEZW6cMgRAO5EyItC0obdOflhmuaSfMiN4wAiM/S9R63Ef6r9c3f28gDpQjCKq2BNC1QxGt8bT+y3uA60xqIIM4y7JcKZChV3hfd2Iv/WUvjk/WWbjPQjR47+MYEls9+KZkUAinI+x/M7YZpNJUHDyn+ibnueNM7DmpLMo6USwuzIf99KSzrwjAIfzSGAEpuoq21eO+YlwWtNF3XkYt8r+m2hs+5sMbIZhxxznCTx+/nfu7nfu7nr35+8yCac2opbFF1UlgJl5n5cGE5nEkhNZUlY7yl3430Dxu6zdBUOhqfspJjYn2bCJdVkEtZfH7GaFznGEaP772smI34vWoqrKcJVaqsip1tXMPvjL9SMrFk+s4y7DdSIaoMNSXCFIiLqCwKQaoorahROt9d724w/FJE5VUYTN/Rbwb8uME2D6iyFpQizDPT569cvnyV1XJIqJqlaajzDE8PbD9+kHpG38tgow0VJUPS5UxaZmqIggMqhZokiZxCIscovNbSKki9PG5NwXjfYPbSBlViJM+ifOaUgNLaqRSqc6LIaSVVngiUvRot0HOl0eOIf3jC7R9E/asFUqDkwny5cPryleOv38jrgqHchv5hv2fzux8Z333A953A1JWoyDlElsOB6eVV1M+cifNCSQHbmJrD+3f0Dw8ySFmLMl7Uz2Ulnt9Il7NQDmjYp1rRztKNG2zvMa61SSluDUnxeCDNk9SI1kqJqREeDKrvwFnIBWKAmlsDkUG7QYb5LAGra8FAbd5D6yy2Fy6s1rb9e+FapnVtbFIN+tpX30yWpaAq0qzVDZKGtx60Zr2cuPz6K8vbKyWn1rYl7FW/3bH99J5+t0Upw/DwQLhcyPMin7POY/tOBuh1bT5d1bCfmbCeyWuQKtOYyCFTgO5hQ9d5eTyDhNeolTRNN/xWRbXyiCQ1uQhX1zqLH10b1DXXOtiSCyW2G7rWb19y46fqFu5zVlTIzt1qekuMpDUR5pk4za04wqGyfAarNnQPW7HjOLEMbNTKPs5MHDj27/gSR14uhWUNjEPH0HfMSyHFSN/1UttpBKO1rCu77Zb9dssaI/OyYq1hs9kIWSNnYgPcn08XGUTv537u537u5292fjvQvlQqheW0ML8epVVlDe1ikzHO0L/bMzzthNuJrC5N68COMYtPdAnUXIlrpOaM7ay0q4ydXOCMaUEd8eHFUsmKlswuUqdpTEtiF7Su5NL4h6WirCIugel0ZthtSctEmC7kUrFakryq1f5hDV4rTKv3pgCGxgL1dNsNbhgFEWRlPV21ZjocOX/+yvz6Sp5m8hobE1RYoX7jccPA/g+/Z3h8AiSAUlIing7E6URZ2wCK+OlKEih4mBZKEjW5lIwyXtS0weO2A27om8/WtmBQIU8zy+lCuMw4Z3FjLxaGhrGqOUPOkqZvNZKyigT7+J5+t8P1ndRZ1kxdpdJyPpw5fP7K+eVVmJRBHqfznu2n92w/fmD8+Ak3jm3VScNiRebnr8xfvhDnqSXHC2ENcqPx4wfG9x/pdw/oThqlGi+JtC6EtxfS5QSq3uo+S4woq+l2Ymsw3bWdS1auKSzk5UK+TKQ5NC5obeKpxW08brfHjiNhnlleXm7BFUoVBJOzQiOoYoeoVYEGaxTWd9iubz9P1vl5XaTQoGSZOY0grcQHakSpNrZRDBr2vnFV1/OZ6dsX6YpfVmqzrwC4sWf3w0f67Q7beWGrKsX48Qe6x8jy9kIOC6bvqLmKWlsBZ4lrEhtGTFRK83o2vujY0z/t8dumVmekdjQnSlWEJbGeFsGIdQ4zdGA1OSSUUvRj1ywyEtYrreI1raK+u95ivGve8Cj7huYf9UMn3GAlLNvaFPG4BubjmRQiWkndqzSgiQ2g32/RffedQQrkkBh7y/v9gPaFJV349Wz4h5Pnl9NKruCdpaTM+XzBe09nBQ82zQspZfa7TUvXZ5Zlwbn2XaWUrOtzIcRIqZmhv+Ob7ud+7ud+/lbnNw+iz//4J5bTmTQL8ociF5lu7Bje7Rh2G7SRJiGtFTkEpudX8ppkdRZFidRGKiFt5zDd2LrhBRNUYpQe7+Zdy2uQIBTq1s1eSyHEhbCsxHWhpHxTdHLN9NbjO4eKmXCeZUi2HmdlgEBr3NDhrblhkWoDuSur8eOIHyXooYz0puMcaVk5f/7K4ZdfmV+PMkR7UWi0l25v6xy2hYYUiuXbF8FLjVvidCYeXsnLDEV4qBVNiuJrXS+zqEeNc1iarcFtN9ihx40e4zt57lOm1kI4zlJjerpQasZvR9zYGpeKXExJK0oh6/haqamCc3SfPuKfPoiiFmYZjKPURV5eXnn7+QvT24GSEqUolKoYZ9l8eM/jH/7A9sMH7FX9rMI3jRnOf/6F88+/oAiizEVRA3Op9E8PvPsPf0f/9E54nrkpwdqIgnd8JRxfb2UH2re611rpthusM9iHR1lpa2GZxtOFt59/5fTrL2hdGR4f6PpBHnvOuGGk2+8wvRflFIHYW++ZX76htbRt1RDaSluJL1UprBMribHm9r8B1FpI00US8AgvV1mLqn8RRGoA+Vpqu8mR92lcV7mR+foNVTNGces8t93A5v07hv1ebjRqFQKAdVSliNOZdDmLMu43gqLyhmotZV5ZTxfSZcZ4Kx7RKDd0yhuGxx3d5qo6q7aqTlQU61KYvr2R1yDvFSchtzxFlCoSRLIG47zgk0JAOSvkhstCnhehXWjxsc6nGa0Uw0684Ma7ZkXQhGlpFobIcrlIMCxluqFvqLIKVqwMruvAyGNXRpMaJmzYjvSbodE6YN9rHjaKv3u38v/43478fHbw8Am/2bDOM2tDTzlrGfqOECLrGvC+tsavwjLPdH1HrRVrrAQareF0uhDC+a/3jXs/93M/93M//8X5zYPo5csrKYpq0Y093Xak33T4zYC6XpyGnkplOlyY307EaZVWJG1urE+cpRs63DiiapZEcK6QxAcpuKUgfe3QwkNyQV+XWRSzWQZUpVX7R+NHz6bvRIGCW3pXNfUGreR3cK06sqk5IF5UP/TYzYA2EvbR1oHWzJeF46//zOFPf0Zr6ek2usrFtaGgTC8XW5oCZ2xLnRvF8voVczoATdUrMnSscyaGSFqCDBTQLvZWEFCbHjt6bCcVi8o0SPcaCaf5hrQyRtPtR1GptKHkFjRRCmskcKNqRRXQfYd/+kD3/j3adZRlol6OUAp5TZy+fOPlzz8zH4+iJDbl2FjL5odPPPzd37H58O6GLVJVGKbLtHD6/CvT12+ky1lKjKwlRVEWjZULu9USVsm5YkoUhM+6sLy8EM9n6T7vHGbcALRh3+O3D6IoqtpwTNK4dPr8lcO//Ew4n2RFjOLyNrN9v+fxpx8ZHvbYQQYWwQkp8d+mRJkn8QIbUShBwjlifxAPphZpTIbt1uKTVgmUlZLQzlDRlNCqPK3BDUPz1tZWtWrQxpLCyuXlmfO3Z0GRZYXpPKlGaqmMHz6w//EHnG8KNlUamlDkZWG9HEjLIhaGZi0oVdqQ5pcTZV6uoEziZZHGKK1xDxv6/YhWooQrkD+7RubDmXVaSYsMoNZLKCpGGZr94HFOQPwoRU2RdZ5liA2J0AZON4qKGdcWOvOOYdPRbVt9bVXSgHZZiOvSnhdFnALGgBsH+eyndPORG28xvZef1agc3dDT73ZY75p1gja4Ws5vRz7/47/gf3nhf9SGXH/koP8TgYHrRiLlgtaCmjqezux3W6yz9HQ4L/5XrXVTTRNPTw+MY0dqn8/7uZ/7uZ/7+euf3zyIaqsYxw3j047uYdO6wBtI/XIR7NDhxPR2Zp0CznfYXqo4jbcC6h47udhVCZOkeW1MUEOcAmkV7JJuqqBSikLmfD6JfywlClVW8Cicdfihu/XYa2Vv3j7VPJUV1aocG34pJ/GGtuSyHwbpEYeWXtbEELn8+pnL11emVxnKup3wTdOS0NpKa463Mqw0LIwkiL1A4L0DFCWK+qO0cBXDFJgPF8FKtXCEouL7Dtt3sn4fB0zfsElWPKVlXQinM+vhLHaInPAbj/VOQtA5U+JKLRnbOWF5GuGrmu2W/tOPuIe9JP/XVcDvJRNi5vT5C4c//8xyPEqjkhcPn+tHtp8+sv/pR/qnB1nrx+ZlrTAdz5x++ZX55RWydK7brg0PueJGLwO+95AllDL96Y+Ew5Hh6Yl4Ody62o1z2Ov6toHFTacxThRe8U9o4mni+OtnDj//Sjif5HVVMlxY3zE8PfLu737P5vEBRfNplgrIzy9R1LFKQfdS6ZhzY8x6jx1HTNeDNi11LjcuOUZSXCgxglH4cdPqYBO2FyuH6fo2nINSBuU0cQ1cnr8wH9+I8yQYJjTKig3Cbbbsf/qR8eFR7BgpIf4QqbXMKRDPJ0pKYg1oyK0cEuvxTJxn+T2r+Kjz1fPbWfqHDbbvqUluCK582bQkLl9fiLNQGUrJYs2oipyrrPB3I0ZragrNEy681RQKaRUPpdIaaw01SrhIOUv3uKUb5HOO1o1ksQrCbQ2igEvbAtogVhNAaUXfDZir6qw0pVWjal9xw5ZuM4hFKGe0teSUWS8zr//0Zw6fv5FDwA+eimYILzyeV/7w7ve8bD/y8zmRq0YhAat1iczzTDplnHPEZPDe45xjs7HM80Jo4St1jdvfz/3cz/3cz1/9/OZB9MP/8JMka4tghKoxVKVYLxPrUYJHteFius0oDEtncN5JxSEKXQrxOLdksnjXSkzkElrDj3jtYs4NoB0JIRBDEM2qQlWKru8Yxp5u6NGNv1grVIOs043GOVEkaxIzZC2yPjVDj+tHCfqo1oGehCG5ziuXlwPT8zPhcqHWitFGUsrGojX4fSfQ+FrbcCmPw1jbIPYOa2zr2UY8cSESLhNxXslJQNm+U+SSUNbT7Xfsf/yAclZ67BtcWynxqy7nC/MvX1FGiV/UAloCOrmWNkC3IaRW4rJifIfe7xh+FJ+qokJYqFX4rus0c/rlF05//oXp9Y1Soes7KRXYbRnfvWfz7oluuxVFsWRqKORaCeeJy+dfuXz9So0JYy16kNVrNQZNFR5j3zdFSzrHlROPLuvC8vVXtPeYvoW4lCTgTddjrbBbqZlrPWe8LBw/f+H46y/k8yTQ8VzJRWout++e2H36yPj02G4OoCZRskrJEl6KURR2a6Tv3DpqrhgUtmG4lBPWaW0qWF7mhhUKsibX1yBWgpyxXS8c0EZBgIoqlVyEFHB+/kacJwkvlYoxFuUcfrth8+ED/aapv0VUUKXFS1pqboUGi9xU2QFlDXlNrOcTy+sJUhZVttEjUiz4bc/wbkc3ymBZchEvcQzUUImxsL6dycvcPNUON4ivU2lNv+txvdAVakzUInSGmDLLZSaFgPcO660MsU29tZuebrfFdn1r3sotjLeQUyHGeFOIC0LbcNcNhlZYbyWolaS9SjvbanoFK2W7TnzhWqO9I4eV6Xjiyz/9zHI8NTpHL75gJTeaDz984N3vH4DEr2+Zn5eRbzNMq/y8l7cTnz6+o+87AeTnzDTNOGsxRpOLNDXZO77pfu7nfu7nb3Z+8yDqxgFlZaiKp5XpbSYugXKF1DuDHXthfvZOPGNtrZZXYRAWBbm1mtRcb4gnTGOQxiC95SmSWkK6ZFkzywBm8Z3He4/tnbQBIf3VFPDDgHEyNFGKhDG0xnQdZhxwmw22k8YYsiirMWTmw4nzt1fm5xcoSVBN44Ay4kt13jSWqKw2S5KmHWvdjfHIFTgfM+v5TG6/e1oTaW51jtbgeyfNNUNPt9vQPewxw4g2ohJF74nrKhYAK4D8zcMjqsByOAh2ySrBzKyJmqRzvGpRDE0vquDm0ycJiLiBWhJ5WUiXM+Fy5vL6xvT1hfVyRmnoNgPWd/QPD4w/fmT8+Ak/jqJ8ZmmvKSmznE5MX77IajpmfOfR21EER9UUZyVIK0H2VPHwao0Z3Q36T6ktGCUEBZWTNEttdmIlQCwOOUM4nTl//cbbn3+lLBPWihpdlKKzjuHhgcefPjHstzI8Vai5UFVDfEUZIgul2TLkZkZb3xRGWZ2T8y2VX0KS5yyslBhuhQHSB6tvwSPTjdhhAKAimJ+8LiyXM/PrC/PrGyXJoG60QXuD320ZntqAL0yjm3cZ5LORm3e25txUTEGahdeJ5fmNPM2UJJgpndqf7To2HzeMjxu00hJAKlJPGVcJGOal9bNXqdKtrUVJW4PrvHB7r9sI60gNA7Z8vTCdZ0osGIPglkJAGfFbd/tBAmtK2qtKDNR5Iq5BrBhJviOUalW+tQoHtb8OrUoqV5VguYx3mHGkGwQtpb1FOd9sLYV1Xnj75Qtvf/7MOotf9RqM1Bq6xwf2P/wg9auNJ/X7R82PeeHz68o/x8r88A5VMsfj6da45JzFNdLEZVpE7W1q8/3cz/3cz/38bc5vHkTnlyNFKdIk7SoUWX/bzmOcwfQOP0pdprGi0sQ1SsNRauu465CQy62iMAa54JYsne61VLSW1piCAqfw3tIPjRGpxHOqvWtJ47Yirwqlm/oJGN9juk6A41ffnjGUFIkpEy8z0/Mr08sz4XwSQLkz2M0gtYVaCV/Rymq21kpJlapFrTHei4Kmrt30kTItpJzJqRLmlRLLrTrQdh43SD+5227xe0lE0xbIJYlv1fgeY72EXowWIHqF/mFHigvLYYbQ2Puahgsy2HHL8OE9m/fvccOIroUSVxk+p5nLt2/i4ZxnwfwYUa5N5+kfHxjfvWN4etcUSid94iESp5n18Mby9szydoSchM869KI65vod+F9bIM1pqq4opENdOWGuXtmg19c+x0hZFmS8lxYnax01JuLlzOX5mfPnL/LcxiSFBN5hx4H+Yc/wsG83Hy2Ipiy19bjLGjmgdL35JbH6NmQZ5wUTZJyk4yvUGEnLJHYRI4MhShEuF4xzuK1UdxoriqFYjGVQTPGqVH5lvZwpWRBa1ktIqtuM9A8PdLu/GLZzbt5VaWHKKZLW9RZak+J7TZhXLi9vhPOEaf3nteRmWXD0Tzv63QZ9XXl3hqosOc6ENbEeJ8qabminVNpg5Sxm6Og2A4pKWVdyKdTiKNNCmBbCZRbChQKjrkO+wvUd3X6D34wY2/irrZksp0hOiVwrKcln2jkrn22r0VYJf3cJ8tprRQwV7S1+HOi2G/wwcFWItbXCWp0Xjt9eOPz6lfn1iNIV781NQfXjhu0PH9j9+AmjjGwXqqi+aQ3Mhzf012f+bo2s5Y2t3/BqO845MAfVGpoUFfGq1lrlRvO+mr+f+7mf+/mbnd/eNX+eRcGhClLGCybIdRLaUc2DWXImXFZRlWqlNDVBVmYSRopLIEWByteUbzY+pRTGSVuLUrp5OzXGeaw3gnay+hYkuVYTooqsypVCOWEruqExNqFBrjPxfGZ+Fd9neDuQUxAFtxO/q3VW+up1A8er0rijCmUMbutBy0VUtz7znAtxXgin+aYMxhCpSeDZrvPSqPSwxW83Ui1qpE2mpiQDi7oqruJ3vA7ZOSaWy5k4XYjTRFlnqKJyaWNRrsdu9/SPT/iHB/nfamnc1Inl9cD0/JX59UCcJigF42Ut7LYj/f6Bbrel222Fj6qUdHkvM/PhxPT1K+FwIK0zikpOFeuEE4lSjbEp3QaqVmqRd5QwXmX1bZy9eQLzupKjsCNLEQVSlSo8zcMb6+mCGQdpQWq+4JollNZtB/r9nv7hkeFxj+v7hkJqr29K1DCTFlHiaOqZduK3NM7LulcZlDUo26D5pUjffFgpQZp9lNGQq/zaSXiWbrMXZqmxKNfJe71k0rKwThfmt1fyNFFShAb5N/2A7wd5nve7FjyDdhshqmXOIlKWTE4JhVhKcoiEeSbNgeX1zHq54Dq5Qcil4PuO7mGL3wpeTNdCVYayBlRVrMvKcjyTpoWaC9YZlDOUIh5g04gMxmjyEojTLFYIbdrN5kycVkotfzEUK4xzdNuObrfBdB0aLR7RWdb2ONtYuRmUlkGuvU6qhaWUkjILsWNYwaZZQ/ewo99vcdZd71vRzlMLXF5e+PYvP3P6+kLNiW6Q7wQA2/eMHz+x/fBeQpBKQVxl1U9lOV2YXl4J5zM5SBObT9/4nX/jMWq+ppGDfWBhS9bb757rIkn7rvP/9m/Y+7mf+7mf+/n/ef4VzUoG2zlsL4OeuVYWlgo1k1eBhkvNX+aaE5FWxCKd89MqLSctPFKSwMK1NW1FKuEHbbQkqLUR9bNz+ME1L+F1YJMLmrK2rXzFo6mNQytZEZcUCevKcrqwnk6sR/GspZhQBanp7GzzYl5rPCWJLzWJ14uoERW072izOCUmUYymhTgtlCwMUWNa8Gbj6fcb+l0bQL1HaSWDefMT3nrilRKFTCmq0qzzynJ44/L8SjyfQX1/Mv1mpNvvxTv3+B63e7wpRnldWC9n5q/fuHx7lrrQRQYRpQ12t2F89yRK4m6LG7doq6lVUUsizBfi5UI4X5heD4TzhdxW09pprJdB/YpBopSbd5dWFWo7hxl6CcwY254ssWdIFahqwHhBB5UWYpKWrCPlS2pmYGlOcoOsfcenJ4anJxl+tITkSoq3Py9JdLEQVJqdw4sdQPyf3W2guoabypooNZMXwXwpoyAr4mWWIE4/YLuebrcXRV2BNo6qNCGsLK/PrAcJIdWa5cYkCa7K77eM79/TXe0gjQVKq5PMUViaKE2l3MoichHs2Pp2JC6zVJmmLKGsKrD3zX5DP3YY0z6+OaM6R6mGZQrErxICq7nhiYoMu66z+LEXZXnooGTS6UJeY2N8+hvLNofYVHdDVeJt7QbxENvm/aVUapE1fQyJFAtX8VluFIGim3VW3uM1J6kK1oJo0t5gu5Fut8VvBnT7zpDyB80yz7z9/IXDL19YTpNQOzovWxCj6fY7dj/9juFJfNAVIEaUMaS4Mr9K1W5eFnQW64NYaSBMC8txZlefedwemNOGU35i3nzgVDUVxeF4ovP3QfR+7ud+7udvdX7zIDq822K0YI2UVqicSWsghladmLMMAaXKGtboW6p1vkyEIMOG1QZrrQC2nVT/GWdF1WnsRXMdTBvk23QeY7WEmKs05Jh+wA4jrhdf6nWIrDmRpgvhcmE+nJhPZ8JllrRzlf555x2u63C9uw3LAj5XGK0b9L79v154oqaTNXxag1R4Bkn5r5cZcmmeQ6kv9LutDFB9J6gdaIB6uUprxA+njLsxUEsphMuFy8sby+EoQ+QqIS03dpihp396z/j+CTeIp1M10HY8H1kOR+bnZ9bDgfV4kuHFNCV3s2V4/0T/9ES/3WBa4AYjCtlyOjA/PxPP0sRTU2p4LOmyN0Y3tdjLgFBlwIEqNyhtsNFGN9SmeClLaraLJF5WIe6IAlqLIiepdLwOlCUXWS1rje46Nh/eMzzu8NurAsoN0J6jpMlzasp7IykoazBakFy26+U9Zf6CA3qt4ZxmYYAaTU5RWo+0bdtwixsH7DiKcqrMTRGMKbG+fWM9vkqdbRAklzJQyXS7LePjE91uJ4Exo9sAKsUPtbau+isSSgEZQAlj9PmV9XCWTUHJwtEtBTt0DA9buu2I2/Qy0DavsrKGOK9Mr2fC8Szeaw26Ngi8c/hNT7ft6TaiGMYgtbhpDd+V5VJu73ttjHTAtxCPHTx+t8F6J2q+dOwSQxIEVEzy87IEtWopGKexTr4vpOOzUpKsvFUVnNj4uMNvt/Le0ka8w9qQ15W3P/7My59+YT1N1JxxxtzUeOM79j9+Yvv+HXboG7ZMHitasZwn5pcX8rzKJsBacg7yHq2VeVqIS8CgcZ3FEOnLgXE6ETmwjO+52EdekyGkO77pfu7nfu7nb3V+uyKaEsoaapLVYFoDYYmtOlG3YUB6s9W6soaVMAXCskqFp1EYa3BOQNVKK4GJe4vtOlFFaWtdlMDBjfgkdavqNN5gm+9T+64NGFLdV2JiORyYX19ZDkfCPEnrUKnivwS8d3RDU0+NaV5FWWlqZ8TP6Syqk9W/dlZUuxiJ5wvxPJHb49VW6kilFEgxPGzpdyNusxH1Stu2vi6tb7y5QTPUlowGWe8u5zPzyzPr4UhchT5QUkZbQ//wwO53P9G/f2qrYY2ygkgKpzOXL585/fwrYZrE12pFVS5aY4eBzYcPjE8PuL5rQ5Wk0XMpzN++MX372oaX1Hah8poYo1BJlFjrBBOlqNQqNxuikHtsL1336po0LzJw5bxIb3kFkGBaqZUco/hEr37DksRvfFUx+4HNh3eM7z/Q7/fNXiEKOLW29HtooP3chqgqQRsj3mFjHdp6aU66PtNKU3IkrzNpWWTosqKaow0YITv4sUc/uKaa6TZ4Q4qRy8sLy+srNYcWWBJVHmvx25Fx/4jfbOXPWfudMFEEraWshZbAFluJ7J/TGpm+fhPlrgWESBI2Mn1P/25Pvx0xWgni6vretZUUEsvLUZTvmG9q/tUm0m1lALVWbtbS1Drnm3SZUsGojDH69p431pBWy3w4S3tarUynmZIr3ban326kcvdyYZ1XShYbirFWrCxW/m7jLdZch3io1jQkVWbYb+n3O3wnN3ogzyNGM70e+PYP/8L07YW8rGiBEUuTGsIM3v/uRx5++AFtNKWprUorSqpcnl+Ipzd5nFnYv1hNyYp1jkznNpy2prGqNaWCtYaHTYfrCqU+U+zEV7PhH4/dv/d79n7u537u537+O+e3D6LKEEMhzHO7uDafm0J8hUFW7yUlKJFSKikV6Y52VvrjO2FKWucEjWSEF2isRXeyutZF1neqAemxDu07/HaP7hy6+TVVU5pyCKzHA+dfvjA9v5Fy68Zu4HgN+MHhnL2pMzkXYm4DpXPSke6cKL7OoToP1hBPE+HtKGvKFiwxzlFrJseMG3rGpycZjjsnAw0KSqLWDErUI3VN3lYJi9RqqCWLEvn2xno4SrCmIgO4M/RPTzz8/g8M79/L4y1ZhiJjidPM+cuvXH79lfVwasOutOXEWLEodr//kYc//McG3c+tjajVb769cnl+JoeZsiaoEgi5rohLkdCRdYZSZODKKcvvZmXAdVewOrTnuoAxpGUirwtX+lKOqb1/IKUoq35AObET1CBKqB17tu+e2Hz4QLfdoXtR7lQOMpjHyHo6yvurNRFxrZF1XkJernFjjW2rcKEy5Jwo84UaoyxvlZJmoBBJ60L/9ITx/a3EQDX/K0pA7MvLVy6vz6QQcGPXMFtR+uD3O4YHUZq1sbfkvpAcCqUkeSKsKNC0alqyIsXA5eXA/PWFvK7tv5ebJm0Mm0/vGd8/4jtHjhlqIs8LYZ4BxRrEHqJLwXiPthqrHMoatPf4zYgbvCjYMRIvk7wWxhJDA9mj5HerAuAvtZJCYJ1myvWzFBIlyWefmuXms7WCUQu+81jnRRV1hn47tPBaatgqCRBWVXF9z26/E6qGdY1IIJ/nFCOv//gLz//wJ+Ky4L0UHOSYoKHLrJOb2Xh440Slf3yHGwaUtSzHE8vzF3II8nNrbWJ0Zb0sTJeFdVmxSuGGnrAGSmlDtLds3m3pNn1T5jNaJ/p64P32npq/n/u5n/v5W53fPIhOh5P41UqVsIeRC32cF6bTTFxEybOtC17pirMG/9jT9R6FwreASYxtHWgMWhlRsJQWn6QGTCcX1b7HjhsZIFHogigYwHq+MH17YX59IZzPEpxBEtG5gDUW5TTWgG5Qe5SSJL5xMhB3goFS2pDbAFCBdBE0VTxeBJ7tLXrspT2nSlire9jhxlES1NeVItegs0dZd/MiXodEKsQQmF4/sx4OxHmmlChe2VwxnWf89IndH/5A//iEyhI8UkqhuoH17ZXjn//M6ZfPxHnBOovrnNRjrgGjHMOmp/MGk1bSdMK++wS1EKaJ88sz4fSGLoW0SDqboiX00TrFybRaSy3qZ4VSK840QoLvxG+JooSGPEKGvdoQSAA1ZkqplJpbr7gMBlppYa+mTEkVjOHhdz+y/fgRt92hfScNSEqBqqSwUJaZcJlkGDYNn6RAO9dCaZ1glayjhhWMrL5LyaTLmRIXmqQqQHOlyfOFkgQb5fotqpN1N42Fm1Pm/OULl88/oyjSduU9JWbiMmF9z/6HHxkeHzHWwtWvWXIb6oKEj7TCuI5SIjUGUMKnnF5PTJ+/kqZL8zzL+1obh9t4xg97+t1OhuVpxmw2GNMT54n19UhaAyVJOFA705R6he48fjfinEPVAmEh5UINCWUsmSq+4xCbPUO3RrMCZPFNnqeb2qyun4paMb4TnFIBbZTctA0dxjpiSthRmtY0oAXcS1FZcLAoaWNrXNqbZxb5e6bDia//+99zeX6VggcnFh2o1Grwgxel3km4Ka+hocTOdE/vQRnqcmlDvvhqlfM33FOYAjVEOm1FCa+twMAZ/LZjeNqKctoCVjkmSsikORBejv/e79n7uZ/7uZ/7+e+c3zyIxjZ0uM6hjGZpydocIyVlGVQG31Z7Ehyy3ssqsSXEm0UP1/XYoYec0W3oqDFRDbjNBrfbYazHmIZNaS0uOReW5wOnL19YXo/kJVBbkEZZaUxRgDW6ge4lrV1F3pO1v/Mt3CSJ25IKtbXG5IYJqqU06wCgrcwnsdBvR4bHB9wwyP/eBqqahQWpnRePaS2tAaZwQwAtC/PLC/PrK+t5oqxRfl9jsMOW3e9+YP/73+G2e0BR4wo1gbcspzOv//hPXH7+mRwT1nv6sW9MU8H4bLZ9QwVJyENpzfr6Ij32y8z88txUHrkBsN6TQpFhr1R0KnjXoY2j1EJKEWhMR2Pww4D2TpqtUoYiz1cMsmo31t6Gi5IKtSpyTqJOXfvYlWq+RtDDwO73n9h9+IjfbMQ32CD9KifSuhIOz5QYRKk0Gl0yGL5bAkyHoqXHammNVj1lnQmHF9I8iX/XWaEdGKleTZcZ43r6jw9So+m8BOhyIefE9PzC2z//kTRdpHO868jXOlZtGN+/Z/fpE7Zva2Vj2xCbiMvSAl5tUDPNHmAMBc30cuD086/kZcHZjn4YCSGQQ6DbjIw/fJBgXqnUmMnzSq0J03uW85nzl1fSEtCSyMOPveCTSkWPHd3oMcajgHA6CXXAOVTXsV5mwvEiirQWK4zK+YaIWi8X8eyWFvoBlNH4wTMOHc55GfiaAm6dRTm5ibPO4TvXVEi5Sa3NqmN8T7fdYFvpASgJ91EppvL8Tz/z7X//B9bLxLDvsUYR5kjJ0I8e1cgcONma1JLa50a+b8LpePvsX593bS1hXpneLmIhEplaeL25YKwWP/fDBjf4W1GBNrJBqLlyuZxZzzPrGv9937L3cz/3cz/38989vx1oP1hq0cznhWWaIRWsEeyQ67SwPncjfjNQagvlWPlir7lQW9e8NRYayL7WCrrKhWP7gG/8QK01JSfxnipNWmfmb8+cf/3CcjoBuvXIO5QyaAXGaPF8KUlU51zA1Abr7jGdl59jLJLYFz9jaq1HaQ7NLqAbb1RmEz/2bD48MWy3LSihGzsSQImftD02kZZKS3QLmicsM/PxyHo8igqZ22rTOfqnd+x++pHNhw/YceSK9JFLtGJ6fePwz3/k9OUb67xgjKLv/O1nKaPpOo9pYZAqyS9KhXVJlLIQv34jx0StqtVtWkBTcmMkKqQ5xlhZIaeEykhFq5WqUqVVg8MnqmoUhOlCWldRv5QRn54ulApxXeQmoa3lSysCUM23uv3xE9sff8T1MtBjWwAmJ/LpQDgciOeDANn7Aa0NKkWUd8KGdT0aIAaUH8BLSh+tyPOZ8PYsLV26YrylKvEeS4uPwb3bSLOSsVQrNZYlFKbXVw5/+iPheBClbCPewLQulKplAP3xR1zXy/OvxV7AOpFiJswzOS2AljYxY9ClkFNkvizMX9+I54uwU3UlpFWS8J1h++k9w7sHTEMSaS8r9lIiOcD5yyvxcCKuQQgI/YjuHMoqtBLftfFCKigpk9b19vekXFlfj9SY5HUw4tU0CHv3cjozHc+iBmtRwHOWQXPoO1znccbL+7KKJUcZaby6vn9UUaJCaqhKbCzKWNx+K7YFrcWbnIIQEazncjjy+f/9D8wvbyhl6IdObDslC1bNWpSSVTzm2pYVsI3jq6xBWxk64xykvat9fuO8cHk9EeYoK32rWUMmxUg/DnT7kX4/oLWlpIobxAJELaS1cDleiMuKUprt4+bf+z17P/dzP/dzP/+d85sH0bCupMtCKWBQ0PBNtnN0vf9ecWkMuiq0Mze0jjYWq8UXWdMqpTpKqvr8dot/2OM631BQEiLOMRHnmen1leXtQFoXcqzkXHFe/n51bYFpzNFr+r0ieBbT93S7UQatUm8Bl9oU2LSsxMvaFCCFMaIWYi3dpqff7+h2G7lApUyticaWQXuBziujRQ1LwsfMUXyHYZ5YzmfC6dx8kjLM2a5n82nP9ne/p9/t0N6DstQqHdq1VFKYiKcjx5//zPHzr8SQ0FZhjKMajes9rpMhqZZM1XLRp1biNBPmtSk8ihiSJJStIcYotZpWYxQNm3X1RMrwoL2XGwzVqAFaPK/yWiZyWMjrKkOlFf5qzrmF2TRpXYjnRVqtGkCeUjDDwO7HH9n+8FE8fdqAFs4jOVCWTHh7Jr58u/lxtdGonCjZYvoB5ztMJ/7DmgKopnbXQl1X8nKBHGTFalTDBhVMP4gHVLcWJa1aRaqmTBfm1zcOv34hHF7RBvqWLC+txtVvH9h8/ES32bQNv6zvaw6kGGUon2exBlRp8knrSlomMI7l9cD8cmhWiIJSLUKlwO1GNu8f6bYDmtpuYjLVS4PRcl6I55k0rVQkvHQdcnOtOG1xQ0fNirwkCg2KXzXKGVlJxySfOWtJNZKyILLWNRCXlZQSpYpqLTYR8H3PsO3xvqMfB2lEu9ouQLBp3mJtW97Ha81spRpDt9vQ7/ZY7/+CGJDRxhMzfP37P3L685/RFPqx3UigKDFjvcX7VijhPWUNwhmuBTDyeWleYG0t6TxTi1g1SknMr0fm00StCtv3eGuAtuXwjqe/+4nNhydyWAnnSWwe1lDDKjeVSmGUoR9GqKKS38/93M/93M/f5vzmQbSsoiygCrUajLP0Y4/vvSRaUyWHLO2NRtbZkn6vqJSoWlQ+5Tx2M+AHYTQq75FqQ1n5hvOJ5XhkejsISigKnkcpjba1IWEadN7KKjjn2uDqlZRFgaq1YjW47SAXyHkmzmtTMjUKgaBr75oHVdiHbjPS7bcNFySqDyDBF93aeJQ8Lqp40UoMAlKfLqzTTFpW0rqQQutY1wY3jgzv3rP59EHCUbYTCkFFajSXmTRPrT4zQK2Mm4H64R3HlwPOGqk87FxbH8rQrq2mlEpYAmlZJbWsFBXFugSUMnRDj+uvtgkJZZVSb49NVYVyRuwUnW88TGn7KUlg72mVwV1KB0SVTQ2dJInkTF0DOUiQTVS7DjuO9E9PbN6/w7dQCY0oUKKspOP5RDweIUtgC1Xbut9jNhts36O0xXhpaRI1Um5ccorU6YxqdZaliDqsWxpaG4PfbNugjoSVKuR1JhwOXJ6fOX3+SgkBP3jpNK+iLne7DeP79wwPD2LDiOnGfs1Z1vBpXWTY9Y6Kbq1hwjgNrxNxERyWzqX5ohXJGLr9ns37R1znaWgBqtbyeYiR+Th9xzjlIiQGe1UBLaZzdLsR4xwlJdI6yw1C8yankiiXVZ5PuGHCamnBpXkV+kCtsubPSiwaWtONHd0w4GxTmZE60auH1jhHvx1RSm6eJDwmK3632+G2G7rtRvi2pbTVQkfJmePXZ778/T+RDkeMNpjeYzp7UzN9332H4NdCang4pQ1u6Bs+6iaxE08XSghUY1mPswzuc0Rpjb9+VnVFWy+tSz99xI3S2uSGAT+MxGUhzCvaaHzX04+Gcb8jLCvT24Fwnv/937T3cz/3cz/38988v30QjbX5sDT9xtEPPaYhYEprTTKtbYjWoV2ypLBN32HGETeOkra2rsGu5cIY5pn5eBLo/OEgvsJKUzsbIqdUjFE458XnVa/tLDQmo5LGppQR3I+SQMPrEe+sKJoFCbXQakCtacDzTlqithu060TllNJDALnwYdFXwH1B2JcpkFuae7mcpTmogipQIthuwO32dPs94/t3+M1OPIOlhYBSIa0reboQjgfIkSvWqdZCTVHWlZ/ecyU+qabolVwoIRKXSEriacPqtuIWZdUPPb7vsU58joL9acns9ryarmvNWC0ElCs5r+Qsg2i8zKR5QWvTgllSfRnXlRhje53UzY6AUnS7DX67o3/3juH9e7nw18o1LlTCTJoupGUlr4us8IsMeLVmcoGcK7ob8fsnGSpjas99FWZkSRL+yUUGHquhiK1BOSura+/FbtCS2fUK1p8mwvnM8vbKOk2oWnBefKhoi9/uGB8f6DajeEhrkfcb8trluJLCChRs50UpbFQE03vi+cJ6vJAuawPdQzUarMUOns3DnuFxL1uDdaHVJREvKykk0hLIqzQ0yQpCC47KOXRn8GMnnyNj5EYoyOuAta2is0ipg7PQIO4ptr83RmoRCoTWclNXSyEbsFpLk1DfY9r7VBkjN5VWo5XFDqLIqpJpYz0lFUw/4h/2dLtdQ3E1JJaVf79eZg5//BOHn3+Gkug3PSkVlDe3BjU/dGIdKbTnOVOrqPSCeXMo69pwWyhLIC8rGQjzzHKaKEmCisZaFFIX7LcbhncP9I8PUqvbSiVyiG2w9gxdL7+3fOBxRglLduh5+/nzv/uL9n7u537u537+2+c3D6K2F0SRUVrseFq1lbDBGFBKUDq1ykpUG4MbpBfcjqNAz61UV9ZcSCmRL2fSujIfT5xeXsmzgLHRCnddeWslbUv+mrQVRmIVyVXY6W1wNM5StZELUBUFSqMavUj8dCjVmNmi2PlxwI4D2rVVdy2y1tTCJ1W0obcWae4pihwD4XySJqJVkFU5Rblwa4fdbOg+buka2FxaeWRQKiVJ8GU6k2YJLV3X4mjT2oFSszHIxd74FuJpzNR1jTL0rkEYqVfUFTRlqanV2xHrvFQu5iL+Uw3WG/mdjL0NxrSVcEnSlCMoIQmoaSXKcM4Jovw9MTTovRI+rHYGv99KDefjI363w/bbxphta9t1bcr0WRBPGLgl6jM5RHIUn2muoE4XtOtw2w2uG6SUoARKyeKQUNIfDxJgyctCrQq328r6usHiK1UKCKYz4XQkL+Kf7HZbTO9Z3YWaC36/Z3z3jq6xYGtpXFTVglcpUlMb4oyi0jrWq7RKmU5S5a4bqBni+kxaIsZKnabfb/CjxxkLOZPCSgkBrTUpJpbzQlnCzfJSk5bkvZfPkd8MWCOWhVohL/LeK7GFcRRQmiLeDJw5F9Z5JszCD1VI4r1gxJ+NIMlc45tew4NoLfYXZ8R20/Xy765wegSor7TBP+3oHx9FTY5RvKINhRWnidMvv3L+8o31cETXKv5OYzAkjFK4lpDXSkPMUiuKfO6xFuU7CSTmZm1oYbycC+sSiUHaqox18j3Ubmi0dWw+PDF+fJKglHA50CjyOpNTlgHfyHeGlFpoIQkoWC4Tp8/fWM+nv8qX7f3cz/3cz/381+c3D6J+kIuH1oYrjUiCAbZB0luStR/QzuM6j/a+KTnSpJRCIq8LOQTyuoga1HyeXd8RGp/UWIN3tl02VFt7Qs5FcEdVhjJtFBSFGzwVGRZdBlVa6Kj5zpQRxUVZgx06XFMJBYhvRFVtfkBlWoUo0v5CS9NmDev5TDidCJczcZklBAQoJcpq97TDDyN+s8Vt9uh2ca+lkONKXiZKCs1LGijrFfjeeKw5UuPa0vbq9rMVEiAJ00paFmIQBS41RJI0H0lloh173NDRjT3GW0qVttXa0uOm963/3bTWoyhVlyW11W1pvfHNrFsVKWfyGskhCuvU6KaAlnbDMbL59J7h3ZMA/bteBnglnsk0T6TzkbxM1NgGSSXKbo5BMFClfme/Oik5MN4QJ4Htm4f9rVJUWyc3PGGRFqjmPywxiN3gfKD2G0zfQynynM2Xm/oqbUfX9/VIt3/EuK6pfVa4r1SwjlKqvHYpUmpBF0F41bZy1r7DDiPGe4xzyI2DME3ddmR+PcjKdxywTtL1OQlKKa2RtET5WaWicmkKPzfLQ7d/wO+2YslQUq5Qrm1VOZNikhBZY2ZefdJQpanpcCYsq9AkrKHkSlizeLS1QluhIkj4TWGMFV+v1thRBut2t9c+jVWUZ6Vx+wdcu8lUQA1SB6uspdTC9MvPnD9/ZX47iFpOk/WrfOZNb3FewkYCmihNpRV1uiLfL9r7xg0WK41CEaaF6TixTgtSduEx2hCXSFUw7LbsPr2jf/fQXhd5Tiq0DY5G2VaUkLP4ga9BxQqnr8+8/sufWQ5HjNP/lu/W+7mf+7mf+/kN5zcPonKhldW0vgY22pe3dg7rN9hhRHe9DH1SOA1KEddInC+ky3TzlFGhKgO1CMoI8J2n6zsZBhHWUwZyqTesjHGtm72xF1ESbFJVAgba69uFWDbrCtf3dLstdhhuagw5tRlQtcBOq2IsWeDxf7GCDtPMfDywHs+iQsUoAWPv6B52DI9P9A97nPdt4PXCMKyVvMzE84myLjJoIYOGuoK+W7VlaRxO3RpulFKixMXEer6Q1oaWQgJbMUjApB97xu2I63pR5XoZ4NAtnJUKaFmpXv11JWWorac9BMqyghHOaW11hiUX4ir+0ByjvNZVBqSaCqUWuu3I9tMnNp8+4q8qpDHyutdKnC6E04Eyn6XBKAsoX9BakNdFQjgNqK+MsEO5Nfw4GUg7D1mUX4y9/dmyTJQqChpKxoyaK/F8JK8LZu6gQlqWBrLXrc2oPSfdgBs3mK6X90Rpq3ClyFURpws1R24NWSmJZcEYlHG47SCtYFeA/u3vbkG8voPd2F5T13BfoFwv7+s8N3pERrWHp638We08vg2CVSlqiMScqSlRldSBllXUWdV+54L4nFOIzMcTl9OZ2DBhfedvwTJRsK3cLCq53btWuV4/e8ZbYYYqJYNbEYRRRYbv7vEdbhzRqtEvmo9bqcpyvnD8+o3zl29t/d3qVxXS3OUM3diJqlxbeUAVj6+xwrSlVa4qI9W/ppdWsZozl6+vLEdpfUJdtx5ihu3HjuHdI+O7J9zY3bBO1/dGVa1BSstnUGndbroyGM0aVt7+/Jnjz78SJ2mTIl+N4vdzP/dzP/fz1z7/KkW0yX+AfKHbfqDb70UFpbaQSuOCKkjrRDieSNPSYPXqNsCWUmRdGGILohuMacOIVrdmJkkhV5TT1JiJa2wDZWtloaKrrKa11nKxKQVlDH4/4rdb3GbbPJL6lk4v2opXtTbeZ8k3RaRmCNPE9PLMdDoSl0CeVlk5qpZ+3+14+I//kc37J6w13/u0q6wJyxoIpzfidLrVQaJFSczLQlnXBuGXi7RUeupmb6iEeSHOK3FZuHaoa2eIIVLIdNuOYbOh32yw4yDPU6koe1UWQSEILeM9tFVzSbSwiqiJqrb5u9Rbo1DJkRRW6XFXoDDi3cyiarntyOOPH9l++oTrB5STLndlPRVNXgPr81fi4RmaR1Ip/T0sU6qEZdbYqjS/Y6tM57GbDW4zyt+tNKpmSo4o7Sg1ktZLawmqopyV0oZIqClBC/CQmj+0hctKlJ/ndg/YzR7jBQ8kyK8MWpNLIU4TeV2pZFGPEUW5pixNXNudDEYCkZLgWopNQU3Nh3qRkJJplpLmwS0Y1tNJBmV9DfvIkGwaKsl4j6aScyRdwnefppFBcjldyGtsrVmQojB6Xe9YLmeWw4XlMhFCkqFTQ04JYy3d2GGtPCZtFK6Xel0JvjU1lKaupoTyHdYZISNQsdsdbv8gN6VXBVYbaJ30p19/4fTtmTjNt1V3zlJqYKyh23T4TjYmNefm6dZtla/aAGpQ1soGox/l+6YW8hK5fH0hXBZc39HvBlLILMdJAPV9z8MP7+j2e1E727q9VHntqjaihqfQ2K6NVlHFzrKcL7z+8U9cvr6SWhmBbRad+7mf+7mf+/nbnH9FxacohLLeHnCbDdZ3jWlJuyBpabOZzoTpTJ6n67+gGkcJhRRX4rpQg9QDmsYKrCHIBaNKRKgo6cwWriFoZXGdpdgsvNAiKpWxkoCvMVM78da5fsDvt9h+RDlJGpNTG6RkKDAoiKFtwC30PTUn5rc36X0/n1mXRdqkongo0RqMxXedDElaiQJsjXgJUxLva0swlxBvCXbZaEo6Pi9LK5VpXj6qPI8FLq9H5vMFVVVb5Spq2yRrZ+m7Tlbv2y3Wd7cLLSWjO1EiK1r8dq2BqNYCCUoIgleaLtRUcN0gw3FDS5XUvKdtxS3InBaeArr9jt1PP7L94RN2u5HgVK5XnwbhfGF5/iLqkgBGIZYWFKrEORLn+fvQbLR4c5tybfue7mGL2+0xXYcqhTJP4jG1npwCeblQamrhpCLr/lRaOUBT7EH8hAqqrpQkoSbbD/iHJ2w/gBf4OimK4qgU4Xwhnt7k5qANa2lem63B47Z7UVBdq3MtBXKrfzWaElfSepH3dilyU1UVSsnwnZaVNF2gJkytMlx6h6oyfPn37zBaE99eiesMzStpvKcYR7zMhNNJ/jdlqLnKa68FNXX69sZ6uciwX+sNdK8M2N7huh7nu9smw3W2qcxCn9DWokqlhFXa09pGo+aEGbd0DzusbSn/WgBZ4aucmV9fePnnPzG9vGHcFf+lyKm0UJxjGLwQI5QireGWhkfJ+994CRlpZ9G+Qw8dNRfi4UxcFpa3M2lZhTVsNCVKi9KwH/HbDZvHR2wnNiAajaK2YKL2Xqw2MVA1oKRkQzYYlulw4vDzz4TTCWMVvu8oCuIUSOGKHrif+7mf+7mfv/b57UD77QbTC3ZJ2+8qkaSYc+MpTuRpogSp+wRufrFweCMuq6Tr27CAMlANpWRyyYQWprBemKQ5FUpCfKNeSRWoEz5maQpVDqJa+XFkeP8g6qx1YP3N61nD2tiiCvKKqplqBGiunCXnzPztC8vzV+I0Sbd5LegqCk3W4gPtdxtpZwJqikx/+hM1Bba/+wM1BNJ0ooQVaC0t1oonMqzk2LyBV2i+1eSQb77IdVqktrGWplgpqlECcXcO3/iffruVGsySZKAvFd91wpfspB4zxyhetxgoIVG1kqai01nCMdbgelG4S87klIkpUpaFnKQlSilFyYmiFMPjjnefPrH56SdhqjZGqahKjhwS6+EL6fSGODKMDHBBeuXjGlkvq4RbruKwtejOYaxHGYsfO/x2g/Y9oCEEqQfVWoaW84GiKso7qvE3bisZaEUG+hr4AknVt/nBdB3ucYcbt9+bkAqwLtRaiDGyvr2S51k8zd5Q10UsDNpgdzv6rQzHtyR7Y5RWFCVHSblrjVaO2ntoqf5iLCkm1tc3VC4Y3UJOKjc/ssVsRvymh5RYvh0Ek0XFGKDriLmyvD5TmsKptCVlYctSFcvxwnQ4U0rGdUZ8l6kQ1oj1ls3DBuccWsuQh1EtYFfIuWI7g+uFZKFURXWNHFHkPesfn+j3j7KeT2JVwEnQLc0zly+fuXz5wnqcMMZIsUJT12up+N7RdVLnK8Mz8j4zDmUsprN0u40ov7XeqjZJmRwKl+cD6bJirKJ7kNewNluJ9Zbxw5P8+evNl7ZA8/FSG3u2taApUbFrkhvLVOH8+TPz4ZV1PpOblzWGRF4zbjfyu//T//xv+3a9n/u5n/u5n//D85sH0fH9x5Y1MIL/qZKqjtNEfHsjL8tNgZMmHk2JiTSdKTmhlcJ3MmBRJJWL1sQQiVEaWVQVlXOdZvS8SgrZWIzrMS1tT9GiECppPXKbDd3DHjf0krDVcjG7ekAleKGkHjJXUXDsIJ30a+T4x5+Zv30VpE3JjRNpMNpSTaZi8FYCFNdOb65pdmeolwvzn/5Z1rPOSa1jqzQtIVDCIsNeGzpt52RQi1kGuGllbaEla2UJuK4R5y39MGBbbaWxHrfpgSLImhBQWtNvR1zfoZwD41HKourEenoT/2RMpGluTVXtgq8lqJTasJVzJi+RmqqIfDmhrWZ42LH/6Uc2Hz9ih4FqG8ooCworrRfWy5myzrAGoFKSpN7LuhBDIq6JnOttuJXUtkW7rgWrGmLKC1+0oqglyhCcC2m+kMOM6gfx3caVMl9QjeepO+G9isVCwOPir5Vwmt/tBeVkruqeYKkkqb6yHA6E01kUuebrLUsAMqZrCmrXyQBdUmuggloztSTSMgtGCkT5VQ1dpDXVeMLxRJ4nnDXgrJAOYkR5i9vJ+1ZRyYcD4TJJAK5UAdZbT7zMlHWV6lgt9ZqojBs8JUWm5zeWy4qmYK3BWk9uavNmv8VtBvzQUYJwgN3QEeaVHDNmM9I31V0+uCBr+Ua+GDf0261YAJaLfK6MQ1lLjZnz568c/vQL8XKhpNQUbgkZlVpRVjEMA8Y6ITLkgiajjcNtBgrf61qVFf9nyZWUM1pH4hqIk2wP3ND4uUo1xm2m346M7x+xrSChKlHeZcdQpM7XWvF8V0WxYiGoVJT3hHnh8OufmV7fKHNoDF4ozUv67j/9ng//83/CPbz763zb3s/93M/93M9/dX77ar7B12VoWYmnI+lykYt/qaJStDBCrYUcFunmBrSVFqJr3L4UCcJcO92NlXrAnBIpZZz30qriHMbYprIoCbtojes6/H7bFDTf1qjiP60xUq44HSMKKCm3AVQGjeV05vz8leX1QAqrNEM5Tc1QsqJURclGoPlKVqg1F0IWPqPtXUvff/epms0ojy1F0hRlMC+peS5lODNOHsc6raznSVLw199NKcIigPF+MzJu2xDaSfBJGyUKW5Jhq982JJb3bTjSlBBJy0kA+9PMOk1QK6732G5s6f1CrbmB2EUlSjGTc23rf8Pw7oHdj5/YvHuHHUcqVzZse52WmXg5Ec9Halhb2EtYpDllYoikOcpAVMRnV5WSgJfV2HGgf3yHGyVdrrjewAjiKqeVdZ4b2kiB94JSCvI7U4SbajrXbjyaLxctBQrW4PZ73LC5qWe1iBpbkcai9XxmPR4wXkoMyNIVL5WbHe7xURqgTEtcFwlxUQVflZaJEqMMhi3go9pjrEoarvLlDEmGoFzkddOdRw8jbr/D9Z58ORHPC/GyyGtrQDlLCpn0ekAhdasoSEnQTqZzLOcL09sZBXS9FwVfgdKVfifDnzKueYQtZreV7vq4op1hHB/QXWsMi1mCaFFqaVXX0b9/RzduqCl+9yg3T2VaFo6//sLx81dqq7StSoGy5FoxGqxWWKPR2khgrlEpMBaM3CS4rhf7iW71sc3jm0NkmgVlJQFJoVmUXChRXt/Nh0fGpwdM1zebhLwvSkmUqiS055y0MWkNuVBjkBsKZ7m8HTh//oVwvlCWlRSyhLa0xm02vPsf/sDjf/gDpt/cPnP3cz/3cz/389c/v3kQlbagldD4lyqLIqWcFyWTQs2RMkuTTK3Swy48TsHDlJqlTjAI6ql7kA7neJpJBbrNSK+1DJ+2BTxqFf6h1fjtSLff4zff7QFCly9tzS/NTa61stScpWpSyUUsnF65vLxwfn6hpox1RppplFQLgkJri1WCqSoxiWJYMtoafHcFa/uWlNZysTOKmiLpGkKqjVdoDAUJDlEKYQ7kEClVFFJlDM5IAAkqtuvxm55+HIXdaFVrC4rCNvUDbuwwDeUj7TOVEhJlbW1OcSFOosLaljxXRgZEWcOnprqJqik2hIrtPd12w/jhA5unp8Y+VdB670sI5OVInE7kafoL/52SNadRkCGHRF4jKYplwhgkqKINZuzxuw3+cY/t+hZE07LlTitlDeQqqKuKpLDTvFK1EsVUIR32SmN8J8NnjLLKRYI/ahjpP3zC2usAKvv5Wgq5JFKMpGlG1Yrb7kBL6lt8oV3jdW5FaW3FDLWxNWuMpBgEwxWieINNa/iqlVoVOUTC+SBoJ22kUawWqLo1TQlXlxwJz1+lNrcCTqPdQE7pFvRxvim0FAn6+J5SMtPbkWVaxOZitDyHWYgSvu9w44Dr+zacq4ZHkg2Gdq5B3TUlCFcWVeTxO4N7fMA/PGKNpM11PzT+rAS51sMbp19+4fL8Js+t0uiuYcpaIM2o5m+mNW6VIjk+rTDWyufXO0jttYlR3gO1EJeV5XSWz0dtGw2lyWts79OOh999pN/vb/YIcqaU5lftOilpaNQLattOpEaJyInTLz9L6n5Zm6XCoJ1QNob373n/P/1HxsdHtO2k5azcB9H7uZ/7uZ+/1fnNg+jll5/b8CLgerwTvFJoLTA1t1YSUU9qFqRLzVVYhylRqBgnKCHtBc2S5hVtLP3DKINkvf454TW6XtTPbhwxw4hykvCtbYWIkpAKLV0ttUatE7sUSlyJ04X5eJC0cYwCs2/VijlXSBXTeKfUSokCV1dKY3sv6s4wNOh2Y41aQ6WSUiRPQUIvzTOrvEVrRQ5JWJFBlKZaZSjNSZLSfutbGMVhnZUO+bFHN/xRLZlSCso6XNdhfNcakBpGKcvwn0MgXmYJGTVMkaS1BcRe0jWdX5E6VfHvaqPAeYaPe7bvP9DtdpiuFzh6RVbNKTWA/5F0OUsqvcjfca0nrRRYv3MitdJ0vbmlpu1mi9uO+N0W7XsUhRoXKtI3n3Mih5mqGr/TGFQuYoMwtg1OorxpZQTsX4pwJrUk+muOsrKdZ8LbK+wfRMEDSmkVr8tMqTIga9VqTmOSAN5ujx23GGOkNahU6atXpt1gnYnz3Nqj5HGpZgXJyyo+1lVIA0a14bDUdkMiJAC/26BqghQkGHWeRYHUFqUtMSzkeZUbMeeayJ9BVXJOYp3ICagMQyeDVRIGZjd09JsR00n9bYn5xqEVpVBufLSx1FCaFaVhi9oNZbfb4fcP0qpU2+dLy6ZgPb4xvR5Y38RCoGxrGMsF6XHXOFXkBs0InktwXeLbrVVeL9336K4T77aBtIgnu2pDWVbiFCSo17kWuJNmJoxj+37H5ulR+LBKg65wrZk1nQScjGmd9PJWqjHKhmBdWS4T8/lInGbiZSGXgnLi1TbWsf/pBx7+8Af80MvNJe39qMy//5v2fu7nfu7nfv6b5zcPojWLYmi8R3nxp8X5Qg6iGkr/OUAlpyor/CRtPaqx+yTRbSQln6QnXFUrrSkt3KC0agla6aTvtptW16ebuiQIJWUa7qUl0pv02biikbjMhPNZqiTXpSXmBZYuEEGgaGltqg3QUq48REn56s5jvUc7DUq8gdfhoFzDLKU0tE3jmmrxyJZSWJeVOK3ULMOP6zypWRBc393af1wnrEStlawodW5tNp2s3527pewlsJzJLRCWYyQt4m+T9Xlt6ldCFdWGSvknJ/FdyqpTfqYdR3Z/+Dv6ze6W8K9VfHRlWcnTmXQ5U2KroqRtx0ulpNaKpJSEz4y6rWGtl6Yhv93itlt0L+1SFaiLrN2LsaKE1grOoE1HzaLu1lRENdMGVaqsj7VgwaS7XJSymq+/g8E4Ub7XtxfyumK3O1HyposkwRsrk5Qk7O8sdrPFjhts192qI9HiRUwxNp/vTFnnxrsUpVuwUZU4X8THGYIEfbQDVBuOlKTshx7X97JenyPpfCFHWYGrLH7HNE8Yo/D7rVhbGlu2NN8yyAbCGAPeUaPcpFTETtGPA77rbrzMlOT5QheMdeJ/LYWyrK3ESxRO7Tu6/Q6/3WCdk9dfjLxUIJyOTM/fmF5fSWtoHl+5GcpIq5RRCmebMtyGtty4r1VBjIkUA3WppBgZovw8FVfS5UKO4sm8KqDKC3YMgFLo9lv6p8fvgSQtuLRaorznrUO7DqOBLDWzNSXxsafEejkzHY+EaZHntNUAa6VIS8aNI0//4Xfsf//7hq8CrGs3t4p09QDfz/3cz/3cz1/9/Hag/W6PcR4/DihjSMssbTNlQdVKSlevqCK3JD3oBnYv5FrRTcEyxklLYBXFCAXaKmzXi/LX/tGm/XoKagubqNrahtSVSSoesFoyYVkJlzPr6USYm4cvZVG5jEYh4HrtLFobSKJ+llKgSJLbD+LHVE2J07YB1GORFqAYKCmiclu5X0MeBkCTUyBOmRQSYV7FVmA0uimhymhJ32vT1o60FH6haOm39ptRHr/vpJ0pBWoWv+mVTlDaxVE2k6XRSBXGG3IIrJcFq7WsfRuLtSpQRmOtBE5MG0bD+Sg94uPmu/8xSNq/tLpPkN+/pHydawUtVRoiyshFWxuN2wy4K7+172/K4RUKn4LcGEglqgLXSao5R4G0r0lS7Up8i7W9ziWLCix4pgJWSZ968xVqozFDJ/3rORHOJ3mOa2k4ItXQUho7jNhxIzdWSt2g8FhLSZl4PpIaakrahMSfrLxUV6ZluSG6JF3fUFwlk7TB9R1uMwgsH8jzLOUBKZMLglxKRQZYrfAbKYLIUawTOSVyClSKEAasRStFXgIlROKaRIXsO1HTvW+4J6i6VdS21jKt+M4rbQxfrMa/e6LbXwNT8j6RW4oqafjDkcvzC+H1RQbrhjwwWssmoVEArLM3YD9JVERpKGrmDaNQSVrOSq5cnt9YLxPeG1SuDWHGdx95lveZ7Rz9447ucY/pBvnv2mMT72oF36pHc4Kqm180U2Mk58Q6XZheX4nLIjctckcndhJn2f3+Aw+/+5Hx40e09UIFoLabSeEJry8v//pv1vu5n/u5n/v5Tec3D6KbDx8FAN9USN2PxFRYjv9CmqW7W5QIMF6Up5JFQVJKYPXa2uZrpDG8ReFxmwE3dKI+2lYpWEtLKRtU64GX1PW1bk+8fSUlYpi/129Oa6vevMp3SobMtjKWZiiLQpFLlI5qb+WfvsM6dwtHaKMFPXWeBINUsgyEud76rmX1KxdOjSbFQJhmllkUS+ss/X5Pt38kzRdIEWtMa5uR1aa2EpjxDU6vnW8JZkl5lxhJ80ScVlIU/irXC2qprWdby6pdKYzSWN+RggTCjJZB3FgZGLSWcJdpA2KaJ6aUceuMTlH8dK1/HnTDZdGSz/W7N7UoitINKWToxkFqIYe+WQiajSJHSlylSSkESg7t9ZSENXFt7VKRGmUIVdqggZyj2Aq0DA8l50ZBSGjMbXiRod6gURStUVXwP4V4s1IoYzCbHdb30qOOhFikThIJYsVAvFxI86W930XllsCdFY/z2soASuOhNoZpzRXtDabvcY2OkNdVnreUZHBH4PK0GwvbdxhvqaWKxWJZZQAtAoHXzQ5SowT55N8XTOfxXaup1ZqqNLVI25YxHbbzEtwycuNW23sJq7H9hu7hQepYzTVEeH1NK+lyZn17Yz1fCPNMVULAiK3H3moJJJlGk1Dtc6Jpg3xJYj8xSuws7f2Ry7VUoIr3O4GuWm7UrDyO6w1sN/QM+63YeJwH3Sp/YyQrWnhKwki1FS1c2aFKa8IyM7+9ENaZtMZ251SaTzTTPe3Z/fQ7tp8+YXrxK5ewQk5CtQiF5fWFeDzKzdj93M/93M/9/E3Ov6riE2OpbTCbX56ZD6/kGMmpkNrwZ71Hg1yAWh+8at5B8TZmWbuPA24Q5U9aWrR4u5p6R6tR5BrKua7M2ikxEi4XltOBuEyieKQi+CSlpG0Gwclclb9reroECTKZTuP3W4wz4qtsSmtFVEbx/S3EZeXarlJzab5E8V9WBMJ/9YMusyimtuvYPD2w+fiB8cMn3GZHmCbOf/wX8vmC0hXTefrNiH8QtVk1xBFIcCOvE2meKTGQYyDn2sDz8jO1cyhn0DlKWCrJ72f7js27B1KMrPMi9ae6PT6jW8DG3YYQU7Pgj5YzuXxvI0J/D5ukpVU16sZmrUUCZM7hhqF1jg+tbacNB7pSQyKHtYVFovjydOsRL1FQQEXqSwUdZJqadx0qAMRvW2IQm4L+joKqMQm03Uo4pubSXqnWlqVlXWyGDX63E06oeAuQOlFRatM8k8Isw+gabi1DSilh4QIpihoJBa0bIso0gLq2uE2H9RZrxWOZLrP4XK2hWkdeFtI8oVES5OpluCopk0JkPV+I89xW5602tCgZjkOzVaDo9ztc16Eq5CLWlyLGaYzvMN61z4KwPmvzTJu+x282uM22lUWISomWGwapkz2RLidqTnSjgOPz2hGXlXKcgIJzBmtte561BBO12DrWRcgOtnfNkyyectM5sZAYMEj1pmTVtADwjaZE8bGOTw/4cWy1r1bW/UWGeYWUC2jnUTlL+5PWYCWNT4xMby9cnp+Jyywe6VzRWt/oFbsff2L36SPdMMr3QspQ8w0xFueZ9fBGWVa0hmrUv/6b9X7u537u535+0/nNg2gOkbCcuXz7zPL2Kl6+UslLpKSCbStLWrez9a4pYi14BJjO4bdbuv1esEvNiyfwSuF+qtugQVNpaKELTVWydk6XIyU1X2QtMsSUls7PFa0M3olnUFkZMrlqpKY1t5iKbulrdBtqWvtSTkWGm5b019bKYJUBdFNAo/w5J+n69XQhhIjfbNh++B27Tx/p9w8SsGrKmul6TDdw/tO/4IzC7/dYZ28g79qCH3lZWQ9HwuUinlijxSagCilHqgI79BhvhRGa8s2uYMcRu9mIIhUSnev43sXIDURPbcqitZBlkFBiOKTWQlmDDJ+Kxuj8HgDTxmA6hx1GaXjquvYcQ72qnWjSPIlFIuc21IFSVZRu7eVGI8WWqhZFTLX1fdXNh5qlmYdccGMna36lJPRkjLRUVVpwrYpC1uwDynW4hydR/lyrjlRt+EqZWjNlnomXK8hcfj/rHVgjuK9SWacL13WzckbC2K22sioZ8Kz3WCdYohIi4SwDpbKGsEbidMDcet4dqkCaA7VmwjwzHy/ERWo7TRsea5GhuiBgeKM12lt879HWyOtepeJUe4fdbOSGKa1gWmiwyE2LGzd0D49CuWjRNaqS9iRtCOcT87evUMt3oLzSdOOGrOX93w8OY5Q0eiE+zApgLTkl5tMFpSpu8MKiLRrVLCmm94DCGIdtmwTTGrdyzLAE/G5D/+4RNw7iYVZaNhDCTxNFux+51o/WGJsiLu/RtK4cP//K9PJMmlYJr7XyAWU0Zhx5+sMf2L17RJUkLUuulyKCKgbw+e1AeH2RZ71tPdT/103w/dzP/dzP/fz1zm8eRH/5X/8Xas7keZH1X0v1GmuxThQhrMOPvXjI5pmSgwR/eifw8n6ge3iU9pzahs8YySmh+00LO0CLJV9nG2ophOlCCqsA4uP3hLbtBuF+Hie0lqYghZK8iWsQ86bkuc0oXE6lZMYt4kerKcsKOBeqvgaXxE92VW4qjpwDKSyoqwcuZ9K8MJ0udEPHx//0P7L98Sf63b51Z9vrBp1rjaauid37BxnSG3S9sWtI68Ly9ko4nKgpyKBmDCUUKNKIZDupVdWt4lJ3Hjovf5fvKFUxHy/olLFWkt1NuiLXSkry2gkcH/H03Yy6irQshPNMDqnxI0Vl1NbclLput8Nvt5hR2nBojM9KESdETqSzvF7VWlQnP6umJP6/GKkkqrEYrWTFqpB/l5MEXVJGlSrKbeeljcoYVCeDaEm5rVLrd5RXKZS1UGrG7vf0H36HGwcZfGttjTtAzeQUWJ6/kdfl1gdf2tDiNj3Ke9ZpIl/Ot599rSUtIRHXAMqIGjz0GCcIsHi+kKMo86BYjgfyvOC8w26kNapE6ViPcWU6vDVou8Y6i+0cKAkc3eafKu+dVCvbzShtVilLMCxn3Dhgh14Gr1pQfYdKibys6HFgePoB13XNEiM3hRL6UZT/D3v/1SvZlmVpYt9SW5g4wtW9N1SWajTBfiLAf8C/yJ/FBwKsF5LNysgQV7k4wsQWS/FhLDOPRrNYXll532wCkQFkuPsx27bt7LnmHOMbVM4//0x8fmqbAWGqcFqZp2VlORwoMdHvdm1iLwqDDT21VtZ5Jq+RMAQZ1nKmYprZzChNKkmK4qx0vaZoK1GzME3j20c2798JG+ZERiAmsvJ9Md1OTNlmuONyeGnTyvPzF55++pE4TaRTJMeIsxc4vWN8fMPb//hPjNudqA34RoVYsDZQnef8y0/Mnz9JNxxauln7Wbe61a1udavfpr65EY2nc7PD2GbekQnI9YqgdLatxijiExqL7R39biRsNeGoSdMq4yJpmZhfD6RpYV0WNh++Y/twTxtvUBG+J80TaTq1OHLTzBA0GanMRnWN2NpWgE4TopISxIxzVsioYSAMfTMfSatW4qzVbjOImLaurC0bslo1Z2WNLKdzm8Bqqhi8w5qAcY439w88/OH3jG/eYbqeagPktQG8gziG5xdqnJD7uRmtDFf25PTlM6dPn/RA94q+xFo5o43FjKO4pOvSkDuGHIVS4hKj+vwFEvTDiB8FQS9NG1dzxOAYthtd4zVK6xo8bAbKuhKfX4nTIuO4ld605CIH/9ATNgNhsyVslM5E1US6Vq3h8xpZp0k9bd/Rjb30uilTM2CDUEq54LsB47w4qzFCjM1I0iSLzmOHoEx5U+RGdwGo5Gmhxnw9uJTW4JIKpt8wfvcn+ru9rn/J7e/pmtc4s768MH/5QppnJXJdiATG4saRWGH99SPGSF+LsdSYdc9F4S/9bod3DueVkV5iIs4rxgbC6FinM+vpiDOW7vH+qm+tOZGSrtPy+kJJia7rMd6I99o0sMYYcJ5+7ABIuYoL2w+Ni6n7yO+2WsWXLJuRc4rGTBl3d8/2zRtN/Zu+kizTGg7SPDN9/IWyTBgcNQEhyGBYMvPzM/PxgMPgQyfyQoxQMtZZEpV1FfA+bAZpQ7Ma/jRNipK1HSYBVXny1rmvEalIXrL98JZhf69pd9c1w1KiGqh+kGmvRE1BszYVphfKLK8zh59/4fDzz8R1oeSmQy2VUhWn6rqOzf0DYdhhQo9BEqC6rjKexSjSwnzG77ZY7xtWy0LMpOWmEb3VrW51q9+qvrkR9b1ShNISKVPGd55+t8V2QZPEmAW57x126JQ+dNF/todPNpX18ML548rh0xfO55nOe4bdyPLlE87AsN8pYSlqbUktMjNUKNVgnPSb8TSTTmdMuuCItJo2DeLtNiN+O2ABa2VGsl7JMHlZpQmcJkqueO9wXpngtQpFZZwVvigl4hJbRKZSnaqFXAr7d28Z7x/odnsYBeevMUJZoJPLtxyeKPNREzkXMCZ81bvaigkjz3/9icPf/oWu6/Bdr3x1tCLuNhv82GlyfJ6xDb1Tm3EkVoiHI7ZWvAtKG6KQ4nLVkApVU8F46exaJrtpiUX5+ZW4LJRF5APXnMnWemkZx4H+4Z4wbuQOz7lhtCw1NR3t6UChtEmwAyp5Xqhrgq4D25ph6+n2D+JzppUcW1NQtX6vNcvAs91oJWvAhhGyWKA5RqGhhkGD5HxJC+oZ3r+lf/NW074cwQTwvUw4KZEOLyyff2nEAYdvSKO8FvxuwIWe9Xwin07CJBlFjtq+08+PGTdsGPuAtUoyohTyumCsI9zfs56OrF8+yQm/UfRkmRdKjORcyGkln88sxwljrFKTrCWD2J+lgrX0Y083bjRlLoWuTcKlUYVu6HHj8PXgdKEI5IgJHZv33wmcL/HnFU2Gt1AN88sL8flJn2OtGNvoEzmznGfWScxd7yy2GulML+lFtRCjmj68w3ZBMp0E1UjmMe73gGS4aiw1RS1FTF0/dAz3e4b9HjduwCkcAGNgbYZD3+G8hfWkSW/TmZtB73s9vPLyL//CcngVFcM7TLrogqWn9l1Pv9sQn5/5fDgwvH1k++EdYRgx/dg2AM9qjp2XVKQxgWuuDQUX/01+2d7qVre61a3+9/XNjWhpXEOTDOMocLbBUNcIGGzn8FutCLEOd+FGRgHf07qyvhxYT2emw5lSK9040A3tYVMK6/moKUiK0vu5C/JHmJ+0RJaXE/E0Y63FN5ORHhoZ2wvf0/UB18m8QpUWtBZkFjlPSuvJiYK0p9c1Jyjju00Q6yXCUUJVqjUMb+4Jw0A3bJTA0wWZKdYZMOA7xVlOR63XL47qFLmyTp2TNi8t1PXE3e9+kNnkdBJGyFm6u60QThXqquhJf5EaWDW8cdb76PqgBCXM1dxTncMEgfIplWr9FSVlrKNUSM/P5HkBI6akfrTDBq+I1WGk22/w242kBKVQ6+WaJ+JyIp1P5Jyx7TBAm0KWIp4jIejzqwXrAoTQ8DyR0iQDNaYGZi+EocMOQ8M3GaiV9XDEJDEjfdd/TTLKmhYP77+jf3jEh4FamumpH6lWQP54eGH58pFyUmIRxut1Wk0h7WYk50w8fFYu+WUK7WiRlmtjoo7tYMU1RarE2AxPsPz6EdKKDz20aW9eVk3gyDLVrSsmF+XXBw85k1JprnMLTvnroVMDnUuGqsk0VdIAZbMrUME4q/sDMN4T7vZ0m50OKxfuLBZjlNAUTyeWpyfhj9r1lx66QNU9Fc8yVPlOMogam4HNyt2fSiZloBpcrVALKWb5vzBgpf+84KOwkoWIKQx+6Nm8fWS43zf5igx0tVaYJh1AgseZCsuZapSyhQ8YHyjA+dePHH/8GyUuTQurA5QbFM+bUsFUw7Df4LxTY7usnE5npl9+YfeHP9Dt96xPn4XfbRN2N46aOC9H6rLetvK3utWtbvUb17eblZZMCAE3ODWLtVLWiB87wmbEbUZc4xHWUsmTHMhpTdd40HySvrMbe3wXmhbrH9b7fa91L824U/VQy/NKmhfWuXFBBT0UoL1BsMOmo9tvcEE8yxqz8tmpxGUmzQs5rlDBBy/uZWkIKKP/CKuzqm2ICVuhHzvG7Uh1geHujs39A77XROaChqrWCIBdSmtAF6GiXNMd5gbFtAHTD+KZ5lUPWB/oXc/jH/7Ey9/+gklROtuG9BFkvRmtrCfGVTD9WQk0JnhlwJeM66Wvoxm9qjHCTiVlgRvfqYE8nMjL2qZkF+i9kRt67OnuZSgLmw01V2pcqTnKyJQb4uh8pOSItU7mFWvVbLf3WggtpECreQyaAMeV0tBFpVZoJiEfHLYb8EPfmJxa9V8OOsYFURiM8u6rDbjdHf3Dg4xxGKX3tIaZnMmHA/PTZ9bXl7ZObtP5WqUAGXRoSMtEXaMSiZopy3adJnQlaxJ8YdZSyWdRDDCiFORpJp9nvY/tVpO/FInLBcMUyeeJUor4tbYhmUqlWnC9V5CqsUr4cpooC5UUyK0BtZ24theiQKnAmrFdwG1G+rs7nLsER6gBpegAmVNifX0mHw+iCXjhprDScpYYlTa0LngvQ58gFhU6JTLllIk5Ui7foZTJMXM+nHDG0O93mvL60CBrtSVRWayx+DEQtiPD4yN+GKRDBcHzs0xqWIfremzVQVA0i6Bm0zrSsnD49Vde//4j1laFGKyr7hHr8N4Q14zHCy1VTEs2q1fcVkmFfHxhXSfyNEuD3Jr7skbyrN9TtaIV/3xbzd/qVre61W9V39yIdsOgh1otWo12/qq91APSCdUTV/KSlLteUsMNaa3n+g7fd63xdNjQyf0d9CAqrbmtKTY+ZiVNi3A6nZcZInlKTlqfe7n0XdcSkLzFmnp1oK/TWRnVrRESzkl80JoS2WjilFLSWj6Xa3OaSyZsNwxvHul2e7pxbG5h28DlqPmiNUbrJLcy6rmqrc2V7MD11yQjLgb2fsBUGXfK9EJdZzZjoESrGNGKJsLGXPWy6+lIXiZByq2mQCXla4qRohQbeSkEKrY93JW2lM+L1uVJUzZjLMYZTYK6jm63Iez2+HFUmEBzotN4pXk9Kka0FjACjit0oDa0lJzYgqtqjXtJuKGa1jC0xJ2sZtF0QRrUIEd7rVUNTpFT3Fz5sxfdoMFtdrjtnVKnDG3i25ily0JZjqQ1El++kFbJAS7kAtN1auSsXP1lTQ0Xpem9DFqdYj+HQU1ryc0ah8x6uVBwlGUmnc+UXAjhK5OVqoCBvCyKFc2KxnUtkajmcrl9cEMgN9KD73tNnuGqIcY4eu+ErXJOjW3V36+l4jcyAIahsVtbk13bNDmXTJzOxJdn6ro0FJoDLMZXqhMcPi8r5CQTorWUhtFyzpBrJS4LcVmwzhFCi/dNmRQT1ge6Qa/d+07fMaPDRKWxR4ee8eGebrdpqK1WLQWpFklXbNdhqg5P+v5YjJcGdj2+8PzTT5w/f9GmYwjt+y9cVamVGA0uDHS9JS6RmNtavX2AYTfQP+xw1pJOE24c8GMvfe48k6a5hRTogFSaQe1Wt7rVrW7129Q3N6IYxWOGsSds+sYVFQqnlsJyVMqMpoptn2WsWILNlW2Dw3WBMPaCqYvnQ86ZmpXGVGKkLGszdnwFhuMaaN6D94Pg7M1cdHlQmJxIy6omOMkNX9sTX42VfkZKifV81jq4VDWwwTfmqcUNA/1ux3C3pxtGNX3tSVbbal1moQhxabxK05KWit638xjXqQHCNPxTalMgNSnpfGA5HKBB7akIYO690EVrIsVIXhZMTpiU8G3KmpuW1YegCS1qMGy7FiVVqDoYlHn5GseJwTovWYIzSubZbgn7fTPutJjQnCHrsynrQp5OlBp1vYPH2V5/LkW91gJkNa3GOUzNjV9Zrqb85k/RIQKDteA3PVwwX2iNS7UYU7DeYIoCAzABt7un29/JOGNonEq971oExI+HF+LhmRIj1kAYeioNU4SiV3XgOVNzwjvpQGspLXUrtOCCLOd1aC79y5S1GYHivFAXERSsEaPS5Ey1hrSuLKfpGgFLW1dfkodqqbjOE3o14Smpcb2QFRRz6zAWnFeYgzTBBTJUU3FdhxvaFDSElizUNJpGh7+8LMTTK3E6QanNyd8a0VqkD54mNeDG4IZe79OYZipqSV4pQilCT3Ud3XagJEVlDrutmuRqWkytPsNSZFo0ztLtNwz394RxvE67DbWlXHkdFJzuR6rkMBV75QenZWZ+feH06ROnL8+YKhScMZLV1AbB9z5g+8v3LTfKg1z8xjn63QY/dPocS9UWp+v0u2eZSPOkg3Cu1wQnWyr5tp+/1a1udavfrL65ER3vdppADXK1GoRKSstKjkm/wItQS9Yj00puWfNWaBo3jrhOKSs1t7WdtY1bqfVhaS52sa7lHjbOa/0YPM5dmi09tDVhrIqOXGbieVLcY2scTWtYc62a1C4z87KyzlFYGSrOO8a9o99rJd3v7+g2cpfXdRW+ySrrHoAGZ6+5GX9Mg8w7iw1bTXXaNbo0CHLIQz6diOczeZ7JKVJrxTl/zYDHGGLLj9ekSM1MLZlCFamggb593+OcGhjjtXY2tAZ2XnUtc2yNRXuwV11TFzolWm3FHbUhtJ9XWjOaKcusadp0xpiKG5ujOWVK1UGhtsmtdZba8tCrNYolrTKo4Fpz2lawxiLou+s05Uu1mXTaVMwZ7DXcwOC6O8L+Dt8Pmn5V6YhNqWqmTkfFksZZEPklYq3B9gHby/xVUkvFatM3aw34XixLFLcpAkD5yrHNkWorBau18LwQD0doms5SBba3jfOJ97iuYz5NinOtraFpjn1yxTpHtxuwnYD5lIo3WpGXrPhN6zzOt9fghIWqOVFiwfoOv9kStqMSotokWDdhhtCxTmeW5ydxMlPEICZovQRD1EyeJ9JpAsCFppmtjehgLGkVRzanjA2XCaomsxXFXyoUISgNraKf34gVORf8OLB5vKPfbBSf6VyT7uRGxhAdwVgvruclJ96gbQdG5q/jK6fnJ9bjWQcDKxIGLdHMGIv3Ha4TUi5P61f+rDGELhB2oxrmFqhg+wGcUUxxzJQ46/fR5baDpqG9/JK51a1udatb/Rb17Y3ow52iEHMhzitxUsyhRliXFZoatVxkTnHeqQENXtOY5mYVBmZtWJ+iRjZGySGLmlcZZjzdZnPN93bO6uHt1GSWqIlhrRlybRxFIZbwmkqCYZ0XYozkNRKXSEq5PegNvuvYPuzZvX3LeHcvneUlcaZWqhejs+QI69p0grZNSNV4V+OxQ6/El9YM2louCHkqer/r8Ug8Hsjr2iZUl+knaoKSGk5DxZaqSWCDcVfAYcURDeHaUNamHxRqKcnpv6zXabKmsw36bdoKfqMMdNf12D5AzZTppFV+RVPUZRbvs2YxS02b+F6atWYwsbTr7MT2JBdl1M+L9IfBf2WZ1iaPaAcAshpJNTFih1KALjR4+RY3blvj7TCuB+8xWZPZHGfy6ZU8nXRN2yTRjq0ZDp0OEEUxoZSCuTSaVmYuATp1zS/BCeYi+6jSJ6/LSo6ZsixKrmr8U9O0tbULChzoFOu57Tz+dGZ9PeggU9SAeu8JfU8Ye6jinVbbDm21Yim4IMSRqaUFHaBEqjXR7/eMD/cyK/0jaL0WmcIqLE9fWF6eYBU1wYZOtKR2nV3XkeYTOa2NqGA1Hb+46o0hrlHxsJfVuGlRtgmSSdiYW7JXp0Sw2hBatcm6naO/2ytGdDO0xDBtEUpaZSwchHTT9PISW6vPxZpKzpnp+QvL85MmlTFivV5LKTJeabLc4WzQa1iS7vPOY5dEKQpB6HYbHUyN1WferlueF+mfG9NUg8+GzmqbkhrclVRwq1vd6la3+revb3fNl0I8nYnnWROEcoGcNyZg0JQTY/De48ce13d6+NPQgbnI6DLN0NJ2SsqkZaGUgjHCJoXtQL/fyITiLvn0alyy9t/K8I4RaA2Xulh86LGDZ51nlukMpZLXfJ18UCtd5xkf9oxvHtk8PtJtN1rdXyJAa1HTYxwlLZg4gUA+YDX9qaXIfNRtcEGpR5SiyU7TINZSSfPE+vqq9XZO1Ji1KqwGgseEy4pbTFDbHv54g+mVb57jikm5RZW2aMQiB75xFmohz4m8rJqeVTX3rrnfMeBCR7fb4bfbFkagiXJZJiiJ/TnW6QABAABJREFUiiOllXg+kZdZ0oeWoENarw71igHTTD/W6XBSEQc0JvIaIa1qprquBQe05tVJd0gVfqrkgm1axGp9Q0IZ3Linu3/Ah6Dr3Nbm0hNG6joTDy+k81HXoQobVXMRaH270T23KPbVtCa6Fr7GnFbTtIArtqoZND5cDTQ1KkRhnSbSovvGBa/1bxuQOeewmxG3kTMbJ3mH70Z8P9ANA9PTEyYl0QCokgi4lnFfdXgz1uv+vegqS9GEsgH+XT/Qv9ky7HZYC8bU6/RcWLCOFBPx9Yl8PosY0bS31EpZVvCe4e17unEkLSfWzY71eCSdZ01bs77TtVZK1c839TJJrcRUcDjKmqX1HrqmtS7kFK+O/rAZ6LcbwijwvvSoAFUHmXZoc033+dUERrs3Csv5zOnTJ+aXF9K6tM9D63UbwGKoxUhf7gNlVfxnyaWFUlhCH9jebWT6y0qesq1Zz1HIrTifdW9l/X7TlkUTfO8DuWTm81lZ9be61a1udavfpL65Ef38Lz9TU6RrOjPjrQxKVaMu4xwueMI4aDLoDTnpgSYTwUp8Pf6DW7vie09eMwat7m0fhMjp+pYp/g8PZtS4hc2I6TzTr78qOeZq7DEE71nmyPr8SoxJyTzWqEHOhWoq4+Md++8+sHnzlm63u076LpxQul5NyjJBzdcHvkw5SOvpAnbc4vpBhpsqZFBbRGOo5HlifX0hnc6KA22GHyo4L7xUtb6Zh2TOcqE1Q6YZZIqh1oyzHtMJVF7b5O8Sp5qzZA1KgGmwb2eo9WL+gW63Z7jf6/VCA+JXahTns5hKjqevxi7kaK9xhZLU7xinKWybLLVEgdZYF+q6UJPSmOwwQtcJW9RMNyZz/Xu11rb+bHpFK4aoHUbCwzu67a5NUc2VeaqfdSYeX0mHA2ldsca0aa1rE02HHQdKiqTzCUtt7u+qRsaiqVypem0xijwA+jneYUomzwvz64E4TVgXcMaIYVuLaAgt29zvR9zQSxbsg3SOOSvQoRR88Gzv7wSSv9wbBl17q/AH45ymkdDW4xdjmPTEw+Mb+v1d0xBXMO3vGAeukxv+eCBNJzWD/aDL6h11XYmnM253x+bdB0LohJfqt/jNA/3DwvnXn5k+f2Zdzu3AErDlIrVo91fR67KmEvqhHTBk7ipF94vtPMP9Xmxh56+GKB0Sk959r8axfeH0eq0Vf9hIpzsdXzl9/sx6OGnrAu1+RlKMXCEbbUdS2wj8Q/iCqSIw9I97fN+R50WHWe+vqVhpOpPmuRm/KnVtcbctcrhiWONKmkRHuHmVbnWrW93qt6tvbkTTtNK19eNlFWy9x/U9rncyzPim32sxjaVm4nFmfj1SltiW+F8nPjVn/Kanu9vhOtcMEuhhUys1Q4krJgTC/T1hMwqr00wlp1LIJ6UurceZPK/EZaVUTaC6TS/Q9hTx+x1v/vAD+++/x/ejpnRx1S7RWPADpWTq+YQpqUUHKrte3EwZUey4b+vboOW8aZOsNtXM68p6eNa0Dtce7FnJTUag/WqhloRpwP6SsiZx3mJsbVGTwvfYy9q6FGpaUdPfK5FpWQUVb2YKc9GBGkM3DIRxQ7fft2Qd0w4AuWWoJ9bDq7S97bBgbdMA5kycV/Ky6JqPoziTcJ18kRNlmZVpb7TGdH2PaVNM6UPbw70aqmlTwCzUDqj5Kznihj3DwzvC2NizRmYmaWMTJifi+cj6/EXxrt5fDyrq7NvKNibS8RVbIt46TeQuhjlfG4hf76Pkr8Ld2oaL+XxkOZxYz7M0o85r/d4MTiY5qqsC7o+jJtrGqufKq/i0qZDXVfKKvhdWtRY169Yql6yaKwKJoluIMFCtJr4lrdjNhvH9O/rtXtpJXTFNT32QkWg+Ec8Hyhqxl4lxQzvFZaFW6L/7gf7uUVKRuOg1O/1c3/X43Z715x+l6QxBTvN5JQwDrrNCoGUIvZexq+Gvyjyroew7umFg2O8Up6pX2aQYBshyzveDtKTlQgOwmJYyVr0nx8Tp+Yn58EyaJyDhuoDxnhxjQ8YZKBbvZG7KqdEMnJUKpfNs9htcJz1rOi+4LmBD205MK2k6E09nctahQoeiirW+Jamh5Kt5hqjGezqe/zW/W291q1vd6lbfUN/ciO7e7IW02Y4yHRiD7wO+67QdL1nonKTGLE5n1pcjeU3CDbUV8iW3PIwD3VYPdNt1FGpLjJRZiWjwux3juw+C5GsfDohJ2A0b8uMDL8cDp+cj6zRjSqHrOsZxr0atVPww8Pb3f2D33Xtc42KWNWpVHHqM7ylrokyvkGatnNs0iCJTDF2H7camH5VuT91HS6NZFtbjgfnzF+L5JCh51+FCixM1BjvK/VySAPJ1TRS4TiCdE0fTeEd6ecE1tFIpBVOipj3NpJWm5X/rbm7+cTWbEHYbhrdvCJudPrwiILnpOq3tj0fmp4+UdVXWvbWY3KQPab0yFMP+Hj+OXydxinWipij00bxoao2hug76/ur+Ns1AU5J4kBZNrMQ/lzzBjQPd+x8YHt/jaJpYYxppocWHTifOn34hLTOu6xWhapAxqqA4SmNYTydMVqZ8qRXXDGylhR2oyW+NelGELI1UQM3E84nz80FrWB9krilFZh1npKR0Dn+30+GiZbGbZhLK60o+T+RVFIVuu1OznlO7bvrZtTQ+qPmqd67I7U7SFL9/eGR890ar9ZyuSK5mAydPiw4RaQEUwSqUmBgF6bRg+5Hddz/gu/CV2GB1r1Cly3z+2194+eu/4LtAv98Rj2eW44zxRsivBqQPvce1iM8S49VUZPqe/v6O4e5eumVzgVwBaZUDvoIZ95qwZmnKNfW3mJLBefKysBwUAGExOOuIZIyzOLje52KsWkwwXw2PTb9LhdBbnDPYbqTEJAoEUNdISlXmwJJ0eDDoXkjS8JYoWUhKC4WMDx2uM5y+HHh+ev1X/nq91a1udatb/bfq2/FNQ4cbOtwFvXTBuyxyR0OlxkiaI+ksFp/1DtN5gcuNwRqH3W7wwRLGAeM7oOGbChCzGqC7B/r9Ht83jVnTiNaqh/VyOnH6+AvT0xdqjlgKofN4rxShnCrD3Y7tD+8ZHx9xfS/t29Lg6NZhui15jZTPv0JaMV3A9hs1mc0Vb0LA3j3KYV1yYzy2KVwDe6fzkfXTR9LpoOFcLxZirVVTF99jx466zsLMWKtJZmoNhDH4zRa/27amQVzQGjVxTCnJlY1Vb5aKDgKhV8JP0QTVeIfbbBl2W/xmK2A5jRXa9dSSiIdX1tcn8nTSmj0o29tUNWspq3GwXTtg+MAlypOKYi4XMSfLvMpg4z3h7g7j/dVAQhY31rSfX7ANzaVmyHhP9/iO7Xe/x2+3sM7N/dw4q3GlpJX1dCAdXqAUwvZOGtWctVa3moKl1sD45uY2VdO4XIpUAZeIWK8mvOYiPGrXCd+1RubDq9KTXGDY7ZSytEj2obVzT9jtCZuNeKdBVASomoC2/HWD4mKNlWazliIyQ20/E8VYutCJUlXbir5mXathJGw2dPs7SUpKvh76LtrY5XAinmc1tt5h+16SAuTKpxg2v/8j3bBRXOU6a+XvvFirKTI/PXP48a+sh1e8NThriA3x1W96/NCRq0Is3CiZjJi1sZnnHDY4+rsdw+MDNvRc0FGkqNedI9U63HbTCARJ8gVz+f6sVBdYTifSyyfB/DtRFNLZSlPeUFfYQGgMVuNFiGhnUmwf8Mbjx06/Ji7YKB/IKbUwhkRMWsNfunrbeUyFnI04xhVSXChFXFRrLfPhxHw+0/fuf//78Fa3utWtbvVvUt/ciPbbsWVXq2nJl7QRK9NHPM/kabnqIEvTRFovvt8Frm28xYWOimt55oaStO51d1vCODQu4WWFLw1dns+sr68cP37i/PmJcokobE7nWqBYJwf8u/eMb960bHk9mMBguhGMI88T+fOv1Khmw4agprhkNVFORh3bD5rklgrdoCla43Hm80ka0Oms6VBLvakNfWSckyv5CkT/ai6xLS4U5/Ed+MFrtXvW2tr1PbFW0nmWC12OHzDiOBrfYk2LmoJuuyVseoHfnaVasKHDBDET0/nE8uUjcToJXNB1zSBTKeezUmeMlaM9+Ca9aAYxQ3M169CRl0VNUB8EZA8BKJR1vZIEjG3rcGSm8n0gxUjJE93dA8OH7wibra5JXLXB9UpEKstEOh11XUtqjvy2Qs0taaffqLk4vlLWFWflpIY2j8tqYEywWKuo19JQT6ZJHuIyMx/OpOmsNKBxg7WWvK6UKLSXH3r8MBDudpqGc2k+c0uFkkGr2f7bFFhTT1v+gZ9q1Oj40GH6HqpV5nvJ0OIz3TjSjVuca7Ga6P6g6HCWUmH++AkQ//L6XkumVmmB7eaOze5BDNe4NjNbB3rVpHni9aefOP3977jQqABrJseiFfZ4wY4ZvHW4vWDvtRbq8SzWqlWcb7ffYkKQ5MR3Cm6IC3VdKDkRUyHcPbYDJDL2GUetSYixCtOXj5R1VsxuvmTZV8KwwY1bSXrmFW/sVZ5QLzrRSjOpOcIw4PtO3892ZfKytmlnIa2RaqwazqRoX+lxK67ryTmzHE/krO1NLYXlNDXUmJMO+Va3utWtbvWb1Dc3omEUbiWvkRyFGaoxKzpzaszLXBso3Sr5pWqiU5MeBikm7LJi3jzS907Z48bgN4Ky2zb9EVOyxTyeTyyvr7z++CPT0zM5FTWPbRWJhW4c2L27p99t2b19q3VtqeRlphqL7UZNUeJKPh8oiyZKco9bNY+1KkZy3LX1bQOIGwNeaU51XdQQH0/k8wnTwP25Vj3Iu46cFadJLtT54ratypCvRbSBoSfstspMj1GrUsRlrZfMe+NkEilGxjBr1azRHsbG4oaOft+A4mjNX8mUktWMHJ5ZX56Ih4OMKH1oBrMq01NLL6JUcI0n2TartYLJUZnwqcVJlovz3bYQAGWslzU3F7WTNKNp7aDpXK1l2N8zvPlA2N4JoZMzJa1qugxqmKeJeHimpiQclh9liMnSWeK0So/HF00I23TzwrWtssWDcWq0aDKAFKXZ9IFS1WTMrwfimgj9IDYliN6Qs5qb7YZuu1G6UkP+1FWrdqrWvPF8wtJy1d3X8AbB8fU9kP5UkZlmHHDeKZkpyentQqDf3+GHJoG4ECKqNK0lrqzLRDwcWrqS12s0bTIIUC3h7pGw3VOXSZ+taf+W9ZSYmF+fOfz8I/PzF7yTI78WQ+h7cqmkRXn1oQ/afPjwD6Y9wAkrZTtHf7fB970MQnEhloTrRkxcmA4HptcjaYmE7Subd2/FEbW1reYrMSfS6UBNioiVFbHJAZwjt++uyemqTXZd0HctruR5xXUeHxwu9LjOC+3k9WfSaYIiI1WadYiyzpDX1KaiLT7YO0pRClyK8cpyNbYS+g673dDvFWxxq1vd6la3+m3q281K8wpmJaUix+m6UmO6QuxLozhZZyBIq1ULgtS3B4Ax5jrpDPs9fhjlejc05iXg2xr3PDG/vnL8+JnTpyfiumrV3yaLJgTC0DPe37F7+0jYbhFaXCakahzViwlaU6ScD1deofFNV2namr4fxFw0wgqZy/Qlt7jJeCbOE3WdKfP8tRHoQkuJkV6uVLSmzaX5McxVnynUUcB3XlpH565IJHIzsxQZXfK6Npe3uSKQLuzLisH1QeiaTtMzxYh6bNAKPy9n1pdn0usrNa24XoxTUwp5jmqWc8E2Lqt6N9fczBWMIikvpqnrhNHai89E61nfJslOWekA1rXUHGOpuTYc0wa/vcd1Sm6qVDUdtbSEnkiejuR5USMAkiY0w1OtjTe7LloPl9J0x64xKhvj1Ng2nbPNjNa0wC2mNC4Ly+uROC1AVbOFErJq1fXotiNhM+K3G62KrRVoftXnSinUrDxyiprjihKmtAcQuxZjZE7ykgWYoBhc2v1vnafbbHFdh+2kPTamJVoBpVTW05F0PlJrJWw2wmPNi75o3kFncZs93XaPDR7iDFRMcNc1dHx95vz5M9PzF0pc8d7hnSPHjPMG4x1mTVftqgvdNW2InCSFcA4/KBzAd0GGRd8iVUumNHd+Ok0cPj+xTKs2CSlxziv57k7osK5X5GlaFCvrOsk1Cpp6F4H0l9cjZdGk29Duk6q0LmMsfvD0+1H66FzbpBppWJMwVHnNxPNMxeDbZiIvCspwXki4vK6SEeWLGa022YGnlELXd9x9+MCw2/2P/Za91a1udatb/VfrmxvReJ4oKZEWxXga0Ao+N4NJsFhQCotVfnmOtAerJob93Z5+f8ewv7uuQmlNC9aQ48LyfGB+eWF6fmY+nFjPC2mN2Jaj7fuezYPA3uN+p4ztxlepBnAdGNemSRGyHMzGerCBmiPFoLSm0GHD0B5okZKXq+Gi5ERpWeFxnsgxETpNiWqqVGs0QaxgayVP4jHWUpu20AhWbqQxtON41f3VLOwRRmgpg9bAKa7E10k4mxZXaJ0TJNx7fNdhul4rxpK5xFJeQPRlWcjrQjochJVyWmMbb6kxEeNKypkU1ez4EOh3G0WYNvew4N5KdFI0ZgDLdaWtmFWP22w1xTNKnyopY4IOCjUVSonYYUPYS6NrfNNwtvupJjmY8+lELVF6vxDASWtcS6YsMkmlaYHUYOUaAWqK6XVw4KIXtNJgXo1txmBDTzzPLK9HTcj/ITtc7MyM8w7X+2ag24oA0UxNeV3agLJo6l8br9Y7sWJzadPZpPtpHNoBRG5+2ybFNVdqlNTAd6M4m16ueyHDaK+5ktbl2oQaJznGJVKTWsBZ/H5Pt3/A9gOmJOoy/YNEJBDnmdPPPzF/+oU8n9uE32KdwgJsreSYyYuaN++DMuSroS6x6b5137mxI9zt1Cxb15BYhdJCIvK6sDy9ijE8L5Azvh9lUIqJ+fmZHFe63V6NvEG0hVovH5PW4YeJ+flAiQkfNO29pHOVZcJ5S3+/a3pQK220bZPnUilR8b7rNFEX/c6opiVWNWKCMZacL4ecciUmhIbHylRsF9jd3zPe7enGrUgBt7rVrW51q9+kvrkRXV8PmryVSzvRNJ8WbNCkrOQiQy316rz2/UD35g3Dwz3dZov34SugvmiVmtaF6eXA9PSF6eWF5Xhmmdem+1MDNNzt2L19w/bhjn67UROIelhcEP4GmSXKMkOKMnBofKc3YbTStsE3Q0JrWtaZWtN1rRrnWdO3NTYGaCUEoXyqsZhuoNTMOq1a2bfGXCk0Rko1I4apMsGDpnIXHmrlmtxyoQZYbwktnWZ5PYiNapV7f4nvdL7B3y8AcOfbA1gNc500qTbeYYcOYxx5zaRplYY3RbDSg7rQUXNhnRchuJohJkc1lbVWOaUlspCGtw+4YWg6Ui8IfzM6AdSUievaggMKrlRsv8UMW23qS6bkSFlX0usT6+nYMsrlilbakuQLOSXxPmvGZBm7ikHTWd1h12x7rJH0oTnTTalgnXSVX15ZX4+aorrWtNRmgjE6MPW7AX9Jm/KdGqCY1WDSJBMlNY3qRfebmv5Rk2K7vceFXpNJY6gxSULiNDWXQabHezWm1geZyGppXFdDrqUFCkzUkmV6K/WaWGUMmHEk7O8JuzsZnuazDlxG5jNsYj4eefn7j0wff8GSFZVb2ySwC9RaWM+JMieMEf/XX+QdOVGKkpZc7wmbXvegc4LQ16pwhvXShDZkGjRTmGMzDs1oKMpDGDRJNY3Lm7MoG+SMGwZKTqzPR9K04IJTk9+kC1hDzprM95uWFQ/UnHDWSapQMmlNpPP0dbodOnzwauBLUYxurcRl0Rq+oGve9O6h87oPnGf7+Mj24aEdSC4Rqre61a1udavfor59NR8z1ssF7ayhmsYCRVrQ2pq4HIWr6bdbTS3v7/Dj2DiH9sq6rCUTp5nz8xPn5yeW40Q8L6RlYY2RmIRQ2T/cc/f+LdvHR/r9TsaUuFJTwQ4DZtxSceT5rFSjosblYtSoFplDnMXUjPe1AcEvaU2SDZSUiacjZVmukxo1Qmj929bipWhiVWLU2tLa5qovlFKby9hjEaZKue32q1GpIZhsCMIAdWNzi2vKt333AdcPrKeTdKfWX/PRc8lY7/Sf0KsBLwWPpkFR3QbCJimVJy0LcZrJsQj673yLx1xb47Fep3klt3SnK5BcOkM/dI0X2wvDtEZqWqitQa1F8aoXjaVthi01Bwv9sjK8eaMp6OEFctLPb42AgPaSSpRSWKcWU5oyrgv4QQ2UrVBN/iqHMC2KVa6pq76y5MzcDjT50hA26UTJbbXvO/zY4fuO0Hf4YWy+sossQ0zYFKOkJJ1vGfP1+iOtC5jgsX2P6cd2vS4xoV54IsB2A27c4EL/dSbsHVgPaQEMaTqLaLDMuueCb5N8pwOZc4TdPd3dgwxc60RJa9PDSB9ZcuL173/h+PPPpGmiloLvnCQczrUmMrHOC3lKeB+u8oNKFTqtVHwXZH7rvLi9Tg5zHVREP0jTRJpmTX3R5NI2vJWp0v3aztHvtoTt2DTMiYxph9SMpTZd8FnhFM62aSuaWFqjmGBn8H2PG3ppl62VMQ/IaSEvkTgt5DVpYttCEkpOWCeZUK6FZVqIjR1cchEgvzGNM5Ww3bJ5+45hHBUgAEoqSxeO661udatb3erfur4d32SqBou1ElOSnq251i+Nj/OOcTeyfXxkuNvjxrHpCrWCN9ZSamF+eWZ6+sL56YXp5UhaU5t60B6EA3fvdzx8/x2b+/uG5tF6GGOxm734n7WQp4kal6uGEizVVCB/xRyh190ydKCZSjBQ1pX1fCSeTppMXdz6Rpgh03eAJZciJ27OmJL/IbO8JfVstvS7Hd5ZTBIQXzrLhnGqyGDRD2okro2UHOFiWypq0DhlwotPOevyByFlTJtuWeu57BWt82we3nL2jvnzM+U8U2sml0KJMiWFXivbmjNpjcLgWE2fbPv8LmtX2qrUeEe4fyDsGhNzXcV7vUwUraUUSSryGhudQA5tYxtcPS6sTx+xdcVUXcNS1eBTjdBAVU1sWgtlXjTVwly1fDovKBLW+NbkVa6TxIokIDUl8jyzHE+UJRKCJ3TjJUGSGqPeU9//QwKYnOI1S+pQW8xmnibi8azV/Tjqc2r3jfNe2krn9TlZ6SEJyk6nSpJhuh6/2TUzmSQNNIOe/k6kxMJ6fCW9fG73XeOwFmT0o2DCIKPXuJFLflFErhBeBmrh/PTCl3/+M/H19Uo78J0iSSti6uYYlXaWlOLVbTbkrNQz07S0rusIm0F59t6JtWo07a5AXqKa0GVWXKqV1tkFT3U6kEiK02mNHrqmES8C9rd1OsWynk7kRfeMadQEUmkT/YCxjjB0cu7ndl8ZdB9gKOtMPJ9Ja2MPF32pq5Ek4DIhX+PKfDjKLOlksnN9wBZN+2NMbB4f2b//jm4YtLGh6YxTVAzvrW51q1vd6jepb29EvaHWpF/6FYGlAVMNruvZvn3D9vFNYy3KBIJtjvSmuVyenzh//MR8fCXFxPm4UNZMXCOVym6/Y/vmnt27R8b9fWtknZqgUqR37AdB2Zcjta3YjG1mIAPk1pSOd/qzueW/15ZWhEwcOa6sh1fiSWaQEjPukovdDEwmeE1Q4iLzTM5a64cO5kXXwhg2339HP46k44Gyqjmy2GakkWHFd0EmpQuKqU0za0GT1qy1eM6atMpoo4evC46ynAnjI851mlgaaRgvk2Y7DGzGLcvzkfnwmWoq1jh8CLjBU3IlxQIW/NgrE92HK7apNO2eols9brvRatJYyrJcNYPGqBksRtOsEtsEOdMmYU1055R+5YdeCUJV6VK1ZjXRzbhWaiGdLqYRTclC32H7To1sKYLZB4/bbNTAZelYTYsGvSRBreeJnJQQZX3Q1MwYqjXkUvBDr8amsxgnk5AcdUqCwgIlq7mZZ2GKwqaFGGQ1XsF9BbJXNcCmyu1tUtIhqFTsuKPb7VvgALqPL8xQ3wOW6fPfiU9f5Ca/xKYa2xpWkSfC/pH+/p1ea1qVruUMdFutueeJ17//hac//5WyRnywxDXhe0+3HUhLpCbTnPoXU5LSq86nSWagmPDB0u93hKFvE96Aa5QGGhprPcpAWLNW3xgZC61zGCxpEi6p242E/R7jLCmmJqGo4HSQLDERzwq/qKnJOmhGxkZHuDTEtpne6kXMiSgWeVETGuemT24/ojbTn+/FJJ3PZ6bTieWCRnOWPEdcsIxDR14j++8/8Pj737fpsKJRc1Jja4LH7e/+B37F3upWt7rVrf7/1Tc3orUWUlFeu7lgl7xnfLhn8+4d3XajddYlvaVI75jnhfl0YPryhfj6qqi9lJnOi9AqxtDvNjz+7j13797Qb3dKtXGXl2Yw/YgLgyQAceIy4hIQH8Gx80K1go3bTk1kjRFSvP55MKS0Eg/PLC8v0t11DeGUlajjxgH6gZwT8XDQQ9cKkn7JLZ/PZ2zo6N7fEbpOE9v5TNj0xGlpaUmagIUQrg+4sq7UGsF3MvUYOdXjcianVXnrzqoxdRZTCmEz6iE9bPBh0ATaNFB9MJquWstyPvPylz+Tnp+hFJxzSndynlISpWQ1huOAs5oOkpNMVMZiUqU6i9uoiXCho66xpS9pklemWcaRVFgPr1dWpW3GqlpqMxVV/HZLGHqZidpKvEQ5sNXvG+bDmfX1SM1FkZvO4EeRDkqMpHXGOcuwGcF6Kp6aMul8bvIHS1pWlpcDcV7BBWzXSzto9JnHlmPutyN+6PChk6Tkku9eCyCcUl5nSlrIUbIQ5aDnq3bYDz1m6KVhPU945zCmk4kqR+qSMcNA//gOP4xqjoy5Nq61JKwLxNOR86efqYcX6T6NFeqsNVoWsF3PsL/Hj1utxlOUM9+0z7xWpi+fefnzPzN/+YJB36O8LJQc8aGXJNlKb2mNxfcbfOdIMbKkwnyeGILHdZ7xbke33TQMWVBUaxYVo6TEejwRlxU3jpqyFh3mjHPSnc4rlMx4t9GB66JfaNPZS8hBnmfSSRIOrKVWQ0x6794anLE4b/HbEYvW/nj79aMy6NASF+lbu55aNCEGqKbS7zZULPPhyHI6U2Ih50opibg2xJa3TKny4d/9gYc//UEHxEs6ld40thtg3LO8vvx3/lq91a1udatbfWt9cyNaYjNlGAh9z+bNGzZv3hCGQZNG46HKRWyqEE/npyfm12c5sJPWdutlhVsqw92Whx/ec//+nfBL3UjbC+shbi3VdY1ZOmFyliGj0BqySl0XTTAv7vcix3kb4Glqlmjcx4bDaTB4YZQ8WIN/swHfaQJ3PmvdX/NVr2aoLPNMBob7e7bv3kpw0PBDOCssEtKz+VENqulGjAttcmY08ULr7BTltKdURWxarXWt9/j9BmJqLme5hK/JMJcVujXMpyOHH39k/vIFYsT7jn4zCsdkDLkKWeN7JWLJPW0I221bBVtilJSg3+/xm10LKVghZWlf0wXnVInTmXw6N45luP6cmmU+sV1H97CXE38V/L4kIX6E3gosU2T+8oV6CRowFu9te/9yY5MS3UaxqpTSVsCJdHrBWk061/PKejxSM4rUbBO6kjOgla/txWzttmJfGu9IywqrwhdqEV4sT6siM63B9xs1xzE2Z7vBbbc6tOSIrRU7DkqewiiZyznC2zf0j29llMsZQteaUJnoKobp+Ynl088QF3FA66V5N1ftqd/f093d62DnGpLMotV/LpR14fjLT7z88z8TZ20Ahv0G5z1LLWy6HdY51uOMNa7JMi4SjIRzjpAj0VqGt49s7rYyBxVEfLAiIeQ1ktbE+elFk86hBSTErObbO6r3rNOM84bhh/eKqgWqdfqe14oxlZwz6bQ0CYoc6zIWGU1Fa6UOHWHT0e13MqQ1rTephRMMToak9azJ++W3lzWQ0WS2sXyn11fW89QMSQlHxTlDPwz6Pgwj7/7979m9e6vWv0JeZUzEOuxuS3Ud8fkzlsitbnWrW93qt6lvbkSNMfS7LZs3bxgf3hD6oTmJlURk2jQhzSvnp8/iWMZFLvJcmU8z67LgrGN82LP78Jbtu7eEXjpS/AWNJExPipk4n7EWwu6+TT4K1AwUxIYy2H6P6Ye2epfmqxYhdmiGk/XwSlpmDGDDQK4r2aSGTRJDtJQqPWbWvy3QesC6QqmZWC2b774nDEEO7hTVD1sL1TaYvJp0PwxqoOzFONR4nFhqSsRmNCkNiG+NvcYmlnXFOIN3HabbapXaGI/GBekGbWU9nzh/+sj09IV4PmMyGB+ESgqe9XSmFk32uqFr02qLcxYbpLuksV/9dkPYb8X5xFNzSwyqlWocJcN6OFEWrXKtd5qEueYQLwnXd/huEOQ+JUqNjbJQWtpOm6x9fmGdZxmIqjR9trPKNy/KMnd9IOy2bfKHkEwVSAnrOkrJLF+eiGvGWa9YTWNJKct8VSq26+jvdtKCdtLXUpKiSXOS674W6hrJc7xGO9ZadQhpE2vXDXKNtyYZ5+ScT1nygAp22NC9eUto+fKAIPjOtO9IIq+J5eWZMh/bYWkEWzA5URuI3QwD4e6RbrtXKpYx4GS+EU5sZT2fef2X/8L06ZN+zKADj+JiJQEpsVJjpQu6X3z3NZKXYkgxYrqet+/eSHeKmkXbjHclqQlfDtJOu8ZmLSlj20dy+bfKPNN1jm63xw1dk7lEbUTQfb/OK+vrUZNeb3WAjJlcIsY4QuexwdHd7em2myb1KA3PVRv6KrcIYW0cZPmqkDLegt2O+H5gOU+8fPqCNYbQeelCqc3Ar3CF3Yc33P/Tn+i3u6smuM5zoxuI9FCx5MMTusXDv/b3661udatb3eq/Ud/ciL79T/9eDvjQaSLZ8r5pU5bzyxPT4cT8+kpeFjUGOV/1WzZY7t+/Yfv4yPjwoAmo801/x9Usosbxhfh6oJYs9FHoCc5BnAWrrwYzbHGhbxO0+at+LGdNW6aJeHglzxOlCt9iWxKN7YL+vYpc0dMEVKyTExdrSUmNWLffYnvxMskZUiG3yEtoa7yGQ3JdwIZBWJ6Gkqo5N0Znbq5kpR/R+KnWGjUJ6L+7u0ehfWiQ9lplSAmBiiWlhfNPvzB9/KjUoVKxOEwnA02MijY0phI6Qf81eUO0g1yIUelBfrMh7PbYZhgSlD1BypTUzFM5EY9HqAXbd5IzNAxVWVYwlu5uq2x6I3qAqVXTXyuHdCmZeJ6Ip0sYgFP4kq0yC2H0+voON7amuTEfaQarskykdSXNi15nhdAPIhOAEEKlYENP13u6/UaszjaBLjnJKJUypSGnTG3mGmvVhFc0BW7A0tDL7a50rUZ7aNrBWmv7vO4Jdw/tdTRqgb1EQlryOhEPL8TT4TrZNX2n+2JVQ2xDj9/d0+3vsf6r+1+6SSVmxWnm/Mvfef3rX0ink/SvVnrSaizrNMsUZ8A2ZJIxbQLf0rRiFIvUDx3Dmwf80Cv6NKUG5oeSKzktxNOZw8cvOOfoeh1czOUAQjPrO0vYDITNRsZAZ6VDRaa6aivLeWZ9PUoPXCo5JVybfnduVGPqLf3Dvk3sZUhynYdSyDVTrcd2geHNIyWuTJ8/KS0s5gZ2EI/19PTC+fmoZDFrKdZgkRY6p0j1lv3vPvDwxz8ShlFT1Tbxx1hsMBB6cszU81PDfbmvaWe3utWtbnWrf/P65kZ0/+49IDMAGJlM1shyOjI/fWE9HACrSea6EtufGzYD+zf37N6/o7+7U4qMc1qng6ZgKRKnM/F0oEyT3LFdwNieWivTp4/U/YQzVXrRYSvdYlHk4iU6UOxB/VvpeBbexjlcL83p5aFbjKZCdV0lN3DCvXBxTSPdox9bxGOMzejBNRPbWKNc8BDwfa8M+BYvWVtcIDVTTaWUSMlRnEXrKOihbK1p6UZe8aLBY21osG3JCixO+tzzienwwvz0hTpNMil5h0mF3HiWJS5QCqEPdL0kAcaYS2IkpSoNyntPGDvcMH7FNJVybX4LhpQieZn1XqvMImWaKWvU6+wDYbtpphDbmJtGYHnXYPDLqmjX80ye59Z0B6yRscw2lBeAH3QNoTn2rW+Rsivr6UyaJskKrPSDxuq95VWfje8cftzimiHpgqAqMQm1VTM1ZyVfIakAxkrSYZQARpuzmdDh+g4bLglCbcreeKBq4neE7RY3dC0s4WKWawePlEjHA+vpID2jtYqeTVnmt6T1thu3dA9vCfv7NoX9qgGtJZHPE/PhyOGvf2N9/gim0o2SK4heUEhNx+wMWBzOe11jp0NiXmSGst4Stju6nfBEtjTeb3Oy15xZzw1NlhLe+yuJwm3CFQFlvcMPg7BeQe+90hKqikxfKa7MXw7E0ywVjUUT6KoUNusdfuzpdjtl3NNW9KVo4pqEmsI7+sd7ut1On87QE7Zb1uOB5fMn4uHIOq8sz0rMumxNbLAKu6CyTCsubLj/0+94/NMflKhlLKziABvjJMuxjjzP1OmIc0aNfAW4Ae1vdatb3eq3qm93zadMNdJBrvPC/PLMfHghTRMmJ0o2xLiwLtLLDfsd+7dv2L65p9/vcd1wNdbQfsGndSVNJ9LxtWk3m6P46jDWj3ZtomNaw4cVFkjaU6Fb8rq0/0RyvGjTLhgWGiexXJNggOuDRoYkdzUCOe+14saI82iFSKqptLWqxfWDIkqdu06dLg1Lvegq0yrkjwNcY11CSy8qWBdw3fgPDu82eWpsw1qK0FLHA+t0Ik5nSsxYwFwelMZQjKI5LQi9M24kcyhtkuO9dKtDj2tu4lqLmjHn1EhVS06JNM2aIq+R6+ir1rZl1etyfU93t8OPw/X66xq39zUMrMvE+vJKXXPLpW+NepVR6DJtss2lb0JQP5zkbq6pkOvMep5Yj2dqS9UKo6QHVKhJbnfbdXJqjw05ZKUrzMtKWVZqSQ1BlNQw16JpfLsOOUo3K92tbfpXJ/asNZrAWysAe9fjxxE/btTs6kZCBr0WCTtPrMcXyiyWp1pt0ya7qyQTw4Zw/4Df7mWKcfpeWNfJGBZn1ufPHH/6O+dff6W26bMbAiEor7429FdJCZer9MSNhAD6/+c1YqzBj75tIVq8bczkmiHmto5PrKeZvCRco1AMu237TiB82NBjnMV7J6Zs4wGXxlqtKYP15GVheX6lLIkutKAChCazRlKDsBkI2174K4R1u6ZZzTrU+M3I+O5d+y5WGd/QYWa4f8RaQ5xmlvmVNSVSTlij6FbfD1d99/Bwx/7779i9f6fDQG3xrzkrYa3baFp7OlCXk2KKvW+fGTKS3epWt7rVrX6T+vaIz1SYDi8sh4M0l+ssrieSzqWYhGB68yCU09tHuu1O4HVrr9OQ2nK703QmHl4o87lNZFpKSk7UWPDD2KYuPW7YqOG7rGtroRY98NMkGPZl5VqimkV7ccNfullapGMVsN02E0NtUYxY0yImnVzylzGiaQDyWuQ83m4V2dkF7MVQQYWcKVUpLaUIU0Rb32oy6fQf63BY7GjwYWgTYt+a80LLDGI9vLIeD8R11kMzFRmaLtGR3l8fqJaK8Q7nNvihv4yf5H7ugpBafae+MiVyw/hY7zBoapjaZ5Knub3uttIu+fpnw7DFBq/ppffXhppSWmKRAODr8UQ8T3rNTZt3abIvGfdu7HSd2wEgx0vTWGR6S5GcEzllfNfjB01erbOafGe9Rr8dvzaoToeB0vipNSeoSkQqOTWepdFn55U1XnJtpIVOuKJar7pUc/ns20HEDQN+sxWe7IKpMlaNmnOkeSa+vJBPL5S0NlkAV9d9rZr0++Ge/vENbtzqsFP0M2X8gjQdmD7/yvnvfyE+P+EMmFHGJz+Edg9U8hIpS2zNl29T/XqlJCgkwRHGXii0y31mmk6zWqorlDWyns7kNYuWgCbseIPrNAktFVwXcJ1voQy061d0YDGScaTjmXRWTK0P0u6Wqimn6zSptkPAN45tKRWD7pNSLtpQT3d3x3B3p2Y3xqa51aSYLK3o6edPTM+vWANdcJji22cVBN6vsHv3hvs//I5uv9PBo5SvTX03UEMgx0J8fYJlwjU8l/Ghfe+iruWtbnWrW93qN6lvbkS//MufictCbitSuOAFDT4E9h8e6Pc7hvsHwmYrziBwiUGsuUHL55nSIjRpWek0ZJEx4HqPDx1h3Chi0nCNzsTpIZmniXQ+kudZbMqUWm64flYYBtzQK9IyyrFvnBozN2g9WmNums6uMfkvbJhMhhb/2dbj3svU5AI29A2y3hpN7yg5k9Os9X3OLRveUovR1CoXnPUYbIvu9Jih/VvOylhVlcy0no+sL59lNqqC22tNmbHO4ke9luHukVoy08dfgax/y/jrpM8Gi3EG2w2a5i6aBErKoAlXtV5w8vMkVE/T89YiV3OpmmL5oaPbbXBekHFjkLZuWSgpYZwlN1i9eKuJGmUoMW2yVBo8PIxezY1tHM5ayIvWx5I/FKimmbMcXQi6Xl562moB43GOJhHocKHDXuIcY2qGo3SVROS5aYhNQ4thyGsip4rre/y4uQ41L7rKavTajBX/NQytmXctoMFY4cKso6SV+dOvrK8vmBxl6HKuMTLbOh+LG7eEuzsdrC7r4XJp5ColR9bnz0wffya+PlHmWcgo07BCMZKjgWpl2slZ3xnvlUoVU5v+yn4fNj1hCLpvnbtOXUv+GjWblpV4mqmpQemrpAUX+YUNQU042kwosrTo0JDSdXIcj2fS4azvVvsekgHUENvO43wgx5U4Zxg6gjetCbWauF+oC/s7AfVL0YTcOkATc0pmfX3l+a9/4/zpiZKiJB4GnHMUIK0R6z2Pv/uOu++/I2y3et8xqaltB0rCQDq8kF6f4MKlvfBcc2mkg4rdP/xrf7/e6la3utWt/hv1zY1oXpS9npYo97mz+HFg8+aR8f5ephfvxAC9ZLvX0rAthxafuX6dQLZhU64V6z1hHOWe9UEGFne15161aXk6CTY+na4cyBpzm3TWtmbzmKGjGocphUq66vo0kRV2yO92mJypJWsKWRoeCaMpFZoyuaB4S9uNLRGmXlfectpPYpA6JyC6U+55zTIj1Rz1QHYeY1tTYr2g7i6AFyw9Hg5Mnz6yHF7k2vYB5wMlZdK6UIvBbzds3jzS7e6wXlgr4zzx9QmDNKA4o4d+H6TdKzJumZbag1WMYsqZclQzX1sqTUkyf+SUMcHR7Ub6TjpAN/RXUxElk89KL8qlHQBoGtusabWkCih20VjCGHBB6VfGu6tJjRjlim7JWuKSShqh5iE3B3Y7rDgvlz0GF7zMOg16T27r6LhSlqVltldNsL2X3KC2g0lwmth3PbbdG1iPMbXxXit+3NDt9s0x3yallTZB9xjjiNOZ5fOv5NOrDhmosazGNpNawXY94f4NYbPF+ItEocphL9ePVuMvT0yffyUv56+mH2OZjhN5nYCCC4Ma86brdK5N/XPTLwO27+h2O7qh1/Tyshkoyqsny4wWpybByGglHlfJEZyFTnIJY107jDmZ+ayjxtbIdp5SCunLK+k86/7IhZKFPbuGG5Ax3pCisG6lVtZpot8mhrs7XKNL+L4jbHc4JwZwsXr/GKWV1VKYX5Ugdf7yJE5qrQRddeHTSqHbDLz5pz+yvds33bFiafMqioff76HfEp8+Us4vwrQZGhFBqUyVQjUOe/eA627JSre61a1u9VvVNzeiy6SoSb/p8f3A7u1bxocH/Haj6WdtGrympys5sb6+EI/PcjmXS6MhRNElBzpsRvrdXkzPhnEyxsogY+RejvOZ5fmlYWEuRh6tn6tGpoSxJ+x2WueuiZqFQTL9IBf4GrF9p9Wqs0LqtOlRNa7hfNQfW2sIXYcNvbSNofu6NkbNRU6RnCLiYDtNdFJWhrVVs2udJfTSYFZrpSl0DkpbSTvHOk3MXz6yfvlCnGZpML2mUDmtlJwJm5Hh/pHx8aFFUtpmGgmM77/DDSPLp1+xNeM2PS4oV72W2mIwqzRv1pHmhXw4KZigpV5Z7/XwbavRsNswvL2XNjdnLvnoNUd9fjVTqmFdlAl/eV8myDltq9Pwao1YW/GhIYS8B+Mwpjm1faB4Tz41LWWQYctYJ27pGmXeaX/XNPKBMa1ZQgcREReSIizXlbws5GUBYwjjAM61VCd9fn43KqUJGdWM91iqdJdZ+tFutyP0gyakJZPXhbhG3O4Oj6UsK/PTZ9Lp0DSwAZaVmqMauAq5FOww0r/5oKlrzW2bYNp9kKlZRrT506/NINRBLaQ1k0sW4sld0LkBUy0e05KNtA7PzSDlgrBXfrPBuhZ92qa3JUVMkXxmOS0sxxlyJISGPrO0yFN9hsZaTKnY0Ji1bfJfzrO+VyGQ5kU64CXiLtzadkDMOYsk4KzW3M4ST2cM0huXmFk5ktaV7Zu3jO/eEsat5D4tatdemkOkPz5/+cTzX//K9HwgxtIuo9b7uVRyKmwe9nz4T//EMA7Q9OZlmampxXtu7zH9jvjpF8p80Od72X4Y0wIYKoQef/egpjgt/0O/ZG91q1vd6lb/9frmRtQ5lKL09i3D3YOg302TR5bBxISOkhPzl19Yn5+o6yL9nfcCTc9yOBtvGfZ3Aqh3g6Df1qnxRI1giYk4n8jziXyeqEUPx0KbxrQHnus9ftgR7h+woaemyOvf/0ZNWUzFluDS7e/w40hNC3k+U5PcvdWYZmwyGFPxzisVJ/Qtz7xS0IqupERZznoN6ljbalb8SjDYpp/U1Di0FX/TqRbBO43xxPOJ08efWY4v2FrFNO08JjiZsKiEzYZ+v9cE1Ji2zq4oJlJOX5MlMQh3yjTHS/Np1qTVppFbO62J+HKAGNXkW6PGLCvasxqD24yKedyKm1mpTRqgfHNjDNUZ1uMivFZsoG9nRA3oHXVNlCWCqYShw2CvDWa9GHZy1v0wTSyvB5zz0oB6/Zk4z2KneocxigT13aBpt7NgPCWuAs63RJySsuJa49riPBXhWUuBtEgW4Z1kG9s9NId6bbzZUlrUZd+LifkPOKqKwbpepIKUiCmzPn2hzCelR1HJsTQphcIUcsmEhzcMD+8kKchRB6hugDBAO2TMnz+yPH/BVWlVa5E8whuLHQc5/dNZBhzXtUACRaNeJoDWWPzY0e+2+EEbCeM9VEXH1hQlvciZOEWW41mD3dBTEIkgjBvcOEgf2sIXrPNNQlCo00SJLSfeBpaXA8vLUdIN55Q2VSClhHXuqsO1vQdvqangN4OSsQ5z04xbSsn09/cM2zvdjzVTnblKF0yLOn35679w/vSrolzXQkq5TYMLS65gLY9/+MCbP/xObn8vvXdeZyhJG4b9G1IxrL/8BfIqTBj2akSrJen69xvc5k73e16py/Q//Iv2Vre61a1u9f+7vrkRff8f/wP941sxNSttHag1PV1PSZX5+Qvx6TNlWeXU3Wwx/WVykzGdox87us2A39+36RgyMzmHKZm8rrx++sjLjz9iKNx/+IAxnqIfqikbFjcMhH3DB/lOU4225tz98D2nX3+VXnS7aTihTD68qlm4rOqbmcRQ8aH76l5vKT7VusYRVNxkWee2wpVO0DamoqaYA4B4pa4l7rTGi+a6rU6r9unpZ04ff8G0KE6gtddFgO5+oH94YNjdtRV2xVxcxQ1qj4F8OpCXCazFb3dQUjMDOWovnVvJhfn5hbysiq3sgrSLqaF0rjzMHd1u21BWAOYKpMdWTL9hPpyYP/+iz7c1CS40PFaulJeJSsF0Xs1IaAaiIkMMzmH6Xnrh6UR6OeKHgTBKTxznSJwWTK34Psg4YqUpdcFi2rQ0xaQpnjHkdSLFWSv+VcSGbrOTEYpKqWiS6hxu2GB8J9lEc+2XJclURaXbbAibXdMAV2F9LDKbWUNeF5bDgTyfMDlJB5ziFRFFXCk47HbL9t17/LC5NlfGNo2zdVAiaT4z/fg36vmEC6FpaSssCzUX/DiqUT0fCPYSRtBRSmJu8HVTq6bu91uGx0dN93JuRj2jqXCbQKZ5VfxsTPjgKbXiO6u0Kes0CfVy05tawPh2yIq6O1szX4tlORxIp7MaPuOJqyQ3Jes61pzxm0GT3DVSV8kowFJrwfUecmK43/P47/8j/WZHubxW0L1lHdiO9fjMl3/5L8zPL5RUOR8mUs5YIyZprkpI++4//oGH338AZJCqxlLWNmnvN/jdW9ISiU8/Y2m8V2OuMcE6IBXoRjFlywo5UJdFuttb3epWt7rVb1Lf3IiO3/1O6UcpKbqxFvAdKUXWTx+FFloWnPf4zaj1XXO6gyEMI6HrMSVhxy2mH6WRa7rFPM8cfvqFp7/+jfV4whpNrNblJ959/6ENEwu+H+h2W+ntWhMnLSTUJA2YKdKbgVidWt9qpe4616ZWBvUGAe97NYvOt9VhUcNnIC0T6XAEUzGdlwGptDVeTuJidr0aLyMziHSnpjXahoo0gMvLF+bXZ+bTGd8FIYyskWM9rXTjhvHxgeHhURO5puu0xoLtGlKmkucz8fBMjQk3DhhryfPULoXHuI6cI8vrq1zwOeOMvYYG1FKhZFKt9Hc7hvttg8hrCS9pBKRpajQCy/TySnzRKtP1QexTK61vnFdAK3gXdC2MNa0ZWKnrLPyP9yxPz8TzBLUq8WnoyUtUU7GqkfZDIIxdm6S2NCnnKbmQD0fyErHeUuLCejwq+tWC6wdMP4hnGdWQ2b7T4SB0am6quWqUS5z18y5T0PCVY0q1GFOvqWHz6yuf/9f/N+vxwPbxnqHlmV8mqSUumBDo3v7AeH/fpqn5H7S5Xtc/Z5aXZ84//YSpBd+MW4onFZIJZyg5k85nTE5046jrUCvLccHJXYfrAsP9XvIDvjr4y7pq2puVmLQcj8yvJ/Ky0G9GragN+F7X/6JRrdOM3rLuaUrSISIrwjfHlel1IueMb4zSy4HLUAl9YJ0zrvfYzpCmFbKm76nJc2r7vt9//3vu//gnjPfkeb4e6K60ilo4f/qJL3/9K3Ge1UjPKzllcilUq2s/7nf87n/+T9y9f6fXa9Q8lziLULG9w+7eEk8n8vMvIhC4FnXr+yZfiZIBDFvJCeKk613K1Rx3q1vd6la3+m3qm3/D1gqcz01TKSD88vkT6+Eg40gXCBvFKYI0nGWNOO/ptjthYSpgB0zXCa2TEilGzk/PvP70C8vTizR6xl3xlcvrxEv3zNvf/0DYbPHj2NJdDNUaxAktWqvVSjwplhBbZHipyITkrEDf3mKddJbOB4xTg3DRbF4MPiWupFmmEetN0zeCKUZNq/bZGOM00bIC7NeSMMiQg7HkFJlfn5mePhMnmWdIBmyFIBOYwbB5eMP2/Xu6zUZu8mbeERdT6/0yT8TzKymtWGNx+93V1GVDp9eNYXl6Znl6xmKaE1hNA4mWxGNw25H9ww5nHSUVcsnYIHJBiZE8L6TzzDJNpHmV/nCUFtg6cSxjm3zb4PEbj2sUhVorBitZxbJgOg+5ED99pq4J13W4sWGBppWclBCFc/QbTUhtQ/0gqhX5PBPPZ2GY0oolU6u4pHh/PQyUVaxQ5y22gomVFuMkKUbJTTeLVtr393Sbsb1umlmqMWxbk3T69WcOP/9EPs8E78jTmbkWwqC/Vyp09+8Y3n3Adz2k9esXx/mriz+tK9PTJ+r5TBh6ShWb17QmkyS9pxi0CTKEcZTGsiTyMuOsFWpq7An7Hb5NmMFIctEOd8Y50rqynk7kdcVZS3WuLQ0kARFz1DcChNBN5pIulltEZ8lqFmNhOZwxGPrNiKmVOC/6rK3Yu8ZAGALGW9KyUopID9dpI9BtBvbff8/2w3tMNdT1Iu9QzO2F93v89JGXv/+VZZI2O8XWpFu58kuF3ds3/PAf/onNw700066jrAs1tiCLzR1m94Z0OpKff5W5zThKjjpUWws1QugwoceRYJ2x/SC7YgWokujc6la3utWtfpP65kZ0fnmh32yI5xPr6UCezpRVejA/DrjOf11pNq5m13f4fiNIfdM4Vip5nonLwunTZw6//ko8nsCIESkLEtcH9N2be4aHe4a3b5vesjmOqVoHt2SlUlvOuNFaENPMGkXTMuO0HnRdhw2DNGj10uzZphVFa/hlIq8L1ju6rZqNnDPk1NiXMjBdGlBjpVM09ZIyA2VZWOaJ5fhKPJ0Ejy8VbwPFV0rJlLXQbbZs3n/PeH+vlWKKlCrNm2n58DVnSlyJ51dKiTjTTE9csriFPoqTUoioCeedGtpmoKoVNQzB0u3U0NdSKEvGdAEb1HzlmMnzrDSjWavckgvWpKapQ5PJWnFDR7cdWzSjDha5VkwppBhb0g7kKWl9XiqhUzZ6LVUNdXufzllCf+GFuua2lmFpPc9NKxmvOr7q5NjGWVwXqEifaLD4occ7OfNzqVSjRCucRTghg++3hM0Ga11r5HR4qkWxnyVG1udnjj/9RDy+Yiz4cRBTwXtsCBRTMX5gfHxLv9koz76mhmNqU+FayesiLmyL+bQtR94aAdzT3BznKZNmxcf6vmsraq2gS5QMRlzYEb9VrOaFP1ovK3TUsMXTiflwxhpLP26asc7o/u+EvTIhSF6RwfReBwZjxOJNa2OSVuLriTSvSpoympqXIkmHdLqGai1xFbqqJsXsGnfR4eqg2u927D98YNjvr5uDC6/VtMz3HBcOv/zC6eMn1vNCPEvzm2OWhMAEhqFj++aB9//0R4b9HaCDW04Jax1u/4DpR0y/IR2eKMdnyXPad8banpIiNWpST5Ammlgw/UaNeCnNolfaVudWt7rVrW71W9Q3N6KHv/+VuN9rBWks1ndycFuDG7oGnK8ynjRHs7GhxXmqucxxZTmdOH164vTpE8tpappNcM6QU8YaQ7cZ6R/u2L59w/jQnKuXfPcLw7JkOYbXldJ0n6XkxiVtGd1ZkYG+63D9gOvUQH7lN2qtWEqS+SXHZqKo12YDZ6UpxIDvsMbhXBCHE65NsUFtQF4W4nxmenkWUqjmpkFsiVLW4Fs8ZrcVd9W0plgmpUYEaI1YjosazVUpTdJdemFmqtKD8ryS51kkAgSPzzFep1A4q585dISxF3Nyle7NONdY+jJjxdPM8vJKWeMVEO+7IAd9S7nEGLrtKLB9a5QxFoYNZl1IcabkopCDqACB0DA61ijStdQWYtDQUK4L18jPWitl1mSrtqYwpyjHuVEkqhqFgr2wTSnXmFVz+VzapE7xmzLAmNDhu83VdX5Ji2o0MXJcmZ9fOD8/sZ4OOCMwu+JLXaNCSP/aPTzQ7x81BS2a7JkWvVpbtvp6OrK8PlOWSc2Q9Zp2WquJYC7XGM4aFTPq2gQ5l/R1wmkMbhgxY4/vW/oYDY+UY0OPCWE0HQ6QC90ldhalT7neiGrgG5KpMXJth/SgWVsFTNGBcU2s5xbzCk2+URUg0VBnOWcITtsACilFTVXN188hjD2bxzds376T5KTFukqn6Zr3sBDPR46//Mz8/KQpaNGBh6pDhg+w3e/YvX/D3Yd3hHEDoQVLpCg5xTBihg3VWvLphbocm6yhfcIGHZpy1AFs2Mskts7gB+ljS6Za23LoE+l0/tZfk7e61a1udav/zvrmRtQ7YZcumrsKMlAE31Z6TlM4YzE5twmonPBpWTk/P3N6emJ+eaVMi5zqVHJrlqxzDPst490dm0fB8V3opQ8sRetUDBUZPUprQEEPURrex9hm+kgJZw2uG/T6QifTSYu+rG1yU9ZVjVGOcHGJ25YJHxMsGWPctYmxRrIAiVZre9ga4nxmPrwSTwfSugiqbWSSMtj2wA+E7ZZ+f0e32WptWU1DWzWGqbPNDFZaEzY3hOWlCW1w8yURp4n1cBI+p02zasl6eK6RiiVsBrr9iB87TQUvLExvmjwiUlIlF0M8nsjT1BoS01b+Ml7lXKW5G4Ia02aIIWnVLSORJeZKXGQ6q7XSDb2A67W0qWaDsPcdtu/pNhtpX5shqywrZV3Iab02xyXFayRqNYLjmxbtaa3HmMa5DJ1kHSnJcNWmoLo3O3wYFBfpfMOAmTaRA3IkThOnT584f/pEjVGGKe91ELEWUE662+wY339Pf0n+SYKkm6bdpEJeZpbjgXh8hSxTmrLuV6GJmkM+zQtxmsip4EPfpsuZFNdrs+e6gN+MQpwF3w4ITb5R0vXwlBYZkiimNccXpqtXLGwz6Rnvr027/gdLaY0zKVFqJU1LCwKgyU0MeV6vuknXdeScsMVpGmmq7tGmG9bBNBOGke37DzpQhtBkEl7yllIaGisyHY/ML1+Ir6+Yqu+AKV8PeK7v2L194O3vvmNzf4ftxFPFaUNiQos3DdIIkxe9jn5ocp+WyJYXHX6HXtsM2vS3adAVIyqdal4XZdq/vv4P/pq91a1udatb/dfqmxvRbr9rnlb9Xxu+wt6d72TswFyNF5VKXKT/PPz6keXlhZKUa42pSuJJGWsd48Md+3dv2D7cK8EoaFKiVkFNgJJjNLUscdHksJkzWryMJpXGYqiYvk03mpNeDz9NXpTElMirzCr8Y1xjlfWCWijzjOs6/LDR1NKA3Av64xWtVdfzkenpmfV8hFqaGaSlKDXIfrfd09/dE4ZRTMxSv2aYU6/a23qZjJYs7A6I+ek0kctrYn2VaznNCyUVTbiSDCMpCShu+45+v6PbjLjQWIwX3WkzmsTziTwvUI164dTSkIxr9AAlDGEMzjl8L8ORc/aqNc3LohXuGonzkeU0UVp+ufeaKmkyXBsyyOE3A36zwbjQppUIn7PM5GXWKrpJDmpujnNrpJOsLWhgGDShK+JNuob7KaXo87MO0wkJ5UK4UhFM10nzZxtH1UozOB9eOX38yPL8Ss0ZF3wzXVkuEZSm29DdPzI8vsePG72nBqU3Lca05Ew8KsAhrctXJqcx0n42o02eZ8q8kNeItZbQt9eHBr+liKPr+0A3dthhUAONaaghNXHUosSyRfeKG3tCRVnyRZsCGpPXtsOisGPSD5taqbWFEuSM63vCZovrz5w/fSKfz7rGGHKc8V3ADz25vRfbDpOltNW5uxx2CsP9I7v339FttpqylubGr3Lymwppnjl+/Mh8fBEUwntiXImLmMHWGWxwPH54z+Pvv6cbWixuGJoZrE3jXaC4IFxVPF8n5fWqszbCMFUwQ4PmtwnwtSEXrRVyJq2z6ADzdE1Zu9WtbnWrW/3b17fbQRvbs6QExrLZKrnFeJmTLg/jiiGuqyZLn5+YXw5Xs4R3rjU2lRACm0clBW3u9nSboaW4NKd9LVqFZiULlbT+QxyisuFpitLa9HbOu//t6jpnrS2b1q1maQxLjvrfSr1KTo1Rc2Uume/WEnb3iqP0XeNJ0t5vIU4n5uOB9XRoaU8ThsZedP6KiRruH+jv7vHDRqimKjNGNc1IpHcgwH7OrbERacDUep1YVQzL4cT63CbKRQB6LhPC1ODvfc+w39KPPbZlfSsTPl8xPSWtLIcT8XjAFNMaHPTzjKVaRTQ6awnbXi5qA5pIV6pzVxg+LpCWM+vpRFqlR3VWTXGOiVTBWovrZWYLm0FrcevaSlWOc1JUIlIzouSoJB1nDTklrVYNeO8IQ5uU59L0tA5babD4Js2wtGjOpgduDRhGhxrTwOXL6wunX39hef5CWlcK7Xp4p2lwLRhv6R/e0D++x292Vz2n0iAvTYxlPR1ZX550rzYO53ViZwyuKmlqeT2Ql6jr2/fXKNvrey8F0wX63SD6Q60NZ2Q1sSvSK9daiJfDSNfr34iNV+ot3nfCplmnMIdhaH/vYrbTNVMUKYS7e7r9g17yMGKHDfOnTyxfnsiruJulVpbDUSlclyjP1vDawZFzwvmO/YcPbJp5S6+5CIdWafetYz4cOP36C3memhJF8px1jawxYmtl3G3Yffee3Xff0XWS1Ziu0Q1ahr0JHevxRDy+4IKje3yLcZ1QViFQc6QsEyUl3O4R2w1wMSyBvu+0ex8dnNSEzrgWcXqrW93qVrf6beqbf8PGeaYsS5viGdZpIuz2Evs3HNA6Txx++pnTx0/UnEgpk9ao6M5m3PDjwHh/p1jQcVTzaOR8NhfdW4tqjPOJtK5Xs1Ebg2q92LAx4lV2TbPqIfRqLHPCVKGK8jJpJWq4Rn0CYM31AWsuRgzrW752g/Wbi16ThkXKzC9fmJ+/kOaz/t1SpIFsE0tq/Qrs3+6vk642TMa2B17NcouXEiURKG2FSKVW8M3Ush7PnD49UeYF5y4rRr23alBTMPRs3r0hbEekzqutMbZq5AyY4Imnifn5mTyvcve37PHL9Kw2bWUYOrrt0OQIBtoEWVnzVnGry8x6nqXhbIlS3kmrqylri2/dDPjN2IgHmg6SdBioKVMa3L0CKSfysgrq3vfSlLYUKRtkisoxUldNwi7a4FgrzluMM9h+VFRkQ/CoEbyYVbj+G8ePHzn9/DNpmq+yRWOMsFpIf+t3O7bffU/38FbxtetKTWtjuQZoKVHnp4+snz9hasGNSiu6TCHJGXIhzYuauGXVhNkHwMocVRK5IPbt2NNt+yZ/UCNrm+PdXBiy6yoKA+C3W6x1pPNZ18UZ7BCUtJstrkWcGrGL2q67ERIWHSz7x3d0d/dXtBFExvsH+mHg0HVMXz6zvryynM/YEK6HqlJp8HtLLYkwjtz/4Y9sHh6FYKu5SbH13TbIQPj66985ffpEe9P67FchvHLKBO/od3sefvcDw/4O23fgnRpMuOqSTfAsr89MP/0IpRKtIeXM8PBWRIEYKecTBYu/e9dSxKS3rpdgiJSbBKGwHl5ZjkdK+70jPa391/xuvdWtbnWrW31DfXvW/Glquk/pI9fXF/x2x7C/Ix5eOX/6yPnLZ+J5Er/Q65d3NwSstdgusH3zyPjmDX4YcE1zJzuymkDFf4oNmdaVmooeqhiZneHayFgnaYD14R+mslWmg6J1tpzmR0rJbbLRQdscrvOJ5ekVYyyb94/NuNGr2TC0CUkzOPhAwbI8f+b8+VfSrLQWrMV7D7WQU4Fk6Pd7Nm8flWPugx76mDbxqW1qXCglSnjQGq/LpNl4c4Wpr2ti+vSZ9fmgZsxetHylrfYLJjiGD+8Y7/eE0FaTVY2UsDojNReW85nl0xN1llPdNVQOgLcecianBTeO9Hd7TeKMvbrHa1owPuD7kTRPLC+v4oEarfLNBR+EJBfeO7qho7/b4Yam5zMWkwp5mZu5RRKOirzeZRWiqAJh3LTPwOMGxV6aChWr5sdId1uzpscVQ7Ge4eGR0A9q9o0EsdVIf2qKhZo5Pz3x5c9/Jk1nnHO4IAOP9R5rNdWzITA8vGPz7jvcdqf7oBnHsP66Jk/nmenTT+R5asatFk1qje7xVeSB6eXAfJgwpdD1Iy4EclobCUD0BxPCVU5hzOVeoclBaktVcsTzrHvXWkyvqW3Jul/t0ImyUDLeeUIv7TBxIU/SsrrttnFwI257R//mHb4fW9NbwBTxUyuK8/3wgen5C+fzSTKCoWsNpaQe1hqsMWzevOHuT/+OsNletavKmqV9zx05ZZ7/8mdOnz6KDIAjLisprpynFVOgHwL3H95x97sfCOOo692JJysSROOF1sr65TPx6ZO0006HxhIj06dfsN7jrZVyZ3ePaYc/vIN1hbxS80WeIPTb+voquYlFSW1tEn2rW93qVrf6berbd06lNp2enKQlF17/9jcOzpGOB03MGjieC3DbyZW7efOG3YcP9ONG/0bj82FoOfWaPsXTM2k6yyhziV8slVIcfpRD2zi51m1D/Cg+/KLzspgCldz0j20dF7ymM3GixgrWk04TLnSM79/jg9eEx3fCRtWLblSaw+nTr0xfPhGPRz3YKFeNaslqQvthYPf2Pf39g1aHzWgiQnjLRc8NaRTaa1+WlmzkcZf1fymUVFkPX1hfTiwnpTmFocM5S4qrBrXBM9zd09/t2+QvtxWnwXSBMi24cMc6r0xPB+Lrq8D2rk2drQwgpU1WvfN0D+JSWq8mRFrUE8ZW/GYLLUUnnk4CxrcpHUbRo7WRCHzn6bcD/X6nJC7bwP5pJZ9naloobepbu466Np2lDXSjhdDMREmmMkzGGMVnmqKsepnKmrTBQLi7o394IPg2BUWRrXReca3ekaeJL3/+My9//TumZEz7HHwXCH2glkJeF/zujt3v/0i3u8eEXp/lqsAAxdHq3lyePrM+fYZm0ilrVEKQly645JUcI/NxIq9qDF3fYzGkmDDGEnpPjJEw9vT3O5zX66jVXuK2oMVcljXpZx7PauKs1tNlXdsfbLecpRnKuiY4TS3hC8Hyp0kw+N//ieHhLXU5yZBkrEIajMw6VFiOBz7/r/8v4uuRcbPRpa1KURKKyuG7wO7777n73R+k+S2pSQAuKwCLcZ7peOTLn/8L6XT8qh9eI2laOB5PVOcZNhvufveeu999r+bYB0w3cjEQ1ZIxTszc+cvPxNcvELOIFl0HnYgKeV1ZXg/YENg83uFK1K874yGt1CgjFkUHp+Wo9LFS0aagFOqSG4Is/+t+u97qVre61a3+m/XNjWippQGzIUY5mct0usLL224L2zWAd4HN4wP73/2gqErQw02/6RuU3pJOJ6UypQueSavImpLmXM5hO6/Epr5v4PjKlQEa1IDW5ghPxyfyfMYEj+8DtdPULF0e1sZS5pV+t8dvNkLitFU25qsJp8bI/PSF06efidMJqtGqr0CNVa50mwnbHfff/8Dm/uEK2sc0ZqW6ZEAO3HJJkoqpmUXAxPI1QjInJRgdj5hUMAWgSNpoapt20qbLWv1b58irnNh+HMF50vEI1XD+8sT5yxcwDmstOWZSTLiho99tpMc7L3Tbgf7hTjrDKgNWej0oH3y7we/3lLgyfX4WgLxNeTHts65iLtrW0HXbETuOmgJbo4d6Ep3AUEipkA2E/VapRG3FiqmY6pumV025cVVK4AIZoGQ57q3T6r/v6B8fCEMv7WZOX9FBzmNa3vz502c+//M/Mz8904UARXrZ8W4LrpLmFWMMmx/+wPb7P+paUNSwYGSsagzSvEbOv/xIPr3KJFV0kEopXlOLaimczzPzywEfvDijQfGqaY0YqylsBbrdhrDbaBWPkYayIlNSi4ctq7BS8Tzh+x439IAOYNZ6KpUyR4w3dNutjGYxfnXyW4PznZrDbmT3+39PGDvqPIHXv1UvIP4KpMTxl595/fGvkNv3OiasgZz02fhg8cPA/R//HdsP3ysXfv6KZNO/ZajWcfryxOc//xfqMuM7j7GGskbympmnhRB0Tz78/nvufvhe17Xxh0nr9R4zLlAqnH/5kfTyRZ+zqRiriXF+naVDrxXf92zevbumlJWcMbVikmJMayMPzE+fG+XCNN0rOpCWSo0Lfrf57/29eqtb3epWt/rG+uZGNK1aRee4EpdZ2r62LjZGDmvfeVzfEcYNu/fvGqS9uXYrDeWnjiLHKIPLPH/9IZd4P2OwvdzOLihO8oJg0gMzgg0t811NY4kH0jRRS8aOLeM8Nc7mMmmV3w1gLeF+oynZtWFRcpEmT4bl+QunX34inU6AcugFDzfEdaEsK77v2H34wObNmxYf2ZpxY7han430cHk5q6nyajQuYtFqXNuGJpbTyvz0TDqfuEy3LIYueK3yk1a3m3d3DLvtNZUmpjMmBNzQy5BVK9kEpsMX8unUsD2QokgBzinve11mfAjsvn+roW3XY4xRUMHxhHGOsL8DZ4mnM/H5WU1Fbe7ny1zYSiPog6Pfi42KE/KJnKhxaajVSi2VdV60/bWOOEX6sWs6T5le9F8yi/mhF2MzZa3PDRD6Fp5gsGEQiaDvpTVs11uYoqBoyenE688/c/jbj9SU1YTWShg6+v0G4w3r6YTf7Nj+8HuGx/cY69WUtcOXMUbenpyJxyPzp1+pMcrEUhrAvZSW1CXz2fn5hTjNhDAQutY4x5W4JnwIlFLItdDfbwnDqIY+lWvmfE2NDVoyeZqIJ91D3WbE9Z0CGGghDeNAniZMn/UaEIZJ2fNFTb2cVYT7RzY//EFA/rhQQwdxbe5z4ZLSsvL644+cPv4M6bKVqG1Ca7DB4kLHcHfP3Q9/oH/zvk34T+Jz2osz31GK4fWXX3j+618wccF7izWmxblKkzvuR7CWuw8fuPvuw5WAIDeYUtOohRoGUorMn34lvTxBunzWnpqBmqg5kpaV8e1bNm/e6p+4pldlTEvwwjtYVuaXz9okYK+GzLSu+K5vLGF/xcTd6la3utWt/u3rmxvRdRWCJ6cqDBPgrKZXeCNo9cM9/f09492dOIUNR4RVgkyNC/F40DTRoDX+dXQCYKAlIPnmVr241i8mHmpRkkw1lGUlLZPGZc6Qi9BJ5MLzaeY///KZPC/su8B3797wGAJj44rKqSGdojFWQO3TkenLJ5anL9J8/oNzveREnBZcCOy+/47d27eEcasHvKlXzWCtbRVaZbIpWYBv2xBKtMlOLZBTJs4L85dn1tdjS+ZpislSSagJ8t1Avx3o9nu6saPERF7VqNh+UIJNKZRsOH35yPz5CefMVy1fFn7H9EN7rY5+u2Gz32N8IOdEnM+UeYE1YruA6QdqiuTzQoqZahx5bQzG1kxbq8l2t9sQxkGg+Qv14MJGNZZas+Im50XZ7k50ghozczwrTakWNbUX8kDosLVSrIVO2uBSzHVVHfb3dONWU2hrW6JVxdpwzbifPn/h9cefmF5fJEfWsQXfB7CwnE5YZxnffWD74XvcKC1oWSc1L64TdcFATonl4y+kppNkGJvjfxWRwMmNn9aF9XSmzJHgOrpBCVyKroRSEikbQt/RP9zhNgM1NhRT0zeWGCGJCJBOZ2qMuLHHe09pkZgy0Tj93JxwtUpGEDymZKoVU7ZmHRgJgeH99wzv3kumklbq2kgUOTcJBMzHA0//8hfOnz6381RtGlBaTK50qOObd+x/+ANhs6HWBGuLGQ0BXAAcKS68/vh3jj//iG/OfWmi41c2qzF0w8D23Vv2Hz5c//6FnnGJ7sVY4vHA+vRZ18d4vdd279dcMUa4p+333zHe3UOKUGzDdRUxetvvjryemT9/JJ2nxh7WZ5di1J8zFT925FqlGb3VrW51q1v9JvXtq/mUaJwavPNKwWkZ39u3b9jc3xE2m9Y0wgWyTb3oHpNy4OdJfm6nLPZLHyrtp8X6IJdvi2iENh+8uMWrXkua5ytw2wSnWMJSKW0N/WVJ/F//8/+Tv9RKv9vyp5T5n1Pl382R/9AN/OntI286z+At5Xxi/vKJ9fBMyZlSjWIhq6ZspSSMdWzfvmV8lBHJmLYatq3ZSoqelH6wUkvUv9Hy0oHrxLdUSNPC+fMXGbPmBecakL4xGStaLXa7LcN+ix96rVuL1vtu7AGtPSmZ5fXI8vxKXiOhoYpyLI0sJKSR7RzDdiQ0VFY1lppWYYtiaj8XbAEzzYAoB/SFNDml21hxIHPJxKQkqmAtxoXr5LONoai1kGMizis5rlrfW3cFzZMSNRVyjHSb4eoOF3MztYmrKAo5aaLs+p7h/g7fD1q9G9Myw6XfrDWzvLxw/PvfOfz8k3SxLYbVeFERFGhg6e/27L77geHxTTuYZGqMV2MNVTzX9XxmffksHFDXf81h5zLBR9djWojnE8Y4/DBijZOpJjd3tnOEcZQrfjNih1FNYkN9abIqkkCeV9Is7qUbBbK/pIEZJ7SUsWj9nmkNafmKVEpZ+tFa8Jsd/fsf6O4e1PDnAsuEyaVF24pScfz8mc9//gvL8UgXxAR1Ti70mDLBGPxmw+53f2D3Xqt4ctT1KNItY0WtWI9HXv7+V6Yvn3He4ruOtKwsUxTey+g409/fc//7Hxh2ewUbWCvJBwZB77U5WF6fWb981BGoGhmXGs6qUKm2Evqe4f5BEbIpgQ9YH2Qwo1KtGKxxmpifPlOXWdfSh9YcFwUKGEPtPLlRFvyFtnCrW93qVrf6N69vbkQvqTylKFax228YHx4YHx7pNhsuedOGpm+rhbIuwvIUTcRqybhhaBB5Gi5JD7yLY9mF8BXcfeEdtUSdmiN5mWVoyjKbGGO0OjMW493V0DQ6T18N55x5iZHDNPGXwyvn/8/f2K2R/+lPv+P/8OXMH4eO795u+MHCozVYXGugxScNQ0+/2dDv7vDDpjloW2dZpTsj1WvePVapNTTHvOD40lHWVInTmfnllXg4Nh2g3O01J0rMSqsaevxmZNhtCH2PDe3fNAbotWrNmRIT8TyTTifyNGNAD2FjyG2VWr3F9oFho+mctV4r9lKIhyO5NUnWOoqxlLRgKvp5Tp+F92ArmLqhxEg6T8SlGY6wnL+8UlOh3/QY3zdU0UyOC3FeSS26VeSCADSWKoqzdJ1XAMCFcVWbFjBHUlwBRxgGut2Wbtx8RWtV1NA6RXCmZeb8y8+8/vgT+XjUFNi3qTDShhir67358B373/1BusmLEQarJCY0TYwxkl6fSOeD9InGaxpX23SNQjWFdVpYJ63ynZOMw3UygpWam47TEsYeF4QpEz6oXkFbOmRlaU3nRZxS53G91sO1VGxQA3ox2ZAzIswKmq+FQdbauxSs93QPjwxv30mWktdrSMDF+EOprOvK848/cfjpZ9bzLIlG0qHPNRh82PZs7h/Y/+GPjO++k178kkhkPDjA6XWeP33k9PMvrOcT3iudigpxSTJreUkzdm/fs//uO/wgd7qxTk1jTi3owJKxTB9/IZ2edFgrTdZSkU49amIdhp7x7g7XkE10nSbaehMtZrgSDweWl9fr522a+x6je17yCIff7KBTQ1um20T0Vre61a1+q/rmRtSghJP+bsP4+CAO6GaLdb41nw1CjyaWOS7iGtbG+6tcTU2KGQxYZzStci2ezzR3eVsTXoH166zIx9ymjkbGmFqrpk0hyHWOaWlGHf1Y6Z3DxIgpYErFGYPZbzgZ+H+UyP/t//6fGSv86f/yf+J/effI/9FY/rhGvk+FfT8QNiP9bkcYNpgQ5BQ2Wu9eogBrkS5N+fRBjQJIspDVbFUDcVqZn1+Jh2fS+dxMFi09qk2PXd/TP9zT3d+JFxpl0sjrSk0t+71UcoW4LKTjJK1icLguqEkCgfmrUmrcZsD3Xg9x0IN1betf2x7EGco6a8XbBVzfaV2Za2PHlvaeEst0oixRzaLRIaKWzHI8Uil0xpLnRZD/dQGU8e5DwBoxXI3VQ9+ANIMOTedaQ6CpWMUaRxhG3DDSX7igxl5Xupc/m2Nk/vKF4y+/sDw/g0H4qVIaPL1yWcw7Z7Gdw9pKjlGNcbvXLoNrpU4diYcXqKvMR6loMu6DkpGiGsb1PJGWiMXgOwHkc0okoymasxYbPGE7aI2dM7XIZHSZ6AFKZDqdWU+zNIre0+02mvZn/RkTNDWusQUyWIO9RK1iMNVQUqGUitvuGR4f6XZijNa4NtmIrrOpkJeF+TSpCf31o7BeQZG6pWR9t4Dhcc/m/Tu2bz/Q7e+A8g/BC7TkK0ecZk6ffuH8yy9QCi6YdtVhPk2UkujbgWL7/j3j/ZsG/W/yihTVYLeJeZpnpo8/kw8v1w0K3mKdpawK1zDW0O939Ps7XNcrnnfsmlSDK/IqpZV0PpHOZy44gmtIQK76/K3F9DKPdfs7qnNKTmtyiFvd6la3utW/fX1zI7p595bx/o5uu8OPG2zoheWpSi/StDSRpjNpUT66aQijmjPVoKnnJevad2JZVr4mKpmLe71pHi+JSlWJQ5W2gjVaf8dpxlhL1w/40BKQUApNVwtDH6C5eGsR4F0rbejGgfX9A1NK/DgMvBj4z9bwfuj40xz5X6zl/3x3z91mowbKQGm4oFKaYerSgFunnHvaepemfy2FZV5YXl9ZD2fSsmJqlia1KCfcNLRNf7+jv7sj9OGrCcbrmsTXgyaXzhHXSMpC9piqHPLL7Ng6J35lm6L6vtdks02/aozkeVFz0CnrPM+T4hoxmn4ZR83t/V1g8fNMiUIRGdTk5TXrPZAJ7VCR54VYaBxTK+OM93gvM1eOmmL7sZMhpZYWOlDU7FZdWypYbwnjhrAZG4z9H+JAG6qLWpmenjj89BPT5y9KKwpOKKY2hcYJKm+cxTmLb1nteZqZf/47af/A8OaDdJMG4nQmvj5RGs+Uy/raOLB6z3lZWc9nUsyUVHBOmuZaIeeItUZKEmvxm4Fut2kud6TrtearFKAU4rKwPh+Ip1MjKzh9blZmI9Na5DQvWAqkBstvQHzxVZVkVaulf/+B4e17ESHySl1mpVddkGLWEueZlx9/4vDrF9bzucHnzddJMxbnLf3DAw//4d8x3D1ck7A0wVfCk/EBfMf0/2Xvz2Nlbdf0Puj3jO/7VtWa9vTN5/vOOd0eut22O3bbxBkAo8SJACUOJNgRRJGIEASFgAhSUP4JEUgIIhGQMCL5AyVCSCS2hEJAKCSAQchEQEJI7Ha7fcZv3NMaq+odnok/7rtqn0M78e4+5/TpdtdjfTrtPay9VlWtVfdz3df1u25vefjsU9LuHufF611ywSIbC7GaRFZXl2yePiWeX2r1rqrbeumyIdCMY9lvmV+/pO53GOuVnhH18mSoreFsJPTSnuX7Xr4PUe+pc5icwMC43XL7/U9peaG/uCCGQE0ZE6N4rRcpd/Crjni2wccgl2XjcMMKr5fL0zmd0zmd0/nxn7ceRK8+/gTXiU8R82ZobEaGljyPpHGiHFQ5J0MjVZDl0tnei/ppLNaIClLmERcPaXP1FU4zdR5VTdW2H01aQzmGdYwxhGElXfBBwlEAphR8a5z3Pe32Tp0CEtLxXSBNM4ZG+PAZjUbX92As962xdZZvGfjXn3/Fz5SFv+3pU/7IasPP+IivhVSbQsjFT2YOYPicpR7SAMaSU2H/6jXT7S01JakgtQ4QKL0xErTwm0h/viGs1ppyzoJo6jqs8eJ1s4ZlnLVa3KhfF63rlBUqzmFjwHdR3kid8lBLFt/rskiVo3U078TeME2yrjb2qDiJyiwhqZJE8UvzfFQLjbXHIa+2irPSyW6twenz2mhUZ3Bx0JpMtXT0ku63ThVya2hViw2slfmnCd809oOm0J2sVrV6FedkkFwWdi+es/3qOWncQ2l4b2X17SQIBcI0taqiWe91xS4qY9PGqckawuaKukzk/T01LZomK3L5MR5jFV02TdR5oeaKqZUQZUgpRVqxXAg473CdJ15sFAMFYGQY1lYsSbM3pocH8naUgagWrDPE1YAfon5LNFU5ZbPQrIVmsF564wVeX6lIYG54933C+ZVWWypjVNXLQ0BovH/g+tvfZby5o7SqrWfQml5InMMFz9m773DxtY/p1ivZVhRR/6lGw1yBimH/6gUPn36f5e4eH+WiWVI9rvcBaZwKkXj5mLA+F+uKdbJGX2ZRaWOUCtG716SHB/K4l0uEFz+sdVZCjsovjWdn4t9sVRR877QVqgnL1MDu9Q2v/up3GG/vcM4yb0fi2Rn90OERVdgg1oP+8lIRWvpzyzatjz0poqdzOqdzOj+p89aDqB/WAryuWUIEBsoykXdb7XBXjE1rx62pcRYTnWKYIvaA9QFMiGLx6wTdclhBp/1W1s1eBxP1hJkg3dFl3GOMIa5lALX9SvAttcpqD2Rl6SyDgscPg5O1hn41UOZELZX47BE+BIZ+oNlKSknWoF3gdSu8fLjlr7jKv7q74/fZyN//6CnfyIlgDFXVGVp+47fzgVJh//Ily8MOUsE1CWKhnjaDwfqIHzr6sw4/SD0pTViRxqCtVI2SCtP9PfP9FnR92FqjGUsI/jgUYgy+j/ihxwdPTRlSlnaprOxR78EHlmki3W4xpWqA58BlffNfbZU8jaRpIs9aD+qMDHCHj+csw1rYlxa5VJiDot0KrutwIQg5IGd8F/AxgIaFDuvyQxf7AYbfrQcZVn1UJVCwQxweRxeZ7u+5/e53mG6upVt8iJgmCW+QmdUFB7bhgsN0naynG0ebAbXK5+4seXdPmfbyGrXyOZWkHsxgaDVLycC4J41JUulVlG2hKgjpobZG6Fa4IeCHXgJFGt4SxmxF42PkeWTZjeR5IackpIghyIAZRRUvOVHScmwPM0WqSu0q4qzRgJwGktZnDO9+gF+fycUrzbR5kmG6VBkeKzy8eMGr732fPE4SenOihFrl2oIMwucffcjZBx8KNk1uQKBqvlwGPCUlbj/7jP2rFzCr4toqeSmU0qS6VNvYjHM465hevYTaWL33ISYtkGZhzbpIKYnx1UvSwwPGoIFFix8irRVsiMLMrUU4wN2gKq+0cxlrqXnB6sVs9/qaF7/yLdJ2hzOWWmB5mJh3M9MQWV1eEIOjOxMbg/XueJltxmCcp83zcZg+ndM5ndM5nR//eftmJe9FvdDE9Ly7p2wfsEaRLfomL7WSTpA8TgZQY7RX0xhhFvYCXjdWlJU8bqUJScHs1jn1bUlXufGeUjN5uyP0PeHiAhMO3tIoik8RlbBZw+7mlpff/4x6d3dcax7+p+t7ln6kpMr64hznHV3fk2tiyQIQdwFWl+dsl5HbaWQGvl1G/sIy8ccfPeWPWcsvUhmwFA3ElJrZv7xh9+I5LWec7wjeg/PqmV2wpuHPNgxPHhM6B7WKb7Ya6rJQlgnXRwyVZbtnf30rkHKUkdkKJnjhUjonKmPwhCFqY5LF2CCDU0qK1nL4YaCkxPywJe+1r14flHbwH1pLqzKALuOOkrOsaiuCr8oVaxrGWemO904wS84DVuwXOqiEfgBvyaUo+Dzgg/w5EAWWWiRkprYJFzviqpd1s/dy6UH//SrIrtzg4fvf5+HTz1j2ew06BUlO50qeM74P+GPoRFiWBu05L+lIbIhnKwhOamSNILxazhyD/14wQi0vLLs9y248EqkOk4n15uhDtN7jVwNu6GRzYKx8uU68seKnlHrX6f6OPC+UKZPTQghBrSUWGyWol5aZNM2ElYTPaq44A167z6sSBwiR7slT+idPpXGo6EVRiQa0Kq/PtHD3/HNuP/+cZT+qig0Ni3WOEBzWgO8Hzj/5mM2774o3FuGLohW0B3U67ffcffYF0+0tpCKfC1DVKlD0Uuq8pNKj8l8phf2XX7A8bFm9+w79agVWVvHj6xeU/QhFVv5CB5Dvf3KjJPFKxy7iD+5TJ3YNg6Ht93Kx8Z67Tz/j1be/R12ShtsqrjRhGRvLvJ1Zxpc8/V2fsHr3HbFAmDfPrbFWlHGaPienczqnczqn85M4b/8Ttsw0LMt+x3z9ipwSfjUcsTIyhFp8F3BaWWmCKH2mgfFRPXsywGCNQO1vXlOmvQKwwbTDG7g9rslMbbjqCE/eUa6oPb4BtTyDZof3r19z/dmnLPdbqoXuANM/rOwNOB2eWsvEGBiGNUMXGRftzXaB/W7Hfpxo3jKnylL3xBB5sUz8uVdf8X/u1/zBkvlTmzN+b7dif/3A9vU1+eFB/LLWUWqmZVm11lKwMTA8umB4dCHqk+KNDjgeUzI2yHpxurtnurmjpkKrmjYPsgJ3nazdc8r4viesZfXrfCcr8TxLmtnIet/4wHS/Je1HScMfaAXOi0psJDyWS2a6uyNNowayOALr85KoDYbNijBErDFYrJAUkIGa2iQk5QR0X3MW60HojhYNbIEidgtjDSUJZWB4fKm0BKeCqjR3ydAoifrt9Wtef/s7tGmm1EbsO8IQMc6Qs9TLuqHHekOZpHDA+gghyAuwSWjFhoANnayyUxEfpXJHS5Z1vvUeEz1lGplu71h2sz4PMhgdrBmtikrcjIPo8Gvtaz+o/jbKYF0lBV6mienuljxJg5HxjmA7DBXTe1VtK3leaKbio6fOGd85QWuFSHPScFRSwa7WrD76hHguzWUtLZC1IMKIUk4/sEwzr//qt9i9ekVJGR8D3sv3T8mZEOVxt8OKy298g9XjxzqUFQHat3r8mjCW/etX3H7vO6TdeLQPGGNwnZAdcpItge86QhcJqo5TK3lOsv3YPXD/7S35/Y/wQ8/84gtqyaJKarAOa1QNRYKCDfrzS/GMO8GISbjJyPedkefjxa9+m1ff+g7OCvLNmKqhuh9Q/p3l8Tc+5Or9D2Tb0A42AkFLtXmR75FSWXbb38CP1tM5ndM5ndN5m/PWg+j08gXLbkedJzASQGm50Jz0Mhsn/jiLw8VB1pD7vaxsV2egWCZrzhWU/sB8+5o8LRJcQdabDWlxsSGIF87IQGpUiTmoqK01Wiq0CuP9Ldff/jb769dY5/BdxEXHeR+x94eAUaUe1tE0nA8Mw4qz9QrvHCkvAjkfR26+9wVjngnPriB0wtmsleBlwPximvgejb+wveVPLI2/c1d413faQSkJ5gbklLDNMpxvGB5dELpIy4lqLT522FUvoPZloVEptTF/dQ1JBp1cCt5H3EoRTt7TkDBUt9nIP5WFIJD2E2WZwVSscbjYkVMhbW+pueCME8+tl4BI1kS0C540joy7LcskrE9joVkopdBywwVP3w8EbzHN4b300YuimTVs5kVNzBU7OBl0ipFWTLULS1G5qk21Ec+v6DZnggJyViH4WVU8eR3llHj57W9x/9n3ccorDdG9UWJrwVqHXx88lU58ocoXbSVRF1lv2yDr/pYX8bb2vQTAdqN4kJ2T11fN5P2e5X5LXoq+3i2hD+ScKFnCedZa3BAJ52sJI+UKpdFawa97uSypUp92I/PdtXhrc8EPHS5CnRdM7LBRBqU8J7AVW5vYImwjTZNUuU575vsdvu8Znjxm9e4HhM1G2aMJyiLDZylS+9l37F6+5MUv/zLLwwOlVKEGGPGEeidhqlage/SIR9/8JnFYSYhOLSBSRoHeYCzbLz/l+jvfJY+LKOvWgLe46GhW/M8uBEIn7Wah644M3DxOetkT1Fqrld0X3xO6gwETOxlm9fvHeUm015SwIdKtzyQc2dwbz7DSCdBB88u/+Je4+d5ndF0nYnoBjPhxm1YDu+B492c+4eK9dzFqCTkg53BeB1Wn4csHsbqczumczumczk/kvH2z0s2NoFFCpxBxRNUssnp1IRKGtSa+My1JylvWvwlTg9TvTbfUcQdUYTi6rJ5OtKHGEbpeV4e6lhPWkSisxtHSTE0L827H/fOX7F+9Ii8T64sNGGWLGlh5p2loVUYPsG9jSIusYYMqq9FHasnsPv+K8XtfsPSeTOXy4w9JJjAvM0V9gaVV0rJwXyt/eV74N+5m/tF4xh8+X8sckAvGNWmbenzBcL6RL6FWyAWa1Fb6jVHv4cR8vyfvJ1qWhLHBEIeV+Ba9Jy0JUqJbdYSuU2HH0Ewj7bbSlY7FdhGcZXzYyxBkDM57ai7H0FYrC8ZYUk5M2y15mVExCB0ZybOosaHr6TY9zhpC7An9QC2ZkvNRzaVJRacJRhqWvFSm/iA9oDZJehvr8KGj22xwsZfwm/p7D1xKG3uqcdw/f8nt974DObHanIt/V2tdqZmSGy4IcsjScN1KesXVx1oP6pf1VOOxigWzPsrgaCzL/T3gJOxmDW2ZWbY7lu2O2qA0i4ueGANVPcjey9A9PLri7P33MTGQp5m83WK8xa8HGb6z4KsahmW3pS0yCPrNhloEP+SGDqwR5mguIqg2afpqzhyeFEpaKKUQuoH+2VM2H30iSK6URA3UhDga7irG8/D5p9z+1W9Jn3yVkFRT5FboI25w5GK4eP8jLt59Jqv4Kk1g1CKvH+chdjQM288+4+7TT2kUXO/lR4D3cmmslaoFDs6BrZUwrOTy1BplmiVxb5xYPYpcNrq+py3C/ZQ2NqsXIblslpyJZ5eE1VoA9L7Tz004qyhtI417vvqVX+X2iy/pYlQzBjTTyLnIy8A2wjDw7JvfYHN1Ka8TrSI1h8vtPEGMgra6fq1Noyeg/emczumczk/qvP1q/gCbbg0TAiY4bBBlLAwDPvbyxtCaJLF90JFGUu95v6WOezBVf+ibox80pwTF4FYrwmajvj5hgkrDzZuP05aR5eGe++fPeXj5GtMqXR/ohjNcCJTUKCWTSyY0ZBC1MozqaIS1Rnq/c6Y0cJoUzsvMw90dJWVMDCyv7tm1L1h9+C7EnnmemNNMaRVTCiwZxol///aOf2Z+yT/xznv87Y+fCFz76pxu1eEU1m2dgMGpDZSveWCL5mnGqBcSNETjHdY4Ko1SM2EIxL6XS0ATrA85UXUF64LwLXOayQ8L7rAitvJfM5CrtAGZ2pinLWmZNTUvj41RZSjnBsYRe4HNOxcIwQubU7u7rZHhNk0Lvu+IZyusMxrkqTqgat2p0aaqGAVR1UsBgkDZtbvegukGjPHM88yrb32L6eVzuhhEMbdWFXNDrVU49iEcYfEuOmwQlb4sSQfwwKFVylijqKwAPsg/fX8jg1kQ5TIv0lAlrEkDPuCNwXsLVryCpljiekX36Irh6tERMO+Up2usYIuaYrJ8v8IPA9Z6lu2OMk3UvIiXOvTibCgCsjdVPIw/GO6pJVOmRV4X/cDmo4/l39XHVY68sskFciZXuPv0V9l+9pl4SWvGGAgaghLFGJqLPP7mN1g/eUdQUjrMNuXa2tgJSunhnu3zr0gP9wqVr7J10BaikgXPFoKnNSPsVCuXA1rVgFs7IrdqA79e4bvuiICyQVuVqqzgW0pgvTQlddJmZb2ycJ2G3vT7edrueP7Lv8Lu9SuiD8cK2ZrTsSfeAP3ZGc9+9mdYnW/kNXf4HQMNCdCZEKW5bZ7w67WijE9ppdM5ndM5nZ/U+XV4RLMMD9rU47oBHzpp5XH+uC5XxhCtNlmHp0Wh0hbbD1CT1Dc2MK3huh4T5Qd93JwpG1FxMlSMBgzqIvWJ4/0921evme63UBuhF89kwzLtF2oRb9360RVPuh734gaQAVA4mEYGvFJIOQsuyDlqEx9Zio4yREH7dIHdp8+ZlsTZR89wyIq/LAmWBbYjPOwJ+4UxZf7Nu1v+oz/3u3j86EqwTgorF86jeA+pMigv9zvme+E3mgOf0RhJWhtJilcritPqfI2LsmpstVKmSYJdCMKp1UbOmZRmbEWtDohvsxlRWYvwCvKyUKeJWgumibJtrZGUcxIagvceF+MbPisSLKrqyWtVnufWKqHr6NZrjJNV6bElKBfxiTaD1XKAsFrjgtIGEI4mtWJ9pHlPXhZ2z59z9/lnlN2eGMRLbLxTsLsMD76X4dQ7xU7pWr9MUlXaahUl3VpsDNK2hQTZ8KL25ft7CWpFQ5oEn5TGmbKIl9QHqbGVZ04QSiZ44sU5w7Mn+NVaXqconB5LXK3JKVFnAeXHXpR9UytRWZfj3S3TTXrjbzRQUqKUw1AuITPnPKUhSrczDI8fcf7hxwKUT8I4NYfHusjjmKeZeffA/sUL5vt7ITE08aK+adVC2K4Xl1x+/WP6s3N5To0VkoW2dhkvFIDp7jU33/42bZ5kIEReX87J41pKUStNFEsFTS5Jar8wtojdAURB954QvRQJWANBiAdGiweqadoMVegu1jgnIcnD8ykBP/TjZ8a7e15/+7vMt3d4F451nE1rU30MGAzdZsOjjz5gdb4BNJgUvCivKcmFLARqyYIDM+jPsx/wx57O6ZzO6ZzOj/289SBaasVtNnRnZ4q5keQzCmQHdCUqqKSSiyTkrbwRGutFHVEIuHEON6wxXYd3AsY3TobQwyqenEXdnCam2xseXr6kzDNlzvJ3OsE0pUVA3jYG1o/WrM/PCOsVF18+J6rC1MaZsh3hsYLfW6PUSq6ZznictcTQYaIoi/ara6x35Edr8s09d01CHi1lWBLsZ+z9Hr9kLrrAH333KX/6F36OJ+8+w5RMyYt44SrUaRL+4+ykPWc7SpDJOgG6owlvY0XlChbXBXzfE4de3ozlSdBhq6hIbMhHbFYl+CjevoaqkE065EvVJP2sSWCwVnyPrTUZgozDB4ePsi51asFoNQMG56MQpIrUQroQiKuoPFjFNlkduptcQoxxuPWaeH4hK3Nlxer+WZLpoaOVynT9mocvP2f/8gXWQOyEKWmiDKGtNVopuC4Qhh4f9WutMiSWRawJIMO89R7bRQlQHdRXDG1OtHkSX2UM1FyZ7reUeRE1z3nxLDqHGEdlCPFDf2y98n2vCp/gpdpBnW5iLYnDShVtUfGNtcKjtIbV5RXGB8bra8q0xxQUzdWkLaxYak7kZSEtFdt3nH/0IecffISLA7UkIUXUokl2pKZznLj/4nP2L14ckWe1NXz0RyxTA/zQcfbe+6zfeU8QVyWDO9SgcixnyNPI/tVzdi+fU6YJZ4wA9a16tq14YVurWP+mYtS0Kj8brFVrgQzyGLCxI6xXyjU1WlKglxujRRGliAqcEu3mllYqYXOGj72olrnqxSCzff2a208/p44jYdWx7CVU5xUJ5p3DRM9wccH5s6fE1SCvZ8PxtWL0stisNDkt2wcJTTkrLGRViE/ndE7ndE7nJ3PePqw0LoS+sTm/0iFUVqrm6L8UcHor+ahaGAW+UystJ/kPgxtWuK7Hxl4CAoduaV3tt5Jk7bvbknZ7yrJIw5LwZGQFbK2unC02CBNwuDjDO+UAtkpvoD/UBy6LvHHTFG4uysm8LPQxgIXN+oxgHPM041/cw7RQ/bvQeczne4GW54Krsgz1xvB4CPzS+Tl//3vv8osXGwmMWCvMzFIl9FMraTeSFwmBmKod4zmDF5anUayQjR7feVHTYtQu7CpJ6WUWTI6VTu+axF9rjFG1Sz2wUvFDTYW0yOAKyoKssqq3QRptBHPk8c7ijJVu8BAkWQ86mLij19QYgfbbKIlwc1DBkaGwzAlqxg1rwtmFrKUV14TzcGhIqgsNSLsd+y+/YP/yOXmaBPfjnKi1BkH+KK+zW6+w0WOt1crNQ2WlhsS9DA8mSFjqCOmvIg1KcEmwRtVa0riQ95OUI1iPU5QRutY11uL6SDzTYXrolaXbNCvTjoqkEBC0SjUgvk0klCNPdj0SHATkn0RFLgWDIfSiFJe50RLYENk8uWT9/ocMjx7LhyjSbGW0eQyEnbq/ueH+808Zb65puSnNwEg7VSelB6VUussLLj54j+Hy0fHy0A7KNAacsHun21u2X3wqdpqUqanRjAyAxus94tBXkRsUcM5wwGTVUo4labr3xnZSaCFeVUUiebGYiH1AFu21FKmfLY3aFsab1+RpJORHxPUG6yNp/8D+1Su2z7+i7EW9tNZgvfxccDFI6YO1rJ8+4fzZU7m4qF8XI8q4AfCdMITvbkjTTEma3LdOPLW1iG3gdE7ndE7ndH4i5+1/wjZL3u7Y3T9w/viRrp1lEGylaIXgwd+mH/boYTNS0Wkdrl9JP/0h9ard8RinSJxM2j6w3N9T5lnWy87i+56VMzws6egzi/3A6tEl3XqD7ztpfWn1GNPunKdzEpw52AWsMbK+s45SCnNeMGYNxnK2OuN8WLO/kTBV20RqsEIFQFfcuVJjwAfLo+D5+WL4hW2GL6/5whiePHtMFyPd2QYwTNuRtJswtYlKFoKiYpoMiFbqCv3QE1c9zksDkFUvXsnSKy4VpxK+OJQKmENVpNFfzwIvL4o/SmOSiwFN2oaakTCLNukYc+gqd6oANvWLgnOyzq7WHC8ULnaokUCGyoN/rgFFV6rW011e0Z1fYaNwLduhbcs6gaEbQ54S+1ev2R8A5ujjo8n1mgUJRQUXwVkvTNrWZFhpmVYOFliD6aVfHO9EzZJ/UIDuOcvX7T1llMEz53Zc9eOEW2oPqp5+LmGzob+61PCR8EqbFYWzlSKhuSIDtvXiVz0O5of6SgAqeE+eE/tXL1nuXqsyZ2k0QXIZQ01iW7GxY/3eB6zfeQ+/2sjrOs26VZCBFBfI08T9F1+w/eor8rg7skuNNcQ+SgNVSTTnOXvvGWfP3iEMw5vXDerJdPJ8tlrZPn/O/fe+S97vpaXKyMWvFOHINoRdi7GUaaEdhtADWF7ZscbKNsB4g41Ryg2KqNIy7Esavi5ZGqByplaxVbRcVMGWy9V8f8/8cI9fnRPOz5nvrplub2mlYL2l5gINfJBGqFYrNkbW777D+TvP5Pu9HjBuTsoZQtDLWtaw30QrVZL6itAyreGiXqZP53RO53RO5ydy3noQjWcrbAjMtzeM/Yq+i9QywXJQg6wMWUXTzzYcfVY1jeRlwviIt1Y9kKrGNDSgkEjzRNrvKeMkipQx2OgFQt0a3geG8zOW/cTq8pLh6pLQ6XBy6Cs/hJxU3QuHtpRmOMSVsJZcMrU1UsmU0jC2EXzgnfc/4O6d7zBOM+VyTRsUjp4zdYhU73DO8NhafvfdwqPnO+6C5y/fTbx89cD7T6/5+ifvsi6NXAp1ztiGrIs1hMRhCHUNO3R052eEvtNloTwuVT2WLS8C9Ee6xg2KvzEGnJG1MAgLsxmWeSaNe8EAoQOldqXXIq1J3ojiYx340OnaW8oIrHfiO/WyXj2027gozViAekHRoUgHPQzxQgYFF3tZm6ekA5es4Y13NGQNv/vqC8bbB/UPG92Cq9Kta37nHd7LxaHhqEuRmnlnNA1vZChqQN9J8h1U6S3QBDTvukgzwsBN40xOWRRQL+1UeZGUfVFifYyB/tEl3ePHuNgDVb2V7uhTbCVRigRqrHXy76ZE1TCcKJgCg2/OM97esfvqS+oyiWe1qY8R9PtELhfd+Tmr9z6iv3yEDZ0gt0rigClqZaFVWMaR6+98m/HVC1rJWL0iWG8IfY/1ljQnbD+wefc91o8fy2VDBXPTGriD+9FQcub+88+4//RT2rLIQNdkWDcITL56Szd05JRoqQFW6kCdYLT0doMNXtBjwRMV7i/fmkYGu6YFDdNCXQSNVPXyVGvVMJrUdTZE7c4ps+xfYO5eax1qPeLA0MvTAfRfmuXp1z9i8+Sx1ILmzKHYwlhkCMVQZm1yQ4kORjzYNenXojgqW06r+dM5ndM5nZ/UefuKz/NzCTGkxHR3h7+8gEX4hiYEUbtqpaQFmqHmSdK0VrrZ67Jg5gXrAt3ZBYeWpYYgWvJ+S54nXYdJ+MFaFJYuCiLes3n2DOsCoYsAorg1LYN0ol7kjARQxj29MbpOlvWstw6cDButVlmb10ywAWPg2fvvkv/YL/GX+3+HZKoMokvS7vKKxfBObfy+65n3Xk203Hg1TkxLZZ4FSTMMtzyrjs3FGb6LpGWhyeRBXaRe1ARP//QR/fmZDCYGUYh03SshL8BF5t1OWIpYjLIVRYhUBbM1SeBvH0jzKIEt7Qs3zZJLpS7ihcPqm7YReH/OSUD/PggbFjThIitO571cKtS/x+HxpKkfGGw/EM/ORDG1Vob2ko9YHHSYzbst25fPma5fywrUGoz15CXr7PlGeQpRqy6tl/Wv1cEbGbpd9MJ6FJlYihCqkQDKtNfPP2rnemF52DLe3JHnGeGCel3pckiTSX/5MDA8uiJenEu4TG4uoJaPA2+yVaVHHHyGVda4WCuAe1WfmzHsXjzn4bNPqcuMCQ66KAn5WrBOaikB+qvHDE/fw6/OtbZ2gVykMekA0W/Czb39zndZ7u7w1tBs0AtJw4dIWhJlLAxXl1x87WP683MlNmg7EkawRTmDM6TdAw/PvyLtdxI4ChIATLsdtTZyycShpxt6BSEk4bJ6+fpLLWI5cXLJyrlglLtqlFlqQ1SlWhqX6lJoRv5uKzKYGmOhFZyzOO8lFNiahLZKpuVMnUYN1mVFvBnA4EKk0sjzwrOf+TrnTx6LCl4rNKFGgHbSl0Ke9sx3D1qRWvQCZI6sYWsNtpOShTdNZKdzOqdzOqfz4z6/jtS8qBTdJkpdY07YA7LJyJtcWWRVmdNMWSYJKTVRi8JqoLXGsr/H9QMuRqpWSqb9VoZcOK5GKYmaVInwDrfaEA+pa2MhL6LE6eCGMxjfM+9H5v0WSyM4yyaoYmXFa2lMxTmDc5ZaK6lUbrYPPL18LGpMqzz96CPM2ZppmdmOW7741ndY2h5rLR8m+MUXW5682pPngneOYROYU+ZhSXz18oH3rs5wXpTIg2JZSyUVSUB3l2cMV5fytRQJddUGpVRqOQDdLWWRx4dapS70ICBneXPFGJqDebdlf3PLMmV8J2UDMqg3lnEhL4tUUHYyDMS+p9ZGWhaCc/KGa53qxQbrA6HvJJzFIeejKuTR5iDr53j5mLheaWhGlMNa3tRBmiZe4v31a3bPvyLt96JmNQPeUFMWdJV6M23wONukFcd6GhZMlUGnFYzVVal3MrSjdgPnMN5g8iJd9cMApZJ2e/avb5gfdhht/zLqD8YIBcFY8ZWuLs5ZPX6EHQYdit4obhQNiFVJhBt97iSIo6turZIU9mbPMu64//73mF69JM+Cc3KqutbSZIWNwZ8NrN97n/X5hXy8Jj33ANhDbacM/ndffMb9975HGec3SKrWxPbiHfOSWHLm6oP3ufr6JwRNwssw3cnzrJgwafG65e7zz7G1YrF0fU+tlen+nmUvSfn12UYuVPOM8YHQDxIEM1aKFHIW1FRKGGvwg9S1ikJqBVLfxFPbrMVQRWRuVQJ1NdGsNLJ5vVjVLCG7tCRKzVgj3fVLKtRcBA1lLaU0cBZTCiZE3vs9n7C+utLnQkJbgpKTnyltHmVjkLOWYiRMlAtHzRLEM0oGMc7I/Sd2v6EfrqdzOqdzOqfz1z9vPYh2Xjifot6J3w590yBnyjyRllH8a9ZifJRsUTOq+kiYidrYv35Bd35J3e9I0yww8hBEtchJIOhiDySs13SbC6mrtF6GT/U9SiLZgI8s88L4+itsq7Lidg7fGitrpbXFW6qqJ8YYUq2QZkIbeNiPPDrPsgbFMpdMtx7I3rB/uGPJ8mb1cW784U9vOXu5JdVGCJ6hDxgaDuh94OnVmvXQCVJpWfAxslptqK1RWmN1dUEcBlGa9jtRGhuyxm7SHV5yZXl4wB2qSTVIUhSd5IKsyOfdjvHujmm/F1uiQQNHgolapplaG92qx3iHj5EQgiq0huF8Q/BeVtXeYXWoEyi9lfBZ07WxkcdOPt+KiQP94ycSQMlZVS2jpk0ZQE3N5Hnm4eULqZdckiSaQQaTJPWMxsla2XfaiuSczBBZQlaWQ9heKjZxVgMxHhNl4EYDW3bYYJ14kqf7LeOra/I8U2vBWivWEATAT2344AhdpHv0mHh29kYFPahkGgxqzQqPM4rKR8kyBFph4rYsFwjbeXCG3cvn3Hz7W7RpkiHo0N6jz2krhZwLw+PHPPr6N4jrDW0eJRFvnIbODDTxSad55uZXf4Xdy5fqx1SPrxNmZ82FUjI2ON75mW9w/sGHktpfZkWqSRiwtYYog5aHl9dsv/wU5x1lynLxM41lWchLIXQ9/dkKTKPMMzF0UjMbZbCs0ww5i6fWQsUQztb42Mmr1hoJDi35SA9o+vo5NEyZ2jD2gCxD1uFZtgZF+bIOKEumloZpFW8tIXhKLRIgNGBWA8++/nXi0Att4dDC5rwO9vL6nLZb5v2k5AP1DldoVUJjJrpjWMmGTtq8/GkQPZ3TOZ3T+Umdtx5Ew9m5/FAvslI0aQYjLL+038tK/pC0VoB4Q9fNO/k96514rhqkuxup7wzuOHjUtAiexXvcahBQfjegqRjxE9pjABmcJZfCcndLmSbxYq5WlJQp+5E2LURdX0uQQ7yiB8D7Mi+sqUx54XZ3z2pYU2tmSQu3uwde39/x6rPPsM7wM9vCL/3qa/qHmWIM3h+8cY1nZwNPL9dsVh0Xm56rxxf060FW49aBj3SbNT5IKUDa7gBo2CMiSbIjjvlhyzLutb3HyDq8QZ6TqIV9pJbC8vDA/u6OZUwSLvIeH2SlSS2k2sBbhq6TEI4GeHJOxKHD+iDoptbwq+EYHrPW0kqm4I6DmARwtObQOPzlU8LZxfHPgqhSanYUL2jKjDe37F6+YNmPEgTRwErNokpjwBqxG4Qu4DsZdGrR3m+DhHeClzS99zKs14J1yvm00tZkh0HU+ZIpc2G+u2N6fYv1juHxhXBjx0SZZmwrmCBe37Be0V1dSXMPOmTrzr62Jsp7bWADthvkay1JbROWiqqlrcplIVfuv/8pD59+pi1eh2daZ1C1kcRVx+ryiqtPvoHr1tRlhthBt0JroaBKa9L+7o4Xf/GXIS90Q09ZpNnKOnldl1KY55mw3vDsZ79Jf/WYljIV8aiag2JbxQJRW+Pme99l++UX9MOa6X7EIH7iNE4YA+tHFxIqW2asc8RuwDrBitVmqPMiiCVVsRtIE5iLEkbSgT5PMxT5nq61/MCF1GioSRqvqpIXUK+rKNKZmhZaEdSaM1JqQINSpAwjOk+8uuTpN78haqp1mCgAfFGVs/iPlXmaloUw9KRpPlYK6wtbXhPBAw3XD4Ru4GjiPZ3TOZ3TOZ2fyHn71XxtUllYs/jXsORpx3x/Ry2SpBW+oKXMSYMfRZSIUoUZad1RkToMkpZGXRZZixmDW62JmzP8MOhqD0kfp4RKVZI0xzM/3JH3O2oVGL3RFqYDTidExxCjprZVSVQVqes6dtM9KWWasXz7+Vc8u7yij5Htfser+3uuX78ilMrveT3x+79zQzdmirUEJ+rWoyHyuz56wgfvXtH3kaHviQr7jxupNzQhiMcsLSyztNw45yV8UgvNSEI7l8Z4c0OdEy4ErBGUTi7CZA3OYZ0h7feMtw/keSKlJKlr73DeCD4pJVE1YxSV09hjc5INAd8PohimhAkeFzuxRbSqVYYFmsFaGSjaQT10TjrEz65UEctQOCp8xliojZoWyrLw8NUXTLfXwoy1VhTv1mhFLgK5FFxwuGAJQyeAdE1uC2cSwOJWPTRLqVleR4fn2QrM3nW9vDznSQgOKbF/fUMeJ1yMkhKPksQ3dcd2tyN0QieIm4Hh8RPFiClyCKfhF1H6WxUsk/Ve7SBJ0D+HwVsHcdt1LOPEw+ffZbm/k+R/FayQMU2xS1I+gAtsPnif9Qcfiv9zkQS+6VZyy1JfdEkz19/9Djff+Q7BOeJmTbWi7scgftw0L9RaWb/zjEdf+4Q4DFJTqeq2WAdEDWylkeaF6+9+i/n6GuMdy7ygNwKqgXi+wVpDToVapNHJWC9FFqrE17TIZfTgN7aG0OvFyxjMIei0JIX2ywWlqkJuFH9loxd+a/mBgF4pMrBq+MlaUb+9dceRsRQpV7AusLq64vJrX8P7KM+ht7KCLxqCw1DTRC2JNM/4rhOrUN8Ja7ckKXUIAR89zRicDceyDlFKD//y6ZzO6ZzO6fy4z1sPoi0lUVdcpJRCnh9EBXUeG0TlKfNMXTKlNg26OKWwSLpW1mOqYinqpegQZLuesNkQhkFaWqx9s+5F4OzNGMqSyeNIHncSavIeY8RTlneTzK1dxMZANB1nXQf7kcYB7l5Y9Z0mnQ2vb65ZX1yQUuGvfvopLonCu1hYTTO/8N1rfvb7twTUv2gag/d88OSMr3/wmHeeXbE+W4un0goGqfmAX58RukidR8p+L13vtWii2lKdKHnNWvZ3D6Rxj8XhfRQ/a2kUXY2HGGmtsbu+YRl31CLIJ4yVAdRArQXnPUEDOi4IbL4pHiv2vabHVd3RxLisRIukzL00NRlVG1XAw8UoCvVqfTCpyiCmqqWwOjNlHBmvb3h4/hU1LUcc00EpPaicRtPTXe/xMQr3slX1GGsiH4N1BmvdkeUooPogqWdrRYmrlbIfqTlRlsRye0/NBd91MjBjKLMk0q2xrC8vwHk2jx8R1oN+AeoFLcLLlF2tsG1NN8glLC3ibdSv5xCwwRgqhvnmmt2Lr6jzJJcI13CdFWxWaZS5UEulvzzn8uvfIF4+luFwntSn2CsmyNBqYbq/5/bT7zK+eEF0nmYs837CBke/HjAVlmkG5zn/4F3O33sP550MVqZhjNML38GjnNjfPnD/5eeUccR3HaVB0MBVWmYJIHVekuc1YdUvbK2X12ypwvg0FePAILYAvxoUOWbl45Yi4T5N0RtjKDlJ2r5UpSyArZU8ydBsbaDWwjzuwTS8DrVSVKGPYUo4p0Ei51k9eszl++9pm1ITRVkvEIcQEw1SSuRxL0+Xe8OBtQbxFesFWi5MER+6o6dVNimnsNLpnM7pnM5P6rz9IKqIlDJuyUXX8F44g9RKHWdJuXonb1IGbQ+yorTpm9IhXdxKEXyTC/jzc+L6TLvBJWlMyQLwNhIqKjmTpon0cC9czxBkTV+ypPN1aDPeYX0gbs4IGM77a219qdRpPkL4jbXYLrK7f6Baqd+0GMaHHXUcuUiZP/D8gY+/3OKaMArPu8CzyzUfvXPFu+9ccHaxkZafrsMaUYHsZkXYbAQ5s9uRdjtJAusbnXGeipXN4TKSRgkj+RDFA1uFAyorZ0NNhXmcSPNCqwJJt16aY6TaUwfNIRKHQQY1Y+XjmUZrEmLBGAG3O48JXviOzkvQRT+GOTQFNYWS60DtB+GHkhIHbqkk68XqUPJC3m/Zv3jB+PpGVNBD287h9aNcUGsNLjhi56WVyR1Utizg/qYIJyOgf+ssJkowxnpLw+jXoNWm+0mg9ONEUT+mC0F6562h5UVWwa3iVwP95grfizXhhzi3moanZf03giiAtUiblrU0q4p7zRgjr+ucM/PdDdPtjQTsNFjkO/EOSwCtYrvA+vETzt7/EL85lw70JC1PJvbCjW06ML56wd1nn5J3W7zzGrIzYMF3nrQk6pSwznHx0Yds3nsfa43aJEBo801oAEbqW3fXt9x/8QXWNsK6J41Z/LpGhlUbHFjIi7BMnRGbhzwslZySXgrU4WKNKuydDqHi3y0pHUM/ANZ78jLJ61y9mzhHyYW0n+WHkNfK3UUCiM5bKYPQgoGa9fdAvsdiYPXkMedP3xVQfYiYGFT1LUeyAcYKI3S/l587ziqnVC64zjuMemxNCFpdKqv5A/MW+IHH9XRO53RO53R+3Oftm5XubyU1YI0Mm4iyUJdF3qgr2lZywCVJ4lTCHAonP+Q1nMX1PSZ0+NVKwg3G0TSw0HKipUVQMGli3u1EOSlFfHHOQRMYdTt0XcdADFr/GILMSinTOcuhBafMiwwHrdL1PdPNDf3QU6jq3dxj9nvefRj5+euRD69HfGtsVj0fPrvga+9c8ezJBZvNCh+DWBF8wLiAix2+C/guUPZb8m6mzBJAEppPkyEbGQjzOMsbvtMENuLfFLVHhu9lnJm3O9IsdaGh9+JLbZI2b63hQ6Bb94TgAWGnWuvAy2q/ZQl06A4VZ8HosGcBahbvpXOCuFLrg+l7wmqDD1HWz8r6xL0ZFFutpN2W+f6aZXtP2u4BGVDkuTZqlajU2vDe4oOySbXOtOX6hldpxQdqnMVGT+g7zCFgU2U4MAd1NRdRQB925N1e/MPe4/uIUN3F81qLDNlhtSZuNviuV8uBHisNO+3ArLTuCKenFvWH6rq+6uODkednvyPtH0j7rQzj86QUB0PJ0mzVGoTzDWcfvM/q0TNcvxbk2DLL90i3Bu9prZB2I7vnX7F7/iVlWXR70HC9BKrykkijcES99/TrHlMW8m5LWJ/JY6VlDgd/7zLu2V+/Znm4w3eqPKd8ZJ9aZylNvldIFdOEVOWcPAa1VpopFGXQWmNpis/yIeJC96alK2XqgfFpDM17clrI4ySXUiOVmbU2SioanGrknERFrVk9oI2aG8Y1csrUlNTSAG61YvPsGetHj/XnhlxY3qjuYnVpuVLmkWX7IEO5M6KGKh6umSaKrqKqvPMYF/TyN8vvG3267alZ6XRO53RO5yd13vonbDXiMTQIiqjWIiGNJH4+46R60SLqqUCrpVKvHRhA3uF6URB9lCHDWC+NP+qLO67Z55m031HGUdK1zmliX1aXFFFBjY+EdU/oogxh3h2bXVxtrDAwzuRcsCmzzAm7KvRDT4ieaZpoqVDHBV5e8/Htjp+7nXm6XTgPgWdPV3z8/lM+eP8Jm6HHO2nusSHguk6qCzthnpqaWG735L3yUJuhUXE+0lwg50xdJlltY0Ul5YCxAdcFrDGkcWJ/t5VhpDXBTUV/7JxvtUpDVN8R1wOh78VnWyrOe2yIVF11t4Z0bltVfvT/VjOFrNitk+G2NVzwgtfqOhyI39A6bew5KGiQp5Hp5ob59pa8jLKybcLilK9biQo6GHgrz41VOHyryMWGBtrvjtHgUQi4Ph4V1aYr5pZFiaQUHXBm6rzIQBeCDCTei7CZEka9w3G9ImzWxwGzGbUkuEOIR0sB9PelYUlRQ1Zeb4dKTRSaPt7dMN3fSbvSIsSFVpusw6ughlwIrJ88Yf3ue8TLRxjrxV857kRxCx68DIfjq1c8fPEF0/WN+CRLw3pLN0R851nGhXk3goFuGCQMZw1le8+UZsrFI7rH74iyqh7p8eaWu+dfQZrwIWAxpOVNY1Ezoppa72U4rgVn3RF3BgVjZIA8bBKcl8CQi+G4jm8aLquL+D0P2cIyT5RlQe5gStnI0iXvrKE2S1pm+RyMEVUXVDnlqPpbH6h1wa8GLj/8iOH8/E0A0ctFRaw+CePE1pJ3D5S8cLhYtSKYKINc9JqV16r1QQoY9N8V+4h+TPXznlbzp3M6p3M6P7nz1oOoHXoZNrL4CVutauzXkJKMVBo20aaSA7PQGly3wq8GXOyFEanJZKm0EXXEeHljSrsdaZyoS5YmHW1CoR1CLDL4htUKv9pI9SMNsoQjjHrGrLNsnMONC/tlgXHm9u6Oq7OBBlycn7Ef90zXN4SX93zjZsfPPyTeq4ZnVxu+9t4j3n/vCY8eXRC8DC+myeftNmviZo2zkprOuz1lHgX4rQB+eUP3As3f7+VrbUa8mzrMW2tx0WF8oOTCuNW6way99NbgvHA+S9HBahAlyHpRYK2Xp9EZg+t0RTkXTAXXRXyn+JnKsTeepo1I1qqlIeCHjaw6rYTIJGUtShMcwjmV3e0NuxfPxeqQ8zGwglXR1NuDAI4F7X0PuvluSDSl6cXCauOSfG4+RlFFLUe1+6DsHsMqk6jJxiDremPeDK1LpiShK4Shp9usRX3Xx/Cg7B4qapGsPDZ0Emgq5bhClnCVKJPGWRqWZffA8nDHMu4o00id01Htl2BNo5VGONtw9t57rJ++ix3Wx9R6S5PYIILH+ECtme2Xn/Pw/U9J+1ELDRo+emLfYWjM25G8FAlYdZ7YRx3aZICjVdLtDa1U4vkl1kduP/++1GDWgveGtghWzcdArVCmBeNQxTFjSsE5Rwjy2iqtCha26RoDgwseHyVUZn3AOC9KZi6qtC7YEEkaWLM69BkvVIyi7E5RRo20KSkBQWpsde+vSqRwYi25Qry64tFHH9JvzlSZRutq5WLCMslrBsP44itaWo5tZlXRWoeLkvHy/Wadw8dBfnYZo/g2jxlWSoqQy0cZd7++n6qnczqnczqn89bn7XdOukpE1/G1aYjFOy2macdBC+3sbrViYiSs1vjQyxs9hy2xBgyqNMLUVkh396SthJCMt/guaJWfTjWqUrnVQOhX+CgDxuHjyNtTo1kjwZNSCXkhTAslLbTWuH24w+7PaK0xjiPpfod7fsvPfnHLH0rwyWbFB0+veO/ZBY+uztmcn8n63Dus9TRrCJs1cTVgdN2fx1lqScub4cYNHRVY9pOCzw0hREX8ZFForcGv1lhvGB8emO73PzC8eZqt2k4ExkPsekmLG4f1Ues4pcLSHNSmvEhTjLOEuDoO8ZIi1mrJKtzPUovUfJ5tiGfnstIvWodorJYV2KMvNM8z+1fCBG2lSjtQ06pW3BtVSZ8H26r4U3HUrNgvHdiaUUuCrnFtkD5yq5zRWusR8SPPryhuedpDM5paRx6Pw+sNUSKtc3QXa7r1WlL17nCR0QG0VqkebVZU+iChJgnN66r+GKpp2C5QamO6uWa5vyFPE2UW60UtwhITbBbkpbB65wlXH31IvHiECZ22UmXagT16aABLC69+9a8wvnhBWWZAVPTQdcShwzQomorv11JGcKiJr1lS69VbUTG9pyx7ds935GJ49f3vE4ee9WZFS4s83k2U9ZoyrhNub10KPjjMgZmpIR9boDaj4KlG6Ht8lIYt44QiUNTrffAXWxOYd6Oo/mjzlJVNSUmH8olGbcLYzTnLBaPIVgADFnOsosV6Ukqs3nnGk699jdjFY1hMLhXyEjDiVaBaz/j6BaWIGo0V9q7RUgRrZQB1ncMYjx828poY99hhRUuJWmZ9jkRhT/d3LPe3v64fqqdzOqdzOqfz9uftw0rqySu5Yp2XjncjyBValnCKrm1bkzehuHrjyTueokNlnUWFcJF5vyXtHmhJVvBukE+r1QoK2a6tQN/Tn50RVxvlDLbj+l/A6FXf8CHtt+TdnpALMWfppzaG+69eU87X+GC5/t7ndL/6Bb94PfJLoeNnP7zkg3evePzkitVqkISuQdSfLqoC22FbpYwjeUoU9bBRsjSx+EgLjnmcaIvUdFpdaVeqhHWiE99f3zPvRqbre5a9NOXE4DE4QRzlTC2Jro+4XlLgVgNdh8S7JMmdqofSxiPDqZABWqrHx8m0Qy99o9AwoSc+ekRcr7DavtO0jxzvtBlJhs359jXbr75k2e8kmIWlUcALBcBYJz3rNPEZWos14t0T7mtW+JbBWRm2a8r4VSfNNcap7eLQIW609QjKkpjvtjr0VR3W/dE/WpLAzqHRnQ2snz7D9b1YRswbO8GhovTgX3XDSnrrFS9EA9OarMZTxiqWadrtGG+vactMnidRZDU1L4QxS06FsFrx+Os/w+bRFbbvMUawYw2tqDVGgPU09rc33H3n2yx3D8K3TAVrGl3fE7yXKtiUqUAcekIn6/SDBxUjQT+cp1a5eKVlYtnuaMB63ZFz5uF+y+ZspTWVhpKyvm4MpRS6Icog7r2G1uT1Yqq0W1lr8F2U7veGVJRa6WlvTWo6nQ9gGvuHLWmc8VbW7DUVjK3kohi3BiUVci3S0tRExW9LEibrwSvsxDtc2sL51z7i8cdfw6nX3OqQ2PR1rL4fUoHp+WfUcUfLlbxZY63HUaAVoXt4QaDRLD6uMBjKeI+Nw/H3aU18w95TtPXtTajtx3s++s/9x7j8xW/yK//sn2V5dfcT+TdO53RO53R+q5+3HkTTfqI1o1ic8CZtDTIYgbAPayFcPmY4u5L3fK00bGhiHsXeWE+aZ9L9llqSKEohanWkURVJggXVGOLFFZ1C1M1B4dI6TFSNbUU4hMtuRx6lSrJzjm7OsJsEuv7pl+y+eEHqHGef3fCfWAx/7INnfOPjd3jy7IrNZsB78WPSGiZE/GZD2PT44CAX0nYk7SepGgwe5xwmOPx6zbzfM9/dY43Fx06+lFIkxKtAbus9tSxMNzfsHva6nhcMlWCRLNM04b2RViSMeh3XOCcr+oo0CUkafjk+F77vcMEL4mnKqnDJKlyTQ2A93ePHooLSRPlzXgbPqtOV81AradwxXr9ivH7NvJ+lxadlZaQKYkeUM7A0vDkgtbwQD7IqgRpcq1RqM4S+I6xW4unLGYNYKlrKqDSGwbBst4zXN9IyZYO+dJzC8SUQVErFOMv66SNWTx5jbJTwDQ2c1GWK4KY1ps7j1+fyeNdCs2pqTKIUt3kRX6F3bF+/YLy7BSxlmsnLInD+6LFV1u01Z4YnT7j6xs8IDsl6cFEGtSbDM+q7NMbw8PwLbr/9LdLDg/SmV/FCul5rM8eRZgy+jwyd8EJbThIsc5Gqz6i1ki4/AO1LSaJOqt/SWQO5siyFOAh6zAZHXUQdD8GLwupkvS+eWSf8VBquE9UdbaGyg7wWW14kzNOMvh4a890DTJPYfo3YPcCR5pnWKi5EnaMzrSasROCFN2za0YNba8Pq6+nyk4949NHHGKMXEGNVoVcx1DpIi7B1X7+iTtMx1MY4ywWx7+UiWfNx5R+iVNLW/T11nDDN0KzFxk7Yqy5Qpom8vRPIf/rxpebPf/4Tvvlf/k/Kj80oyvjP/9P/BR2o35ztt7/iV/9Hf+7H9u+ezumczun8Vj1vPYi6ELHISlSCKfoDX1fsJS0s00yeF1I1DJuLw7JTThX1xATPMo7k/a1wARUkbYyjlKLBJHvkZIZHT+g2G0HG6Ir7MHQaI28gpIk6z6RpJC+L+vkMWEcHbKaM2U2ArABryrxfGn/P1SP+8M++y9MnZ3SdYRlvmWxlvTmH6LD9mv7RBR4deDPk/ciy3cuApenkeH5GM5bd9WvSbod3/jigYgRZhJG1Z2mNPE/kSYbZEKM+PE2CWlXA37GPhC5gncFHHdow6rOT/mvjLHkWS4CxHq8p8zLNYm+wBtBh/rCWdoHV42eEtfrgFCZ+wOpgjQxnObO/ec34WnrSa674ID7WVpsgtNTPZw7LeWPU3ylKaC1SJGCc1bCKxXgjwbJ+EJV4njUMZajLIjD0WmhpIe0mfYw6mYWKVHIa76U9q1QahrgeGJ5c0W3OZNbObwZwqiixWFWSg6y4OXhEDTKo5iKv0SKqYM2F/fW1BL5yFv9mkmS+jZ48F4wyWs8//hrnX/s6NkuZAD6qVUWZpEZQWbUZxuuvyPs7GXSdo0wjxoLvLLUV5iTWiGE10G1WsqpOohDjPFUvcT4EoJLmmWk3YpG1O4gXc96PWCwhBubtlmVeWF2cYdRGYA1ixbBvWtCMhsuqkXYsFwIty/eZ63t5nuoig2sRfm1pjfn2VnvmHR6EYeo8SxJ0lveC2krLQl3kZ4Q1h3CadNOXfRJ1uzZMF3nyjU84e/IEg2LZrDm2NZH0NeM6lmlivr2GRby6bjUIQgu1jqRM7YRV67wjbC7k51Yt4CNuLRcuFhmYTb+SbcfdNVCwrRHijyc1v/76u/zsP/4n9bX5Az9b+/hr/uz5z32NP/TP/9d/6Nd+5X/wL7P77lc//AeVSvHb5XgnX3vVn0mnczqnczq/rmYlYlAfpIRgoInfcZmpWYDqsR/IeeH++ZdcvvvB0WeH95S0kO4eyOpDdFHQKdRGNUX9e5mGxa/O6M7OZG1YCiyLjrXiDTO6RquLsEXLrG0vzkKRN1tjLauh56yBvZvAGbw3/K7Nij/93lN+7zuP8J0lpTuu7/dY01jGCeM7rp48YbjcYFuCKoPashuZ77fCSwVs32HXK7b3DzDuscbQDysZVrRqE2RgL8CySDOVdxKccVHsDNZ5ypRIS5aWF++ELLAa6PoeiyFPM42KjYGmoPqqiCvnO13PN+o8isKj9AGrKC1j7RFhJINEFnXJWRnMjFNsVmLZ7Rhvb6jzRJpmGUa8la/JZHLOxxpXaAQHGK9+XRn2RQmXUBlAqZVp2jI8eoRfrY7eT9t11NYo0+6YOi/LTJsWaipKCmj4Q5K7FeHK1opxntXlhv7yAtcNGnaxmC5KDWdKMiIf6OUxymsoa5uQqnSkRVFNWSprx5Hx4U4VV6kFba3hV1GG50UGdTf0nH/wHutn78kwG7yslVs5MvKNkc87jRPz7SvKvMcZz/njx9zXinUS0Ks5Y5oMcHHViV3igLeyFmwUfqmVgJYxjbQfmffimW3GUErGOce8X8ip0Q+O3Bqhi6KJL0kCUNoMZpxVaVFsCZRCbU0oEMo1NUOvGwog6+OpNoPSKsvDg+KVqgQRvRMcVy5yMYmRWrXpyFlpujJWrSgHTqd4wmsuED2XH3/E2ZPHMhgfuJ6hk2BdSvp95ZhevWJ69QKTZ1FMY6Qor7R5r+URMmTafiCcXcrXVbP4k7uAKYKswlj1zGby/TWtJFFSvcW2H31iGj58wu/9p/7Bt/7zx1rWHzi/55/8U7/mz01fXfOX//v/6x/6tTLOv+WG0/Mh8MnTDf+9P/2HAfgX//yv8mf/H9/96X5Sp3M6p/Nb4rx9ah7xGAp3T7BEeU5HliVOAh81LVAyeXvHtD8n9muBVd/fkbYPIhDFKFV8BvX26fo+V9ywJp5fCgu0NphG4Rf6KEBxxcDUvFCmkTKPsvrWBqbDG6ywKiF6x8pZQikMxvKHHz3i7/vG+3x4uSalHbvtXgIuQDOGh+09/XTHY/Mutsk6t+RMmSeW/UgtVd6o+0itjen1DaZVwmpQvJURRa3IUF0b5JaPoHPnBdhfc8WagO9ljVxrkQR4a/gQGTYbCYTkQimZmiVRLD6+RitWVddDnaIMpdY6WbHmKm001uBXPavzc3zXy8CpK/rWUIZpoy0LeZ6Zt3fsXr+i5SqPiYLrnT14No223ojP01kroRQFxJclKe5IvKq1NXKaKVmG9/3LF+T9ls2zd3A+Qpqp4058l83QdpN4GJ0HK8q3DQHbyeuraRrbDwPdxTnd2UZW1xUpWDgwQmuRNTMWgrRNmXKgKihvM8tQI+n4TJ5H5ocH5mlUW0imLtoCZIxyYWU47C8vOP/oQ/qrK/ECYzHGQ84Q/DGU1xost9csD9eqLooNwHrP+aNLHq5vGKeEqZYQLMP5ijhI45MEdizkIlirKGpuzY1pN0oQ7gCvt+CcY1oSc1qIoYMQiJ2GnDSUZREagDayAmjoTNf9WvtqnFAZrF4gS571KxJlvaQkKvGyUFsVGHzwcjk5Xj7dAeeKVKgKX7VkKS+ouTKsB/kcjMENA48+/hoXTx+LUu+kxtU4Lwpoq0JysIFlHFmuX2GSWCWEHZrf+MZzghhoLeO7Nd1qA2mhLhO26+VnSc1CfThYh4wj77dyORxWHO0/6r3+jR4bPT//T/9DP9LH+A86/buP+IP/3H/lh37tu//S/5Htr37+Q7/WSmV+cfsT+Rz+w86Hj1Z0wfHP/cP/kR/69ctVZBU9++VUFnA6p/M7/bz1IGqounIz5JSoOQEHtJAEcaqqHt51lFoZb66p540yjbRpFGUuBg0rydpS3trkTS+ebwirjaSqk8LgkZYbQtA1VCZPgkqqSd54hDlYj008h6R3TTPMC2fO8N7lmj/67iP+jg8ecdVZtrtrSlok1e0sS6rib6Nw8+IFF48e45ysJssPsCrD5kw6s/cjdV5wzkh4KgRFBy3yJq//L9cq61BFzRyQTCYEWsqUObGMkwR9vKfrIl0/CAooJQ4OT8EuIQOpafhBg0u1HlUi4wzGycDYKtiuI5yd023ONKQho4TxgYYn76W5h1pYdg/sX70k7bZHL520zygaqUrCujaxEPhg8V58pc04CaE1HUA0TJVrIY1ykWhVPp4xjmm7x69GulXDLHvaPFNS1RCOtmDVRes8o/BGa6NlafSK5xu6iwtcPxwFPRO8KHc5Y1qhGXQV32OclSG0Id5Nmgyh+souy0wed4zbe2paJHxljCjPmrYuLZOWjPOB1TuPOPvgA+LZlXwIWwUJFDqMXUkTT4OaFubXL0jbWw2sef1kzbGdaXN5QUO+p1ZDIA4DNUu9q7HmqIy54GXmpLLMI/N+kt9DLwsVSpLLoQtOk+Hy973WvioMVjiaOdNSFs92Q2t4Bc8kM5nTP5dEMRbcgdgUZoHUy0Ps8L7HKGtUVG3tg89FHz+hKpRpEWRTkS1BcILFSnMirlZcfv0TNk+fyPc+9c1z2zTsNc/U1lj2e9LNa/WIN7Fz8IMKryJqrcP6ntgPYt8pqoR6CTvJOr9gQpC2s90O8iIXZSUbtOyo6eHtf6L+Nc7Z7/7oR/r7v97zyT/0d/yaX0sPI9/+n/9rP/Rr4xevyff7H/u///VnG84GsRv80//ZXyT4X8th/Xt+6WN+9at7/vxf+urX/N7pnM7p/M46b5+a907W6znJsOkHWeVmSaMb7yU8k4u82QUZYGqaFAmEAsfdm+HJNEy/Ia43ksJ3XpS6lETNOigh1ogCs9tJe81hiCjK63RWVLoYVb1caK0KTLtUvn654cOV5xefntGbmWkvoY4YPaU2cq6CxDms4MrCq0+/w7SdOL+8Eo9mHzEhkOdE2T0ADdcFsQA4K6DyJCvInBv1AEFvYKLHdUGGmyThnTIvlFkeF+elMSh0Hf2q10aboilfS56zDOUGUYqtxdRKnaWn+/gclSoWB+8FMXV2JipoQzFJouyBcDJdCIw3r8lLEuzNOOKsKoo6eJhDzKlKYMRaCMGJamZFwaVkalUvqI/i9dVVt7EG2wJNvaLGWVyrjLfX5J0jxkArTYWsQy2oKLuiHCdaOihugbBeEc42WN8po1a4kM0YWBagqB/Xg3GymtXBB6Pw9Zw0QGQpOTHvHpgfbmX4EzlVh8VKXUS9M97RX12wunrE+ulT/OYMY6SS1fSq/DVRoanSCLTcvCLvd7jQKdwfWaNXZZU6ByWxPhtopTvWWUrjlryucFa70GHZj6RlIc1JBlNQNVKuUDUV8UH6gDMWHz3eywDaml5mgLxkGeL08uiCKPP2B2gM1EaZZ0VdaRiwNXJKEtiqoqpbLx7xWoRJ670jL5mcFgmDgQ6wEtwyTkocgrOyZaHSnZ9z+fFHbB49BhpNofrSEtE0lCSq+jIllrtr7IH3qpgmUS4PQUhLmhaM69hsLoStay02p6NyzzRpyUagVEMZt1Dym2KE1jQgpiGpH+H87D/+J3+kv//jOOFs4Hf/E3//D/3at/+F/z3X/9Zf/rH9G5883fCNd874k7/0MZ88O/vr/vmf//CKf/e719zulx/b53A6p3M6v/3O2zcrlYrNGRvFj1jn+ahI2sNwBBQvwHarhnxTmwws8fCGIatQ1w/4vsetNjjrRMU6rPSOP/gNpRXy/ZY0jsJaNDJ0clglGiOeOeeotZHmJG+gi8Kza+L3PRkIxRDNQi5FrVeGXBvzXCi14a1h6B3OW5bU+Oqra4a7mfB7O85WKwF/b7e0UqTeswuqmMjavaZCLZWcMyVn0GS1CU4HTWE/5nmWNfRSwArCyXsn6teBiYmOlwZyrghw3Umft3NHL580HUmIq7Umg2M/EM/OCesVznrlM5ojf7Ed6AJpYff6JfubW/Ii+CkL5Cb4JQmENQ2NGZypOCcUAesDzVgdujTD7SS4VnIml6wVkD3GJvJSsFGVcw3/uCgKd0lNXi8ODa84RXNV8R62KoPSIL5JN6zUd6rMS0UzURKtlR/gdMqavKYswHSkKegwUFELeRmZx52gw/SyVHMWNdVYUTblBsXw7B02T5/ihzVGcT+UJGod2shT5XNO+y1pP0JapNThgF0y+jU2CfrUnET11u+hqlxW65zWxzrwjroklmmUZqUmflnNFeGjBMNKKpQqHFLnPF3fSwUmykr1XhT1lIWhioS1XBeJfaffw28QWjXn43PbSiEnHcqo2AbpAIm34le1yvWspbBMk4QGlStsLFLNq6EoqwEp6x39xSWb9z+gW63FMnBQYiWdxqFeM097pvsdebeToiMr6vphfX4IUGIMeUnMuwVmMP6W9TtPCf3wpvRgHGWDEgI5V+o8YmuBEOQyxJuGJ3hTlvA30rn/5e8zfv7qx/Kxnl30/Md//j1+4aNH/IFPHr313/u7f/FD/q+//NVpED2d0/kdft5eEUXg1tLFrMEga2QgUdA9gDUaIkoHZcfhhl6Zj2C7gO8GQohYXam1nFTFEjWsVanjq3Mm7/dMd3eyAhw6OIRPmiqJ3skAOCdR4bL0aE/Ljoeb12wfbtkw0Ww9dq63BilXSms4axg6h/eOJRf2u0xKBe8MQ0hM9y8gN/p+oBsCblgfa0SbpvzzkshJkDctZ/G6BiegeYDaSGmhztI4U2vDKyDc+4h1MpjIG598/aXIatJYi+s6TNGB0gDeY3Hqb1R2aN8TN+fEzZlC4c1RMUQxP63JY522D+RlZt7vSRoCMxhqQVLxgD+EJVrBOakjdSFivJchQakFKMJJutVnGkYoCM6pjcBi45tgmQHpg7cyHJmDT1GDU8Y5HejEExu6gW6zxveDhqUO1gtNPlcJXdVasLFTaH+FJIPUUbVNmqR3jlYy4+1rcpoopchr1wV5HTqlMugg1l2e0109YXj0FNf3ygeotHmk5iQXCCdqa5omlttr6rQHXe8ffZXG6OOMrqfFSyuDtEDcG5JWxxpMJ4G3ZZxYtnvyokUFxgnsv0mDlQXykihzAmvoh4E4dOJj1jIDG4K+VmVYt0561o2PhEHW6ofq15qykAO0iUhW4ZN8L3uHMTKYHsKAIMNzbVW2FvMk4aMi5QKHxLvv9HKqGwwTI5t332d9dYnrB32dHlq/JOzW1Ls877bM2zvqnIRTi3jAa8nCID1cLoxhWRLLfpb2tlpZrq9pNbN6+oS4GrAqTBMipTbKuBfbUejksa9VLm9K3TAGyjL+Bn+8/tY993/pe4yf/cYHUWsM/+if+D0APN50/OFvPv0NfZy/7498zGevd6dh9HRO53fweXuPqDNAoS0zIHa+ZsTgj3WifiBBBlHotAvaWsE0rdZ0mzNhEwKmqAJqzHH93lqjpSSevZQoOrxZI1Dtg2JlvcdGGWZySuRpwrTDe1jh7vqW119+yjJucQ5S0hW+gXmpLEvGe8vZyhOiZz9m7raJWitdsJxfdXRRuu2319fcXY98+M2flQ70IINYK4WSK8t+ZNEVufPuh/4zoO078mdrqfgQiX0kdh21qK8Wp8pPI+tq1vhA6DoZTg+tM9Ycw1rkTDOCEwrDmrBeq19XfYjNaO+6DmEYSk6k+1vKtAdj6Tfn1JTJ84QLnpQXmT8MVAudNzgbj1B4VImTF4RVf6hhWWZR9dwbX6JxTtBDxooyWbJYDaxQAkAVVfU/Gu2ap1YqDRcDvu+IQy8DVZOKzYPyKj2VOsw5LwB56zAlC2UBFE2k6lqTQTxvHxhvXlLyLOl7bUay1h3wtdQs69j+2VNWT94ldB3GRam3TdMPDEwFg6UWmG9fkbf38u/qMN0OtgnFWtFEfSvLLClyK8M36gW10sEqj4W1pHlmd31LThXvrZZGWMqUJPSGrNlrLlKtah0heGH9dpL4Nj6KZSDr92Up2GAJ6w1W4fqHS2DNoiy2IpsJ4yzLKFij0ImFouaCdfJ9UGumJMGJjfdbGVaD1QFWuKTmUBErEiMuOGzfc/b+B6wur6TH/vCiahyDYyT5OZOmmenmGpCOp4PqWZtQIShFPrY1LPPMvJsxxmGjw3hLQ2gQ8+0taRzpLq6I/YY0bWHe42jgdR1vEEZqbfI8OE9eZtIy/Xp+pv6WP7f/329z/f/8K7/hv//f/nt/P330/E1ff/wjfy6/9DNP+Sf/3t/Pf+fP/juMy48WCjud0zmd357n7Tmi3imYvWoHtMG6IMoKunbEUpcZjBMVphbwlnh+SVhvJGFNU8B4EwVM19EtJ9Jur0OS+hJTlnX0qqfp6tupz7TUqrxMQSTVUni4u+HV558x7x4wCBh9WVQJbI15qRgaFxcd3ltSqry6mWil0kXH+izSd55cGrt95WG/sN0t5HLH3Bw/842PGVY9NogPctruyNOsoR537NC2Rio18yhYK82SEIeeOGiK2TkJIYE8lgaKrsJdP+C7SMvSMmSjoJFaFm+fsYZmwYSBuD6TtaPTVhgDGPdGpW6yNl72W/L+4YjRMUaGymG9Zk+jpiSVqrOsm4MXVuWhlFXGAH/8N4x15FxYxlH8tkN/RDoZJ21PpouUZQHb5P9fqihVSNuScU5+PSoYf04yzHRRVdCeQw84h3V7rbQ8ayoeCAHb9UDD5CR+UFDkkfxnnFxg5vtb5jtlg4Kk4nNV/6goeCVl3Gpg/c679JtzCRlpSE6+Y+LROmCCwPjnu1fUaRTIvXOiejejKXlAsVZlnmjLzAH/T5HvgYY+z9rABZD2o6CR5iR1qj5irCdNmZIarRVKkppYF5zUgsZOwkatqoUlip+zIZB2I6qpX22wNtBSEnUyeOXrzoK9KhWcJ03ix46rHlMruSTx7lp5rGrO5JQY9zNlmfEHq4iR1zcNQZK1Ju1P1uBiz+WHX2O4uAQjBANhA/8A2D4vYD3LuDDfXIuy3NBVvTynrTVaFvuIcZZ5Wmi5ETvZmhhrFPGmirW15GkkpwxXTzDLiKEJaSEEyXEZwWDVVjEUlu2ekmclNvyNcR7+ymd871/6N0i321/33/1v/qd+Hx8/3fDxk83RevXjOD//0ZW8djgNoqdzOr8Tz9vjm7qOMk20VKBpivfQA26bpKJtw3Qd1gUahrC6oNeudhmIhIloNO1Nk/7xOo+k3U7eAKw59ndba8E5aqpYbwldR6nS3260JabMmd31La+//JLd/WuskaR9KQ2rYYk5iRq56h1d79nPhdv7GW9h8IbVRY91hnEq3L2emJdKq5WUCxVDbvD8y6/YRM/jZ08x1pLGGTQNb43FOAmouCR8RRk9DaWJFy5o7aH1XlpmkqjBxjtaqUIiwNKtNmJZyAkQXBYu6Aq36ro9Etdr4mqjKqRV1qf4BTHqH0XU6OnmFW0Z36xS9Y3fWIePkZW9YHt7TZ73xODwvsMEGXzQXnoRtCS0U6swLNM845zDd0HUtKXI8DPvsTHQXZ2LWo6SA3ykVkERueD1a2rUUf2ExhBWA/F8o2EoXcUfhuFa5HE1DULE6OAnjCzpkBdQ+SHoI38/zxPj6+ek7f0RH9Sq+JdbEeUup0JNlXBxxtkHHxJjhEXB6cFA30vCumaxEzhHnmaW1y+BItaTI5bAaSoeDh7GPCfqMktYzBgN4VjIFeMPWwEZcJf9nmW7PdazGiw0Q9ouzNNyTNT74HEhiB+06zQwKFYOFx3l4OPGCCjeGOJ6LRelVrB9B0CtlTrudSUP1TTKtMc0iCHSUpVQVPDia13EO1tbYZlnDJXYRUrJlNLwQYov0pS0bEGsB3G95vKjT+gvzt/4LrUpiSaMWBMitl+xffGC+YvvY4M7smgPPy/aIhcsYw3FSIjrUKV78A3XUvEE/BBl2K8V0wzegll2MqD6qAE6d3zOBFpWSNMoK/kY+BtpQCrj8usaQv/uP/ghf+pv+QYgLFDvfjJ+2T/zj/zN/MN/5v9GOVHuT+d0fsedtx5ES05QZf13tA8a9UpmUZaasZjYYa8uGc7OcQ4NIIk3T9K4VXAwiPqRtg+kadQQh677rcV4J2/ah85zF5j3e8q4w4eIcY55u+X6i8+4/uoLaAlDYzdWogfvJHRUa2MVDT4EltR4+XrCGOg7y8VG3ohvHxZ2o3wN0RmiE2Vk03ek2rjZJh5tAjXd8uqLhLcraT6KgtTBcgRIlyrtT81bahUfn2RULGG9wnpPnhcdMGQIKA1819H3gwwJVdiFxnsZQoGmLUVuWBHPLghdr0+C+uN8kFSyNbLmN45l+8B8+xpjmvhMgbL8AGuxGVm3LjMBcM4TYpSqQ1Vgpf7Q0JzHeKkXHR9kDdutenz0ZB3sfOjwfS8w8+CpcyLtZ4yqc1iD9YdmI22RWhbasuD6nv7qgrg507rRg8fyBxLRIPYABaUbgCypfXl8DCbIKpqcaDmz7Hfsrl+IOr1kSkpHbibNSIGAkQrV/p0nnL37PsGJRUCawDroNrICrkWV/sZyf8/8+oWoatYo41ZUYlE31cNbi/g7izT9FA2VOSNNSFUZoWgb2LzdsdxvZeWdCzhLv1kz3u+Zx1nKBEwl+o44dKzPNoLxcl5tGh3GSIq96eq/pIQxjtANMte3hu0HcUKUKhfMKnaIWiv5YZTnd73BlEoroqoefMs4zzwJTN/USgge01Q7r42SK7ZCyVUt3Y2wWfHo619nuLoSy0jJUBvGqD3HGIzvwEf2L18yf/E9qcNVIgW1yc8CRLlE/el5P9KysIxtH0QpraLft5whS6FAnRdCDPTDoAM/YklwUYJpWcgUtEZZZmoVZTynRF1++w9HrTXGT1/yrT/zr/51/6wBfvf7F/x3/9QfwlnzExs+f/BcrrvDMuB0Tud0foedt29WWipe8S8aqlZIuzSTtBAIZ2cMV49xa4FHk5MMZYc0eK2iaBhYHh5YHh5k4LLyxmR17WaNDCEmyBvsMk4s+zs8DRc9eZq5efmC668+p0xbDE2oUR42K8c8V6YF+mikuSY37raZVhtng2NYBVJrvLyeWJZCrY3oDTiDcwYfJLyUSmW/zzy5iDx+3NGa4WG3JVhLv+7oV4LcycsisHcHxnsJnpSmv5fp1yuG8w0NQ9He6loqpWasDwzn59jgJWCTk/hxo/pDq1QXMnR0wyVxWB/9dgLaturRrce1Za2V/VefUZdRFFMvimWbF2yQVaTQmCrLfkddRpwP+AM/0RjF8RiwMggb58jjSNrvcc4S+hU2iEprQ8Bb8YvmeSKcramIUuV9OHpH7aFJJyVhTNZKK5VwvpHGpWGNsV5fM02U3pRoZdH6UWFcOq81oNrRLp5QI9xR5E23lsL+5ob97SvhqiZBMRmEg9pqVbuB8D3XH7zP6uqpruJFATNxA9bTpgdMHDDOUnJh//wLllfPBRA/DMK4rciqXZvgW5XEfklJhixjqUUCGdYGCU1VbcqqErZbxj3z/VYtwaqed4Hp/kHIBkYuNj5EVmdrVpuNqNHNCAfUSxCrKTy+KlbJOY81ThP5ERc78JY2T5TdHmrT8E8hzyPUIhedKhiuWpu0iXlHs5Y0T+RlxjkrvFv19om6L8FDgfFXnLH0lxc8+USUUKw9rtiNtWpbkI1JXmb2X3zG/OI5foiq8FuMb0eElLXKym2N6X5LmaQ9jNZoszR+tSJKt3VWno05E7qO7uJCLnrByxCMoaiie6wqXuRra0DdL2o1+e2dmm+tMb+45S/9M//L/8A/E/XCvOo8/+J/9W8HOHJqf7POv/Lf+OP8yX/23/xN/TdP53RO56d/fh0Vn5V2GETVK9qqqjubDcOTJ8TVRpSoedJ0t77JIJ3PtELa75muX8lQ4OSN1jpHa56SRF01IWDjQMqJ6dVLbBVkUsmZh9sbXn3xJQ83L/C2IcFwS+gt45RZloK3sBk8ucL9VjBOQ+foowyX13cLy1IIzrBeeWKwlArjVFhqwxlZ7adUeXLVsVoHxqkwjgXrDGGYKWWh1KgMdqt4GlmNh2BIS2aZFrpVR7ceNJj0A3zKWvFdRzzbyCA/jcfHzDgrj1dO4DxutaK/eoTz8U2iuRZdWzfpPPeS3F52e+ZXLyDP+NVa1pQaVBGYvqdlSTgv+y11HiUU5QMHJlDVppoDS7Tkwnx3R6uFOPTS9V4LaRZVy3owvVc8j/bMzwux10Q2iMe1FPm6nCByjPPER+d0m3Nc1+uwqb7hA4HgBzyWJkb1GGfIh7V1k1W8tZBnsXLUysNXXzA+3MlQlAp1zqpoGqUygAkWEyIX3/wmw9lGa0lVeY29hKHyqB5G6UEfX3xOurshXlzghvWbcI0TMkHNmbbMgvsqkoo3h+GrGRl0a5U0WJBWrDzPTNs9aTfK82m90CaCJS9S/eqCWDi8D2wuL+iGQcJZUdalLTfKNGFNpUW5eGCscGSLDN4uOA1vZZgOuDQwwVNKIe0UT9b1WIQCYFsFF8SaUzImy8XAGQk5tSr1nFK/KfWrICl6gP7qEU+/8XX6izP1LQtCCx8wsVP/qqc2GF+/Zn79UoKJVgbl5uXyIfW/DXA0U0jjTFuyoJyMPeKWWhU/r7EO14tdwTkvFqEYdSOTwHpKmiDP6jG25GnH8nAvX5O2Udno34SpfpueumT+/X/qf/HX/L3Duv1/+l/8m9n04Tf5M/vhY4zhah252Z0S9KdzOr+TztsPok4ZoCW/GUBXK8LlI+LZBmcsTbvPjQ+ipqkPlJzI05603TLfPyhHslN2pqgsdRHAvd9sMCGyjDN5t9XqTcvD7TXb16+4v3ktKfVmSG/mL7Y7ac7ZrD21wjhVllKJ0RCj8ALvtknWi61xtvKcnUVCJ2npVg3TWNhPmXlOlNY42wS66Bn3mWXJxF5WhdM0UrKhYdicbXAhSBgpRJyu9Y1z9OuOMAzSzFME71STNCD1Zyusj2/aoY5MzEqdJblru554cUXsB6lVtQaKvJk3TZgbY2nWUHImbW8p23t5Q3ZRGJVGPLnGi6c3zTN5vxcmK2glppdK0FaOH7PWRrOGXAvLbo+PDr/eAIi1QHmLJSeMl/8NscNhaHOVbviK1JZqeEv8xEbXwJH+8pywOjumx6UZR/yrTVfjB0qAsQ5T8xGw3qoom0b5l5RMtZ55u2P7/EvS9kH+fssSaNHHuGYkTOfkf7vzC+LZpajvhwpJtCKyNQ11FZbtPWX/ACUTL67UV2iU/GDfPHdZuulz1mpSpxxRY4+1tl4ZtHkcmXd75t2oVAeJMbkg7UdFB6LVxVp65JulP9swnG8AK/SITtbprcwYDyZ0tFZoGJz1am+UtbtcCppwbGepUiUE8rIw3T1AEyW05UoqYmEgBnLKWF2DLIuEp2jKbzVSC0ptFNO0O0G8xJunT3j8jW8SV6s3SmhDqQOaesdQl4Xx5prp1XNCUOB8Kce2Lmljk8e3pEzaLoIGq5XawHoJT9bWYMnH4b+1RvCe/vISF3v5OaZhPtIMyyTPu+/J055lnqimoSBduYQtC2X32xffdFjJ//+fR5uOy1XkH/u7f46feff8p/CZ/drjrOHP/CN/jD/9P/6//LQ/ldM5ndP5TTxvD7TP8sZgnMGu1oTzC+LZufj92qE1xR9RKg1RJso0kbYPlN1OcEy5vkliF/GRWWPElxgiJSXy7bUORo1x3PFw/ZqHm5eUNB15gZIDMeQKlkrfC6d0mislF2IwrDtPyo2HB2Flblaevu8IXt4IQxT1rSyVccmMUyIvGe8NQy9J2d1eFNXYB0qpzHMiRk+tE9O4w/nAOkT6Qfx3rWYMVqD3XjrHS04C6zbQrQdcCMewymH51QwYTbjjAuFsTbfZCJlAweAccDVoIt5aSq2SBn64lzdXXX+bnCE6Ud1qo8wLNUs1Y03Lm8pR9fzWXI5qoAzNsmSuJRM7YSy+GQAtLgSa8/joaYg9g6qKlHpED8NAy0nT6w7rA9574sUZrl/JEGd/AMtUpJ2qNnNUZI01mDILu1SDKyY49ZE6WpVwyf7Fc5b7W9m2R1F+BYyu9ACM2mPFexz7FbZW7r/3bYZ33qdfrTSg9aZNp5ZMWSZJxQdPtVbqbXMVNBXyVLachSc7zlAbPsbj8CSA9HZ8zmqq1CVx/+IVy7iIfzhGbJD1sMGQFql3PfS3u64n9L2wMJ1A+zFi9cjTLH0Fzmi4vOGCEC0EhxnEW1urFArUCjbQTKWMI8tuR81Jh+ZKTYdWr0Be5OKZayXPo3qh9esBQXCp75SDyj0EVk+fcvW1jwSqf6AXtEZz5vgabbVJscLLF+SHO+Jaq21zpk6q1h7CeNZS28L+bqQWcNYKQq5UsfF4izXAYZ1vDKGL8v32A2EnGtRloqUZGzqMlwtbmvbUUrTRyWC7AKWSd6Nckn+Ec/fvfYeLX/j6j/QxfpR/+6/+T/43AKyi4+c/ugLgj/++9/lbf887P5XP6T/seGv4ha9d8e99/+an/amczumczm/SeftBtDb80BPOL4ln57LmKloV6LwEJjSNK33wM+nhXpSpJYlqZT3WiX+t6aDhOuFE1pRId/fUPAOGNM88XL/i7vol024nsPpjS4sV9aM1gpdBJedKKbJWP7AMp0nwNpuVp4uOEOTPWiteUPHtyZ+734oK2fce52VVnyoYZ/CawgdDjF4U1FaZ5y0+9qzqGYfGIkCYkdZSSj3ikpz3wlA9JNvtAVkDOsGKGjYMhGFFGAYZYGqT9XSWMM5BqcFa8jyTdveUcTyKOOK5tRClHrUsiTRNWo2acUBQZmdtMjRKDkgGi1ykoUfyIxLiMSHQqIqTEvB6mmesD1JgUI1UcHpPzZVqUUVTBoXWGs46fNdJk1TsRYkyoirKcGmOASPZwOqKviZIErwRdGd583ecJMPTw60MM7udwPINtCTp9qYoH3DSRuUEzB/XKxl6UqYuMw/Tt2jvvU9/caWIIsjjnjLvgYr14Vi/KdtgSy3laLmQgXVRm4YOlE5Yn3VJqngKeH+ZJtI4HVfuPoTjANQUeWScIfSdXuws3WaD74XuYLREoi6Sirday2qdw4UOY7MGchQeb6WdqWpI0IZIqYUyL4KIqhpCqqIyei/Vt0kvBSUr0zdnWlNEmRUPaitVAmOIl7Jbd2zefY+zd945er5BXg8o0kkYqp5KY7y9Jd/fEDdrbFSahl5kQV5/rVTSODFtRy1zsof+jOPj7bpDqE9ey93Zmv58gw1RLk9NFPlWErQsdg/nKctMmvfktMgAemDagqDHQIsBfuPnW/+z/y1/05/5r/1IH+NH+bedNfydv/8Dnpz3/AN/809nIH7b00fPP/Z3/Rz/pX/+//7T/lRO53RO5zfpvPUgunr2TFig/UrTscpftOEYcCl5Ie93pO2O5eGBliXJ3hTBY5A1e7MGFyWMUEolTQ+wzNRSmKaR/cMd0/aW3f094zgL9sgKsfSQ2LfeiN0ri4p3SAA35M/GYIkWnLPk0sTjORW66FitDBhLWiSMtNPu+a6Xpp9atZHRqIKCwXtDKRVv5R9bkiiI4/6OEAQM7oIjxCjKm0LUrbPSCnR4Q1age8uJlhK4KN5BTZyHrj8C36Edk/FHr62xlLSQp5Eyj5DS0cMoMX3lXoKAvMc9ZZ6xmuCXocXIUAEYJ9WbrckgX4quvtFgiA9Yb8lL0VWqtO1Y56WbvJnjChpzwCwJYqlqvajrBDcVNmJHME2akWQVL6qpKaKqVwBnsaYJT7IpLxRoh/pPHaTTbsv+1Uvy7h5aJax6Fb00ra2vmWagNFGSw2og9IN6YaVFyBiDzYX9559RU6G/ekSdhNBg3BuPrbVy4bLKvaUUWk6UUiScpoEXo/YCEKVUBi9HbZVxuyfPMwYjSrMxx0rLkgs4Qxg6ubj0HRaDc46wGoSLiTkOZi0tGqSpeBfw3QrnvWLOCqVIer+VLL5Jg1hhaqFMI3k/Chu4NUVBSd98zVmIBqVQyiIg/1IpVRVIa2Q1jyDZam1SK3q+YfPsHdZPn8rndWB/YoQKUIQoYUMkpcxy95qyvSWsegnoFYHzs8iFxBgrF415YdrNtGYITkoRcpFJ1HmjiCdR7K2HbrOiO9tgbPgh24So7VkCcT6Sp1EucjmBc0KWCHLhEBKIYKp+u4aVvvzf/Vv8g3/s60Rr+Pv+yCc/lc+htca3/uIPFwJcPPI8ff8/eLg/GwJ/1x/8kP/D/+ezn/Sndzqnczq/Bc5bD6LD1WMNJ4h3zx5WqZqsXHYPTNevSdu9tM809fzZA6onY53FDR22H6i5kHYPinAxLOPE9v6G7d0187ilpCRMOSvJVzD0UVaNKav8py0+tUhAInqLD/KmsaTGvC9krbb0ztL3oopaa1jmws3dom/CorCmomGdqgzT1iiHQG2qOGsAo8OvKG2lLmwfXoOxrC82OESNsyHgY6erVXdcXco6chYFVN8kQ78i9N0bJii8aaoq4qOz3kuP925LeriDKm/UxiAqpaqrUhQgmKY0jdSS8NbJm3VTD596Fn0XsC5QciFPUpEqqXNZd7oYBdd0dw8aYsFavPPiPxQiqXxcDcTQJBTTdL0d1gPhoOb5w2BgFVekyf8idY4HbJepRbBByGpehgFFFCl7dPfqJeOrl9QkF5V2aNqp8rw4J2itkjLSICtoKh87cTbkg3cUXdlKsj7dvsYZDS2VQsky1bsY1ReqKm8pSo0QlmxpVRPYQl3AcCC2YoyEjpZ5Ji8ZkHCb9fK6yFrWgGl0XYeLHhf6I6vX9R2ui+oFrQLMn2ddu3t854ndgHSvV4zxhL7HVXm95HnCWaNfUqbOM3mcFOtk8DGK+mrs8YLSmgyhBsEklVJo1YAR+0hKRbBgVgbp4eqciw/fp1tt5GJknT6mRagOVR9n56UIYrynTLsjT1S64jni4EwztFqYx5llKZhmcaqSV8TH6byXxDyOmuUiGNcd3bBWW4jcKM3hc6kHsoQnTyPL9oGyLFJCth4w0VNTos7CtTU0mhVG749yai58/3/1f+Jr/+Af/5E+zq/n/PFXX1HZ8bf+kU/059ZP5/zy/3vky+//cPhoWCeef/7Dv/Z7fnGF9/J5bvrAf/5v+ybeGv61f/vT37TP9XRO53R+Ouftw0oH1I1FwjIIfzFPe5b7G+bbO9I4K6ZHghTtoNLViusifliRSyHvR+0Cl2Fyd3fN/avn7LcPTPMMyBvcUmQoHHpHCI6UpYP8sFbPuembt6gvKTfut4mSG0uupNxYSuV88PQrx9na44NlPxZ224VmGsE7CWADNGk3cloLaQwEa2QQtobSoGYZnL0zR0xQYmS7vaUZg/eOYbPBx14HZTRUoY9F0uS6tbi+o9+c4XTAAg5yL7UWCVN4DyGyjHvS/S0tqVdSn5KqO0oTvAwJxTCPW+osQ0YIHqtDo1Sviu/OBoG+55xZJqmcdBoWMhqaSePIvBsxBlaXZ1jvqM3Kx2uqcbeq69T2A+qRwcVAWK0ImzOtYz28fswblTdnTSRbCR05IypoPajch6HVvRlYlsz+9Qt2z59DLbhBoeyzqFcuOrFwOGk2qrliXcSHKEqmKr7SYqkhplopJRPWA3HdQ1oo0yghrxAlfe2cDJ9aQdvSoiqjpWZp+YImCCnvsUEUulwqaVlYxpGSdbg2Api3+u9O+wnnvXJZpbrWWPn8nfdScFCKDKBLOoYFrbXEvtP6W730Ka5LvLkF24RYMWXxnNacKdOooHlL6Ad81x1JDlX9oCVnrJFL2zQlXceLB7i2Rq1V1vPGsHn8mMsP3iNszuR17FS5xUM41J3K99N4d838+qXcL2KUDYn22lOKKOlVQm3zftF+gsPrjTelDq3SiqEYi7UNP3j683N89ForKnWpNuhjkSrGOGrN5GlHnve6x2/4szMJfeVMGWfhvWq4zgSP3oR/46c2bv7tv/qbOoj+rt0D7/yu31j/+4/zPP/s1ybgx11l3P3wgzrtttoabPiDf2zDxSrycx9engbR0zmd3wHn7QdR9UW2nCElKo153jPd3JAmUU681wCMegxt8MJK7AcIsgpbHnY4I+GU3faBu5dfMO3u2I/SwuKdpTQYp0wfLN3gSQXGfSZEQx+dDKilEpw0F233hbQUYYA6R9dDKI79lInRcnUeWa8Dxlpu7hMlF7wXn2qpOvTO8sYavD1WbdYC0auloIk31VQIziiHsuG91FQuyz1ub3HvPJFmKW2BsUbqMVtpR9i8HQbiZi0d5oeJ0qDqn659a8V0PaUUlutXlLs7SV0f3hWdE0g6yODTRfI0Md/dyPrTSi+5sXIhaIpuMk6GHCrM+52k46v6Wo2RJLqxbBWq7r2nXw+0IrYCYVU2bPDYw+OgK3iKqKCuFyyV71bHoeroqWjIkJCLKMO+ww4DthXIiw4Z+po7hJgAGiy7e7YvviLv96KIRY9BfZ/rXlbKRTBJZYaSCzb0OOdFSdT1dKmiVYbgJHjkLN3Zhu78HJoEeDAW1/fSMAXUvNCSdKvXZRZkVm2UkkTNrDq0KHeylkrazyz7PXlZKLkKXxaZrUP0pGlkWWZKbfTdirgaZOA2oow75/ErGbTTNIs6rpcfGySI42MQJfTA5bRS3dqWmTpNUBvOC+uzzAvLJA1bPvZCdPCWPI7UJspmzpllngiCFRB+qfAeJJSmMHiHxTjD2bvPuHzvPfwwvLlMNcB4sT4fkGAHL+bdDeRFtg76XB2tFw0JKdbKPC+KG1V13dlj+1ZrqsI3qY71Q8dwcSnfTwc8FhWrkP/DZbjOC2nak9NEM4ZSC+F8LZ7UaaKlJL5k57B1kovHuOBXw2/oh+tP6/ynn3/G4zT/tD8N/l9//uHYQ/HXO3fXb1Tnv/Cv33N26fhDf+AJ/5k/+gl/7t/67k/mEzyd0zmd3xLnrQdRUYAERH74gZ52O8qSsM4LB/IAAvce6x0uRlqMpN2edPdwrBCc88Tu7hX3Ny/YbidKqQT1ei1TVg6oI1fDbiz0nSN24unMLdNHR3WW/SRetr53bFYB72SwHKdCpRCD5XwTWK8CKTXGecY6CQrlAl04BIoaITqy+k2tteQi4P3cqgD2rdHQs6hBRhUpw5swyjje8fL5az78SGo5pX1KVowNaDYQLy5YnZ8rgP7wDlzf2BxUuSIOzNst6e41zKOiiJqqhE7wNc7Kythalu2OvNtiWpPQR3njUTTWiZ9TrQA5Z9I8U+eslaNBfX9Z2q7GGdMKoY/0qzXGObk8WAkJGa+qVzuYJmQgtcHTnZ8Tz84F4XXgLzaOPtSD8lXTAnGF6wcdTBOHVDMgj5/zgFgr9tcv2b78ijIvR0+scREf3FH9q4ruEYYn9KuNDFfLoilv+Vg2SCgm7ffYPhAvNoT1mrYkyjhiVysZQo16G9NCTQu1qK2iiHKIqn/WOioSEGpW1vB5Wlim6Rj6knuG+FWtt+Q0s8wLpcJqvSL0UUNOQgJwLigWqVDmWRTQridPE8YY4tAJ+aDxhmFmZEisy14YnDlTaqPMs/iKtSu+W63wmw11SeRppFa1MNDIacYbCTiVeaaWRilHk4E+36Kqn73/DpcffnSs8JUVQtRGqaSQ/0RZJpb9nrLf0UoW4kLOasngGLQCaW+adhMlV0W7SeCqFLHGNA7WGbkIuegYzs+JXScvHSv+78NwXqY9IIUP1VZyTeAtZTfhNiuo0OaZMidsF7BBLoK1FmppEhr8MYDd092WX/kf/sv87v/WP/Ajf6z/sPMnXn7BH7i/wf1E/5W3O+P2NyYl77eimL5+kXn96m+cetXTOZ3T+Wuft1dEfaClRNpvSbs9eUlYY/CrlShDSVPUB/XLB1Kt5Ns7URqo1JbZ399w9/o5+/2Occp4a9isArsp03Jis/I0DOMsCudqcOzGQs6V83WgAVMST+jFuQyZPjhqaSxL5eZhYV4K1sLjq44YPdOUj29kKVWxDhjY7xIhOkWdZoYhilKYMs6g6pTyEovYAKqRAJSERkQ5lUrFxu4u8Rf+/L/L7/1Dt/zRv+V3E2LUdWDBdj2rJ0+I/fCmrlIHrwa0RRPNLlKaYb5+TdndyWB6UHmMp/lIyxk/9GIXSAv5YUdLSdO9Ojy1rIOU16FZhqa0LBRFA9kYcFEqN22w5KkxP+wxxrA6vxK/JlI/2ko7htKwHHFF4rtzdBcbaYjSMNsxpNJk1GhIBWYriVILdlgL3qqocmOtPs76uLsDa7Kwe/WC3etX5J0Odt5hY8D4QE6NlhdpEApRCA3GsdI+80NIp7UDbN1gVHkNmxV+sxIv7HYHWdR7H7tjII9aqbmQ54U2jTjnyUWqN61XNNYijVUUGeRLqcz7URiqpeg9Q0oAvDXMux3NGkxwrPpegkkhqoVC1pMuAEZUzNoaPgzqI7X0jy7x3ipmyshK21ow9Tg0t9IE7TXPpDnpx/VY7/HDSgDxVp7TVhYwlZoSzspgn6ZDwET6p4rWolovqvjZe+9y/t57ErRqB8+0E7+yerZbq7RlYt6P5L0wgY2PtEUqQw+rdrzn8AulFsVICdHA9lHua/p9WKv4vY2z+M4zPL46Ju5bEVIDGlBryyww/5aoZHIS9bstM2EzYJoh7WVIN0Y3OUujTjO5VHzXY4znRx9DgQZ5P2vI8ycTfvpbr1/wR25f89szWvXDpzXIS+P3n73DL5w9A+Bf+ez/x96fxMq6Zul52PO1fxMRuz3NvTfbqqy+yCpSLIoEpRIpmzJlWRIHMmDDsmzJsAHCtC0D9sATzwzYA09kG7AgN+BAE2uigWBAMmBIFCyJJkVSAllFssiqyj5vc87ZTUT8zdd6sL6Ik2VWFU9W3myqci8gkZn3nrN3xB//3v/61nrf5/27fLgcf8Cv7Kme6qk+7XrnRjQ8viHsD5L+UqvAtE+Z0bXIWl7JP8+I+YicqFU4mtP+gcc3H3PcPxBDRinYDJYQCsc5MA4WayzzktEG+s4yr4nUVuG70bOsotu6vHD4zmE0sh5WkGrl7iEwzZHNYLi66omx8vAoZhZp+CrOGaZjwjvNuPHMc8A6zW7oSbmQSgIq3llhVCJ6sYqSNXtFjDnIpAYglYrrHN/6Owe+/s1HXr36u9Rj5Y//mZ+ivxxxl9cMux3GamoKsrkU7QKKNkV2HpQhTgfC4wMliOZQKWS97fr2QKyYXhryOB0p84xSGu3FgV2LTAeVltx1rWR6lUolTVMDsCu00tQimkq7EfOYjol+N1KVfLZKKVTKEDPK27YaFZ0hDcukjMVf7Biur8Q1fuoWFA1GX9422zlTMbhxlInwKWVHG5mmNxC6fJPCOh2Y3nxCngU9pVvzZ1wLQchJpARGoZQYq7qNsFdrloNPzSdNpUEp06aLim434jYbQFGPk9ABdhsJqyqZUkRnWBqjlLiKHhRQnW/yhrYCtgZybdPDSEqhOeubCUuJKcp3TsIAEN2ja3xW1wvr0ljR7Z7IXrXE1vwZ0jKhrWe4uMS0A4Iy7Y5Q4owvqa3RSyaGlVol5z4FMStZ12G6Tt4PiqoKKeSmS1a4rpOs+RDRjRaA0eiq0apQjMZ0HZfvf8D2+Qv5mHKWJq4xSEmxMUuFNLCukXzco2KiKE0lNnMdUIQhTCzSNEdpUK11KFXI1KZpFklMSu0QqcH0jv7qCr/dnXFmpxU8tZ5xcdREjiu5RGmMK+i+F5TWmknLKgELGwdGTFlZa5zzgv/KET6l1m7+2if8/X/j3+Un/uK/KFuLT7F0LfhS/kA0od9eYkaT+/y/9dmf5d/+6q+wT4FQnialT/VUf1DqnRvR9e6OdY6olMThrWhrNiOYFCsxgWldqblgrCHGxPTwyOHhNYf9HfO8Ukqh6yT7OoSE1pVhEP1mylViDZOYEcbBtgdUZQ2yatdGMc2FdVkZtw6vDDEW9vtACImrC08/OKY5k2JujtF6zpxfl8wwWtmCp8xm04FShDURc0EbYYUC1JIEG9XcnKW2jXfbQuYGlzdW8+bDwG98+RFrNBf9hq/+6iOd/ib/2J/7GS5e7t5qHZEvIlzM1L5PJYVAOByo69wmXeJJr8qhOg8py9pRQ1wW4jSji0wBVYO+11Jb0rmCqiXlqMK6n4jLLFpKI5rWFCvWu8ZwTc0N3uIlO99o9qo1hoh2TytKqK35ANN1dJc7ut1Fg3O1ta0WzqW8W926qoy2Hm2d4IQEIgXops1rUZi1Cmtz2rPuH6RRiDLdNZ0VbJQRY1ZukghQqFLxu61MhWNryqpq00hZ05YQoZPG2Y0bkQekFeWcSASUSBZzgVpEPpDXub0n14D9FYx8v1PTX5Lk3scgrE1lDClIaIDRmphzM2LIfaVdg/IrjbEdruuxnTtrdGvDRcm9AWmWrPR+sxXNb0t/EncY1LA0EoIcuErOwhgtmZoCzndCLACRC6Ca6aeK3ESVhgzjjFwrgO2drOVzwQwOtxm5eO8DhstruUe1FjxWyUisUxtzIoes5TAT3rxG5ST3Mvkt9q1pR2MSt3xushjjHVQlSU6nQIgsrFvBuIEdPf3lDrfbyWGHSl0b5zSvaD8KaL8W0roQwkRtPx8oaabzEojz3LYekjyFNeSUZTpdoYQV3fm3EpNPoR5/5St87f/xl/nCv/JnP7WvaUvhH394zS/f/cMJSn+QSinFv/KFP0Stlb/0lb/Fww+BDvapnuqpvvt650Y0TauEAVktK73OYb1vOCCJeCzTLGvbmlke9+zv3nB/94plWVBV8EqlaEIoGF1xnaYUzulIQvIpkp2NYllk4tV5Q0yVw5TlQWE0V1cdzhmWtYgDvsLVpUwND/twlggoJIUlxCxSgk7LilafpjhtBavBKplGWQ1FQdUaSossVLJ61EW4izQ6ALWyToVf+7U985y47LcM3UjvOg7fiHz9r9xhdcfu/a00A1WiDmvNLbO9sD7uifu7JhlVbQ3ZFoJKjBkC+S6k40I4HOSzaNeflrx0ysSWWE/D2hiMqjY3t9GUlFGdwW7aRBsgF+I0k9eEHQZ0MzjJLlX4rKpW8hwEdq8Vw+UF3eUVtvNQW3NhBaLPKQYWWhNa0X6QZrmtrxW1aWTr2aUPwqINxz0lrpQ1kJcVY0UzWUDc9RVKkzKUXDHa4oZOGqwkefb15FBv17DmTLWKfneJGQZqkJQq049tetaSekqFnMhxoaRIbSk98vqqoMsaFqimTE0SM5nC+lv+v21GvRQEzeSsHLaMc5AF72Uak1Qg9e1ahySTXk0LD4D+YoMftufrWXNu0gV5v6KXbQlTTRtas8RhGusxzpNTIrdITUlg0qQcME6jqpKfifa+SpINQGoHBu0Mpu/ZvfcZxptnEmKhtTje1YlvloGGdHOW9e4N6fGN6FitaempLWEsF7C6Ib/yOdxCNXlGLZUck+i5lYLcricV2zmG6ytx6GtzRmRVKjWtzZwnTW0OC8vhkWp0S1HSzTgn6LCT9hmnqUYm2EZZjNYNjyW625LTd/I79R9Z8fFIuNvjr3efytf73DLxz7z68FP5Wp9W7e/TOXTg0y6lFP+9L/wh/p2v/V0+Wp9W9U/1VL/f650bUaUlYUj7ps9zkoxSciVPc+OBVsI8s+wfeLx/zfF4IITUJohK2OSq4t3JNFNxTjBMa6gYozBGNzOCYJtirjw+BuY1sUS42ljJgO8s05Rbs6qxTtKVahUQe4W24a2UVJuL/OQvackstYgWrdQz+L5USE3DWUpt6TzN3FvkgaRbZnjOhZIqX/7yzIcfzQy2Y9ONjK5n12+47C9585Ujd9Pf5yf/1Gd570svZa1q5YEd54Xl4Q35eGzsyd9qMThNDUstEjc4T5QQWmRhezO0xrpFiyqtqVqmc2GSFax2jbdoTNNvQg2JWpXo5rI0kn7by5pZKbTT5DWem9uCrPi7ocNvRvzFJcZKE4oyYlKpRRzRuU3GlBVKgDFt0ifzWq3UGTV0SpeqVNK6EI+PlLiSl0Vc+0OH8FyTfK1aJAY2yoTV9Q7TYOY1ZiELaFk1q/I2+1z3nm4c0QrKvMjktx/OTQm1UFMmx9AkA1kSvJruULU1cf22Q4xSwsjN00yOckjSSuHaRF1rRz5OMl2tlpTlM/L9+FvSl6CSU2oszeasrxI+0G1GAfCfWuEicPzT9LieGvpaSHGlIpzRFCOmEzZtSamxa0FpCZFIJWNVRcVmpCsilUgxtQFgkddoFAXD9rNfZLi8RCJs4dQ5q5OG+nSA0obwcE96fCMN+4kEkUWnqo0RAlwpcnjNBWU9Rr1NS2ttpRwyjBH3uwLXdwzPn+FPkopaBdVkDHWdqaqJjKui5CiN9naU1+ksuh9bvGeQsAMvpj9tpQHWyqBMhRTl56BU6rqejVSfVt3/zV9HO8tn/qVfpru9+K6+ls+ZL8w/fM3Yr/7nEyl8jzpRwCjNn//gJ/m3fvO/+J59j6d6qqf6/tQ7N6Km82ilUJ1vztWGrEGSjNZlYv/whuP9PfNxT2iwbHPib5aKbWib3ODWSkl0pvAulfQPbRWeUmGZE9MUKVWmpFe95WrnROc5RVKU6ZzEsAtfNJ/iBpUwQdVpnacFN5NSczw3/WVVDauE9E6luXLPpvaWFnSaiZ2q5EJOhTevE1/5yoQqht1mw9ANbPuRi1HMMq+Pd8z3MyVmHB3Pf+YlqUTC3RvS4QGKNDzCf7QodFuV17NTWlnL/Po1pPxtGeacV6un1WFtcomcJKHGWivQ/FopFFQWXSihreI5GbKk6dHWv51a5m+btNWKURq3HXGbbUP1mLf6zpNJJSVKFuMHxp11ppTydkKKpEOdGimqJFaF4wPh8CCA8dME6nRyUCABCVYa56pw2y3GuqaXyGdjEUbJOhUlBjANbrPBDQPtRjyD+evpoiET1hIDtcT2WZ/Ssaqsnzk1txmFTE8zlbAGwhIQkL+WyV0uuGGgamDWqHZw09ZijUNCGKRprbSGrEgmveCfDLbvcL0YqYRK0Bo5196bnOooaSWFRQw+MQrBISVM1yD4axTSwCkWNmUKBWsUqk37a0seylESojBNp+klocmgJZPeWfw4ip4XI6zWooEE2pFKYX3zEXU9cALhl5iE8FCLNN1GUXOUCOBc0Rh0lU2IbDDk5KcbJko3coLpLOPzW9xme74vVOUcvqCsE2ZqiuR1FUKAtef4WO0Fg3Wa1pcgjFnRPEsCmmoT5lrqW8oDQPp0J6IAb/7q3wMUn/1v/jL+5vc2GbWl8E+9+Zh/4v7Vp/vinuqpnuqpvo/1zo2oHUeqkvVaSan1SZqcIvevPub+kw9ZjntZR2Zp5JSloV9a04n0V3DqnRo8vqUZxQohSINXUhbnejMYjaNoP3MuHGdZ7+qWdKT5tmbSCAeUXLFW3OKnqU0pldimpt6dpiANzZQL5rQaR8m2scFlFC1rXsman1o4mZW/+tWJ6ZDZdRs23UjnHJtuQ+863kz3HMOR3nbkO/jqX/2ENQQuXypqEg0hLQtceS8w+Fwoa6Jqg99e0m22YmKpcPj4o3MGu4DZi2j6VIPuKzH8SBqQhvYeVHtw55Qat1RkBkZLYyAPe5mW1vg2DpJmdDJG4weJxtQNVt54RG31fnpQK1BG2JvWyeSsTblqO3icNHkiT0BYmvsDYdqT13CWSZw396VSVWnu7gIYSQ1ykjQlesp2U7VGImdhm9qxw7VM+VPMpvbdOZ2nZEkqKimRgnAjdVvP11pQyHRY3OqShKScNPNpkaljihHjLFq1qWbO4pBfI1UV3ClRitZoVsThb1tDelpDa9Hjamtw260wPrUWQ1trxCVIQqFO91+IYgosYhgs60JFYcYRqJQ1yLTbGErDduUU0LT3VJHpdfs5zif5irUoa8gpYYzF9R11OhKVXDM/jnJ4aolUyjhSCCxvPoGm2xPcmKJBP+V7pQQ1y3XLCm1cO+zRjF+V0nSuJw5uKRk7OMbbW2y/Of8+qqdmtQVtaG8puRDmRwqCNgMJcVC+l0NHPOlIm5muSS6M8yiFXK/TwSRJ419Kkcnup1x//EvP+MVd4ebVt/grFwOT/Q6yRVr5Un5km9BSK//p62/8oF/GUz3VU30K9c6//XIust4rMj1IMfB4f8/j3WsOj3ekFKTRUAqlIeXCuhY6J5GQqbmsyfLoMFaeQGvIhJib47gQokDavdVkoOsd220nKU6psJ41dxpjWsPYJiqlgjEG72QyqvXbFbrkbst0VCamsqoXA0NbCbbJ0Mlmo7RMSWKURtd7mQKGIIO4jz8KvPoo0OuOXb/Bu47ee8au52Hd87A+4LTlctjSOc+rr3/Mm48/5INfvOQLf/QzslKu8n1KlOjFUgqqH+gub+h2l6iSqCnRX95SlWZ9eINKslaX8WaRyFGlpVFCNKWFKqtGLSvPmnPT3InBRNtm/Om9aASzNLUnV71qaUZu6HHDKNrGxiHlhJ85cUGVPBiwFo2T70NtzUVb4Z6wXsi1ziky7x/Jx4m0LqQ1nBvVvMbGcGwT2iKsVm0crhsxTmgNJSYxUbWkH5lgyTrXX2xw4yBr8TXKxKwxV+WGLs2QFM9NqGpv6dSF16Y5xYgOVbV7KU4zOUgwgm5orDgvhHVhvNzKYWxdQVV010voVG0T+IpIGhSyqleqOYOFb9pdXuLGDUrJtBgt2CsVIxXRtVYFOSXC8dBMWYJtoh1oSqmUJUjDpaEaQzUaciKGhNPysxODAPKVlXCEWkFZ0WfnXCSNyrhmgivU41HQSzHgr28lKEApMdrdv6bGFdd7Si5iXlf1zLAtKVFjFMZr1RJjauQwmFfhE6u2MTHNpFRTwnjDeH2F8U6m9FbYqnIfGvnRbQ79sL8nxQXdDShnBctknMhbQkvsajG+yhjqugqvFSWUiizmuXK+b9vt+ilROV9eDvwP/umfBODzz7Z89nYDrHzw0df4d97/PEG/+/fRtfLnP/rRzGKvtfL//NY/4NeP9z/ol/JUT/VUn0K9O75p/3BeVR8fjjx88jHHxzeUHCkVSlZ4L/iTsGaM1fRGnycnp2mjNro5YaugXVqSTkqVVCrW6HOT2fcW36ISQymkXNAK+sHJGr5IA5pbXr33lpNCvippbE/TGNuyzY06AU4qRZxAZ9oQTdpomoM7xIIyCucNmgqlsoRMAQ77xFe/MlGC5mqzYegHOme5Gi+Y4szr6Q2dsVz1O8Z+YIkz6zIz3y/c/Uf3xKXyk7/847hOk2bJ/q5K4a6u6a+usM5BjtQUQGmUtYzPXqB9z/HrX5ZrWAq5ZZcbL5Ph0t67dU4GZbWtGZU89K2xaOekaTUesmSky4a/JTUZg+l63Dhi+/68vm9ROXKN6ymeUxqC06RRlcwp4/ttnCdnaUOplTgfCPORNK/keSGHACiqqs2BLfo9NKSYyTHjrMe6TprsGFGaFjkqU9ySS9PCVtzFBr/dyqp6DWjXnbWvGENpCUlpWcjLzMnUBvWczCTOfGT9rFvaVlya5jijKjjvCGvg+HiUlB5vyCERk0zsrfOYqtplaDxZY1FaEddZppfGUErBbwb6q0tsN8oK+9uncLUAcr0rlRIC62EmxwhZdKW66wVCH1Nz+0e5b5QWs5HSaGMp3hNCJNciut0KuhQo4lhX3or0wTpp+GuhJIHBWyyprLLGTxF3dQspkR7fQC3C8kR+R9Qo5i3tnLz+KPn0KItpk19tKnGKEn3a5B/6JPWoGbcdGK6vMP6tRpZ2bbVzYnqrlRoWwmFPykGwSKpQYxSMmXWC8EpyX6pmnluXBYNC1UyZIliRxpQQTuNWuV9s01F/F+WM5n/73/klOmf44vPtP/TvvzQd+O9//TfISvN//+yPt4PQ71K18q99/df57DJ/V6/r93P9xlMT+lRP9Qem3l0jajQxBF5/9BEPrz+CHJqbWJAzEgJTqAUx3pw0mM0h7ZysB+dZphed01xdSRTmulTKlNBZmKH9YPGdJYZMbCB6EPe871qGdywNJg/OGZEJ5NwSWRQ5FozRkraUCrnWxl+U6V/MFTH06jOvUExS0izHXLHeYptWrGZYg6xELYpXH608vEps/Jah6zHGcDnuSCXx6vgaUxW7YWQ3bAlxZZ6OzMtCiAGXDb/6H38ZouYn/8n3JS3HdQzPXtBttqiaIIbWOFkwTnQOJdHtdqSbZ+y/8TWZ8iqDc7KuX6cF13n8xbZNC1MbQAo31GjhcGJOCTwrNccmwZQHsVYaOwx0u600Be3wIc1RM8fk+PZ/GycTqDNDUrdJnhhjGnhV1r8V1sM9Oa3EdSHPi0DEUW0lKweKNsgmL4mqDF03ilmoJQUZ3xBOzUymADd6AcNbjdvuSMsCOaN9L5pVGY3LBC4ElsdHyrpirBeHeq1yzWgreJpO2FnBSQXhj5YgeB/lYd7vOTzsxVTVDEolJoarS4aX77Mejxw//hjrXfPyaEErpYjWArhPOdJd7BiubjAtIpSKTDNrldcWw7lBj6ugu0pI52mo6QZAk+al6TarHBq0RnuH14YcI8Z5Bm3wY+HN3T1OKUwRtqt1jqKBorDet4OKRhWRDxhvxXUul4r4+NgA+IoaBIGlqKRpFVd9lhAHMRJFcooi5zH6zGANq/wzo1WbknpplkPEbzzj7S3KdWjvRL+bJPRCWSeT6pwpOZCWI8txL2QIrcnLCkph+k5oCVHYrapRNuM0YU8yEkT3jvPUVTY+aN0MdYpwmkR/F/Vv/o/+FC8uf/eY0A/WhQr861/+ezxYx1/63Jd+2z/3r33t17lIkcv03TXH38v6lf/8yHH/6csZTvUn/+wF/4df53w2eaqneqrf3/XOjeiH3/gm+7tXpOURgILGNTZfSgUxECtKrmd9YaoVbxXaGI5TohRhg+6uelxjgs4RjvOK1QrjLX1v5cFUxEiTYsZ2Bm011hoB3iMud28sMWcxF+VEOmkFMxgrjVduhp6TG//kyj01HzlKU6qUwjqZfOWYsVYsKrLWz9QixhJnNPcPka9/dcHi2Q1bvPNcjTu00ryaXmMxXPY7brY3FArH+ci0LKxhwWsrjuWs+OSvvUZPhR//577E9vkztDWSEhSjrMZdi7ms0vzVWgnTxHx3D0pjjJZrlQPrYyQF0eDVU3KTsmdto9GqmWG0GElqbiYMDbY1Ad7juh53ircExMnfmsnTuhKJZsR1YhiqDQvUVotK1TaNa5I7LSaj5fhIXmfyPJOXhPGOkmRiaZynhCCTrOZ2t7Zv4G+B1qdV0rwUspquuU1wncZveskI9z1xv6cqMQ5JdrjokHMuMoFdJjGJadERyvVQgGkTNWSaZw2lZuI6oxSsh1XiKbVi2R85Ph4ppeJ9xzB0VAXD7S03P/4lzLCRKW2/Zfn4Q4ZOdL45Jck/rwVVKpvnzxhubuVz+HbklZZmmFKoaKqqrMcjeZmbxDaTS8V1vaC6DkfRMCtBkmEMylu8NW0aCDmuUCuu73n+4hnz8cC0P7LdDvI5p0TnO7Sx8rkpqFRpTJ1Fe4NSCH/T6rcKjVqFBVuFOVpTwowbuR9SaGas2sxDJ/MZsiZHemZrHdZb8hpwg2e4vUV1nTTvYZXpdlxBG0nQKokaFlJciWmVCXqtlCr3pvYdZY0i5LampWAlwn5CIVPi80HJdW8Nb8agml41rytpWoghvOuvyd+2/lFN6KkUcNWazP/VP/iV3/bP+LN06Ie3wlo/TfTqb6k/8V/dsbnQ/Nv/kz/Nv/x//Mvfm2/yVE/1VN/XeudG9M2HvyGTqypPH91y3WtjXEoDWrFGsCoF8E6TUyXExG60DL3BeoMx8pQ7Tpn9IRJDou8N3hv586lNHq2i70SbmFI+a9qMMxhrzozGWhUhimveGi1NccMi2obzyc2AYrU645vWVSYd3hkK4rxXKNxpYlgyaxA5QMhFGO+18NUvz8wPcLXZ4pxh149463hc9hhluPRbrndXoBWHwyPLurKGFaM0uVZUKVx0l2gUH//KI/biE37mX7hGq5Y0ZJ08xJVkidcUQVsOrz7h8I2vAQLg1sqQ1pXluJJiwHkjjWv7j9IKg0ajpTk86SgrAm9VgnZS1mJ8R7fbYn3PWczYwOPC/mycyJqpaJTvZbpasphljAfrpasowi6tWoGyhDUS9g+k9UhZgjQw3sgaVIHtvTAls6yflXUyqSxNEeCEFOCspayhwd4l+afWTH+5wTqZzIb9Ae2suM1PJrUoXzelRFln0SCWTG56ZlUVOcdmdorQJBtxWQVbVUXz3G0GSs5M9w/MhwmloOs7NjvJtPeXV1x+4cfQ2qAK2K7n5nOf5XXJTK8+YbBNqtLiOHfvfUB/8+L83tG5TXnEkCT0AAkHmN7ck9cZvxnFRGQ1buyhKpbjgRxWafRQZKWwY4/JgTCt4oYvpTWVDiEeWbbbC9ywYZkmVAz4Jq845bnTlC3aKdTgKcvaprQao0yTMIg5rQK6E4c/Q9/W85EcI1UZlFftXsotLldjOkMJEpChvKWskW4z0t/eNj2voS5H+X2SowzarWlpbhCDpFjVdphAG8q6YLpe7vWYqJrGJ62kZUW16S5a0rkA6jzJn9fyu0JpS1WlYa0q/fgPr9O/l6WA7ntgkPr9Xr/0p7dsLkS3P7RtVfpewUqf6qme6vtW7+6aV9LYVF0JMUsyTwPPn1iQKIV1ipggtzz4cdB4Z9t6XUwrIcHxGJnmQE6F3UamUBL9qQTwrWXlnjJtLdkaRaVZ10JdRYeotUIMp4a+axPNInxSrRQh5BbxCEabNk2rhCSZ1lRFarncIIgprRSpZJa1vR6tMAUGr/nk48CHX4tsug2bfmDTj4z9hof1SK6Jq/6Sy2GDcYaH4z3HZWZZFwxgmnN5a0d642VKVxK//h//ffbLA3/kn/95+u1w1mLWIi74sCzsP/oW65vXGGex44CqVXSCIaCojBc70R96SzUOasU3TJJyThzXuULK1JDb2rZHe4vfbnHjpnV98Ha6Wd/q5Wql5khBYfwgjv/SJqPGn/FAnBKBGttzPR4pYcF3HVpVlhAoqq2PjRWe5HE93z+Sud6moE5LE1pzy2xvpAAEz6WMwhovK1dlSNMkDal334YjypRmjiJFQVqVSi0GY8Ucc+Z31nIGnsdloeSE9Z6iFN3FjhIS62EhHGes0XjfY73FeMf25UvGF++16WoFb6g5okvh9nOf49B51jevKCnh+47h9n3csJXGTDX6wElXW07oLEfJmeOrT4jHI27oibPklbvNgALCQRi+1nlAk5XGb0cIK2lZiEsUyULfU0rCDiN+HCilUHTFeXGLW9/L53bSyaKak1+m5WVexHFvreQc6JOUsXFglSavSdbdWvLc07KQQpbpfpUJI1V+B8Sw4vxJr2zJIeK6juH6Rg5TuUgSljLUGsX0pGwzpkXyGlmnIzkGjLdY68TQpk0jAlRJpkCa3hwiCkFp8W2/i2qWgABl32bKl0aNyMuK8y3r/ql+oGXs6Z6TD8NZzV/6i/8U/92nqehTPdXv+3p3ZoiCpWXEKyVmonI+tStxsCuYjhltFduNw1iZZE5TxjbtZwyVwxSZp8AwOOzoCEnMEs5Lw5qyNIAxvAXUr6HIQ6zhK8U0q3BWJkYaMS1ZJ9GW4syWyaokybSEpMY1NdaRi6z5dXvSGGvk+6ZCTBVrpRkrFTqviRm+8eVAXR3jtqfznrEbOcSFlFeu+kt23QZjNA/HB6Z5JoQVRcVoQ8mZTnlGP1JKIeZCypHX+zu+8h98jYnAn/wX/wTjxslKsyrmx0cev/E1dBbEj/HiGF/3R0quTdPpsUNPqQLvZ10wThJtlNairSulobM0WGQK2ju61oRKXnlujnjVUEFVGssiue24HtcNAvYvzV2vJJVIaUPNQfSjricXRdy/gRTlvceIQeN8zzpPwGmyJiYqhUYpI07/xlBVDXskUafSPEhcp0FbJVPh5m7PMcn6VWtylPd7noSGhVoiznlpQrPwRpXVLZ5T3NInSWzOsSWIeUpV+HEgx8S8PxKXBdNoAsY7+ssLtu+9TzdupJH0HUo1GgKgvMfUyuX7n+HYj6xvPmZ4dovtuta0t2ygkznmDLAVrePxk4/J64q1ruWiZ1zfUwtiVqoVay05VxKV4WKLVXKPxyT4KDf0gpVyPbrvBLc6blnu7gl3r+g2W0nTojbNLmKAatc3TgdSCNjeY52VSb1C7otUxRHvnKzMQyAfF+I8S8Suk/V3CRGtdNMnN7SatRI3GwJuMzBc37b0sUqt+WzaqjmjTGPS1kJcZtb9gdISqpSSlb5SCpxt8o5mXvOdXNIWSVrbIUs1WQY5UimNKtFQcjmjUHTjSA4JM3Tf9S/ap/q9l+8UP/dLIxfXv/VxpZXivauBD+9/dE1bT/VUfxDqnRvReUlUwFnTJgStSWzA8dQeYMNo0FoxzUmmkcBmsPS9oRRkCpoLm00nRqUgK0PTMDgn5uipaq3Ma2kaz0JK4k7RtGmWEre4a+v2lCsxprMz3xjRKubYuKNGmtRSWn55y5E/ZcGHmJsbX1bZuhmyKvDh1wKvvpXY9hv6rmM3bMlU5nBk5wZG22MMHJYD0zyxrgslF6wylFyxWHZeGpZQCiVnHuZH7pdHjmHlr/z7f5PqNH/iz/4CRlWOrz4hh6nhOkUbmdZ0zoTXqmKNZGSXCnkNGGtx21FcxTWR16U17qdmB3CiHfWbDbYf2oRRodq0kIbDqVXiTKvSaD+ISQdRVYqT35/X+KfpbTWenCvx4ZU0EUUwSbqtfI3rcBXiukicZBMjKppBqJ6Si4QBoE7OfCXpOKo1sNa7M+UAKlqL6SinkzlFGs6cxWFvXE9J7bU0RJB0is2cYsSUFMNyvu+oYLwlLAthfyTMK9SC7z127Omvrti9eA/bdQ195Frz3jSFSjXzi+CTfN9hn91irKM2J7bWEsdKhZLaar5CmPbMb+4karIqclipSmFcR8mVugSUaT8DFKpWjOOAc1Y4v1bT7Xaiw82Nyeu9RGRZzbTfE+7u8N0gU99c2s+BbvgtuefDMlFqodv4mT4AAQAASURBVLu6wm02MrCNSSbMUabf2nuU95LotMykJcgEUonEpTYc0ulnu+YixiJnUbXQbQf6Z88bz1aumapWsEwptAhWaULTuhKno8SzNrJBRSJs0cLKrTFJIlRKQisIYoqiQetPJIea5HeaUoqqIedmhsoVbSym9/Ian0ai71zHx0z8lBOVvvDTPbcv3T/0z3eD43/9L/0R/uL/7T/7VL/fUz3VU31/650bUd1iE1Et1rONJU9UH4dmWjKPR4lfVEDfaXYbz9BbcpGVvjYKY+2ZG4qquPYgrlWMQ7INbikrStF3ouXKp8x4FM4ZbIOLt9kGKRdyrrRBZuNnthSZ9jCJ8RQzKUlLtdYWzlMIMbf5GlCKNN3aUKjs7yNf/rUZr3qGvmc3bkErjuGAUzBYj7OKJSzMy0yMgZSiRBeWgkazdSMGMU2lGHlcj3xyvGeKK4FKepz4W//Br+By5nM/tqFzCtM5UojN0Q3OdZIP3rLRaU5gXSq27zHjiG7pS2XOlExb8yqZijpLt9tSUiLMR2w3CEi/TZHF8SyTxBwDxRjcuMEgrviqBYMk00olhqc2wcwV0vFIjgtG0RKq2uq2OdaVAr/boZxjvX9AaYfWVhq2JsGQ6W2bhjWbdk2JqpTA1F0DoTeXvSCZZJVbq3A2i+hDBF9kHUppso4yIdfNrNUadGWt4JzCIlNUVKMLKOKyiuNbCQ1inTPD0LN9/ozh9jnWD61PFhqBapPi8/XUkrOepzsIM1o1jWOuMh00Rpr1nM9NWzjsWe/vxGFfBbqvjcG6jlIzJSVxn1fROarO0bf1t2gws7x+JZPiWgvGmHPwwfHxCGFmvNjKFLnWpl1V5w1ESZmck8gSNhe4rpPrW9Jb059umCtjKGElHSbivJBTlUl5FX5nPUkxaLB851sYQ8ZfX+J3u5YYJT93J3xRiQuyQpfJdY4rqUH7lfdnNq3pPDVlSjsMaesoZNKyko5LSyMzqJrBNv1tkkOWau8j5SxNaAFVBXsl1AppaJ/q3eqr/2Blf5c/ta+32Wk2O/07//vO8ke/eMPf/PKbT+17PtVTPdX3t949a14p4YUiekp1ci8XyKkQ18ySKjHLCvhi49htHc7qpsGUZkhBA2TLat0700wlknqUW967bpGgKIipSlRolsmpsQZjxf2NzM2IMROCSABOTebojESFruKs7738vdKiP6VZ5dwkU6voUwFr7RmIn5bC1389kibLduzZDhuctUxhQtfC6MSsFHNkWiYxJ8W1YbDFrT6aDoOYplJOHNaJ19MdhzCz5Ewsma0dONxN/Jf/0a+y6X+C9z5zRTqKBlQbK4eB1qjVKnnnKIXRRqY3J3NRjO3PVZkslkK1Bjf22K4TOL33xEVg8s4KL1IYjZkcI3GNxHluXX7FbLfI/2kzyJzOjWCtwkINx72k/ljTJooVzclB2ybP1omkuCiMdrKS11Dbmr82zqOkJbVGtE1Kz5GXujm2laK2SNQSVpnkaohzS0lq6+6SgW9D8NSUZfKnNUVXcgqkuLTEnRYdmQtaOwH6F0+lsOwn7KDZvXjJePNMGlxjZDJcCyUniS+FBqL31JjI8yOE+bxarm1KqrSixNBW3ZqSE+vjPevDI+WUAlQlktRYJ9O+Kq9RMGUG13VCTgiCSCJbVNdRUiTPs1x3ralWNhLr4UCNEd/51qxqoGljWwLV22Qp6LaC8cqhgfNLPd9Xxjn5rFMmL0u77iJpKTnLl1ZarrfSIqVoDXLJ0F9s6S4uz2v32mQS2mhqEb0nRqQo4bgnp9RibzuRTlTVvn4iL+GcOma6jjwvjRpmwEg61Wkdn9dVtKFKJsDCXhUJiVKCvDKDB0RTraz/vfxufarvsjY7zU/+wvDbTkNPdbvr+R//uZ/l//L//jX+6j/45Pv46p7qqZ7q06p3bkRrBel7NLltqnIz+eQsU5TOgrWGobOMvSTRhNRWfsjDUyMsQWEHSppLjBlj2oOlTSRrEfxTqW1tbxUahVH63EyiBPNTsjwcTRvaxlSZl0jnW0pMEQbpKU/aOt2SeJQkPjXWqTZy8rb2lKiUSKXw4dcKb74FnfNshpGh61nTAjUzuo5NPwJwnGfmsDCHBVMrSllU1fTGS153mwpO65HX0x2Py5G1VA5xwWGopmIGuH5/wHtFKQXjHEZrQWPFQNGFUqSJskbLdNCcHu5ZvCO6aQ+bo1R3Htt32L5rBi3AGFy/kebluMcOI9RCmCaWxwMlZWkmFNQcgcpweSv6uyqNBVqTSyavMzXFhidtk1elzitZbUzLM6+kNVBCpLTGv9SMbqguZYCiSQ1Gro2YktzQoe22QdBNkxnI1LHESI2yps61SsNUJNGHxo2VaawILEShoNt9l4BCWgNpSShVW7PSmu2UUEbMTzmsdNstV9e3jDfXgtZqdINaJeOcFIUe4Kwgq+YjddoLFxaaGamt4k8mmSZByCGw3N+zPj5KUxkTKPD9IOv4JNedNmFXncdtRoxSlHUlryvaW7Sz54lwzUlW1sYQQyROE7VkCUtQMmXENFc5MrUup6jNNcrPHerMP605oxpGQFtpKkvJxHlhPc4oJZ/hKUq2toOL0gZjrUxfU0L3nu3NM8mtlytNTYJ9Ark30Va+VlwlQep08LFiDtNaiAhpCZR1bUNohTKOGAKqgh+GJrtw7bsUSozt3hYkQy2yATAt8lYZg+ocNBObyBmenNnf7xo2mp/6xYGbF79zE3qq965G/tRPvXhqRJ/qqX6f1rtPRHXLjS9vc8OtVlijCDWTshiFdoMT00yp5xWbag1l4fSgbwbrVM/OdNXI5Cf2p+j+wGlpnKxW6AauP+nZcpZox5PuK7VJ68XOEaNMQrdbL0gnJRM2lJHXhpiXcmpu+ZYClYs0LCkVpjmxHODD38joqtmNGy43W9YUKDXTu47Bi3v51IBO64IqGaMdVIXXFnuKDayKNS18cnzDm3lPKpUpBwyCJqp94eKznve+uAFdyQW8tWeMTGnJL84anHeYvheXfJTMdU5r7FJpjB5xFHf9ObtbaYNykp5TUhRdXVyFSxki892jNIvNMe46T02V5eEBbSzO99LEKENaFmoOEnNpFbVISlBtcau16X6VlkYmHRfSsp6jP/VZsyeNtZhUUsM2Kdw4NEOLFl2sqgLO15J3X6s03BhFWlZyWM9NgzArZVpa22GoKtVMSEpiRVM6m35qkRStnDPaSKpQDivrYcVf7PCbLcP1LbbvpUnyw+kmpqaVElZMP0Anueb58EBdDucGiYKs4nVrjlVj2ZZIyZk1VB5e3VNXMXIZbXD9gLKGuC6omoXBacAMI912g24moJIL2lqM86LTTQlVJepUWSPos+MkvM6+Q9WTxKa09CNz/hyUkeAEYy3amCajSZJQZcWYpp1FGcmiz8tMXBa5B5QmTGLO086/Dbiw8udryZjOMdze4IaRk3yhliLGrZNOuV2vnALr4ZGc89mgRlvzVwUlBPI0o1Bob1HeEZeVGjNWt+CGk5GuFJFvZJkkq2Zwk+vkKLmQUsZ5h/JOpB1K7jvT/aOboaf6dMt36p2a0FP9kS/e8E///Pv8h7/yre/hq3qqp3qq70V9B1nzMqkcOk3XCyA9pMrhGKkVxsHivCHGchb/C7eytmZEYVsTuqwJ7wxaKZxvetHSdKGq4qxqjZNMM7V6O5TIWQxL0nIq4YQiS+OcFG8eVsbBNhOSxHRqBdY0tyya3HRuy5qkAW3r/lIKlMIcCkuoWK25+2ZhPRa2mw1X2wtSicQS6G1Hbzuc1oQYmVdpRMkJpz2lKEbjcacJFoqYA58c7/j4+ECpMDU6gLWWow+8sUdqylzd9Thvsd5jnMENfTMeBbyR9CPtHNrbtuYFikz+aO5g1Xv82EtCjjIyGbMypT6t4KnyWZVcmF+/IoVEWgIpZXGV54S3o7jsUSwP93B9jem2xOORmoKkaNVCLvyWhgKjRGtnDHkNxMNRjFalTSWbqQaUXPs2Iawlo5ymu9xh+14a8LA2zXAzmpzc5TlTSyLOs0Dqq0zstZOJVs21TQYbqku3bPQszZsqolM+JYTVKhGopvOYsSMfC3EfuLy4or+8POshlfOix4yBGlf5vq5DdQNFW9LdR+gSBVxfSks6kmmd5Jln0VXmlVIVxsu9ZK+fcfjm1+lNxQ+DmJpqQchYQgTQ41aaUCXmtFrB9J1MuZsDXHSxFuU61nUlzRPWCQge5HMyzp4nxSUmrHcoqxGBtcGMG7Qx5FkOD7qttpW17fNKrMeJvEokprGOtEr8p2lNqIJmfGrSirFjuLlp0/cskoSUz9nxqk0kS1jJ00RcJ1LM7Ro0KUqTD+SURA/athhFa2mWkYmzciJ3oE14T+cBZUWukZco5kvXEZeV0PiyVm84sVxLTBKPap8a0e9ndYO45L+Tut31fHD9nf2dp3qqp/rhqHduRC+2Fu8N1glfcFlhaciUceMEIF/BWWksYnPUmrbmPiGScsz0nW3ISXFNK6NQpWCtrFuXUHD/f/p0YW5WUqznKVNMmRQVQ2fY7ARgvm16NGrCd0ZA985ijCanQqqJlDKpFIwV0xO1iv6tFqYlk3Nl6DXH14o3Hxacczy/uiVTmMLMxg/0tqMzjhgj0zJzWGZqzljEQHVqUksuaGVJOXE3PfDh/g1zEsj3WiJ95/jQHlhshFRZXyWZeBrDdtuzvdwS5oUaM11bw+v2YMzLKtQCStPdykTJjh6/2Z4NIqbrUL5rE7BV8usR93KYV8Lj/ozYySnJJKxzdEPfVqIK66WJXx4esH1ElXrmMKpmRqJJLWoRmkItmXWaiY8HyAVlHbZzjT0rsgoFpHkBJQlQenCScW+laVO1tPeIsB7b+y05CyJoWagpoht3sxagIPrKnM7NLtpQVSXWdDYRaWj4qHqenIYQ6X1rPJTh2Y/9GMPltWCNFKAt5CQyiJxkOtp5lBtIqZIfvyFwAutlspcClAbJjxI9iXUQV6q22HEDy4ShcPP8ipITeS/T51qkUYwhyMFj2DCMAyolYpSkLeUd6uT2dgalnTR3/UhYJtI8Y7sOawzaKOF9phYfqlrjPgi6yVgtuKO2zMjrQgoB7bz8WefEhBYDYZ4Jh0WSrrQmzgsxCEKrAM2OLut4Cq7zDJc7wVYBylhp5EsG151fC2sgTwfW+di2KkaMTDn8FkpHKbJpUVZTtSaFiLVeJM2pTcG1hDWQ5X6pNFNdTsR5pesEJRZDwihNvx1bZGmUw4URvWg8HL6T36k/svXVv7/w4de+uxQqY+Ef/6/s8N3vbFD6nerP//HP8/U3R/7yr374Xb2Gp3qqp/r+1ru75pU6TyYf95nlGCXj3GhKlShPYxQ5K2Js+fAVQpI1uxEvhGTIZ1oSk6xXS6nUejIPyeo/BDEOGSNTTdsaV60UMcvD2RhFafq2kitrTGw2nnmJjGPHsqYzbiqFpj9TwjNdQxYoO6CqMEjXJeOMYugUOWm++ZuZlCof3D7DaMXdcs/YbRjcgDdiyIgxUnNm53es84FUCp3tcFU1LrlizYH9suebj695DIJ0whYml/nQTmhXMUrhrOHlhcebxOM8s59XxrsD4zDItMZ7YTVWKDGinTlP8pR1GFWxmxG/vYAYxCblvIDjwyqxiClTYxY95RJJh0m0gSmdTSrWWLy3onu0DmU8BUWdj7h+kCYRcdWfjGtoTa1aGlOxtLPuj4TDQokBVYvwXSVU6LcYqQTAA6Zz+M0ApVLD2sxDYjzTXqQOJUZKTsR1kWz1KpM67QXoXpu2VVBIsobV3okOs0Rq0ejWlIr5TkHJdJsBpWCdF5GIOMezz78U9miKEgNpT8EAci8p24HzKN8L0ujuI7R3bQ3dOEzaopzksZecUL6TBkw73PaCugrwXymN7zre+8JneXi1YX3zmt5pkRugsLtLxosdeZ0l4QgljWczhSl1MrJl3OUF08OB8OYOY+WgJYQKA+Q2peTsDC9U4XE6L4aoNuWscP65VNagSm4ItUCcA7q+XZWXguC9muNeAW67kch779jcXp8ni2KMq5QQUN0gk1alyIsA6mNM1NriV5t5XfkOqBLzKV9ETHDGUFLCGGnAq5bptiqgOyfa5BiEpoCm1EKcFrrNeNbiaq1kYtz3ok8tQiqwQ0eeZ9Zl/b3+fv2RqpxoxsDfYyn45f/GZUve+85r8Jbeme/iBTzVUz3VD6K+I41oLIr9Q2hZ7OJI11oiMZWCmFoKuRKYdqmVWqDrTGti1dm8pJF1eUyS8931guQRfZcm5cKyJIyRTHtjDBVYl8g4GnYvdqRUeXMvMYyPx4g1mv0x4p1lmmObsLbtnG5pPEpy7K1rzu5SxHWfKn3fkn5y4eOvZ+7fBJ5dPMP3jtfLHdYaRjfitDQ8S1iJKeF0R1gXQgzy75Vg1lMRbex+PfKtx9e8mg+sORFtYe8WUl8ZnRiwnu06vvhiy653bDrLdmsJh5m03ZKco98OaKPFtFJAWdWQTgrlHK5zMjVzHnJG+b79O0uJgZpEQkHJpDUQ1yCYG1NkTVkqJSf6sZcJqmrNX6nSDDktLMlOcEUlxRMZklIFhK6NAWspIbLcP1BCxhiwppMmoBTyEtpnqcghytrVGVxn8X1PTTKdpsia3vQjuu+opZCXhVoTaV5Ja2vGjMZ2vjnJxeCDUo0TKp95DIJgMt5RaxYeaDN3WWOkCek60irJQf3FBcPFDcZ18g7PesYszXFFnNjOgxvIy0w93LWITaRxVS07vhQo8TyNKyGihq1Ebc4HSlrBWlmJa422hqv3XrD3lvvf/A2Mgt3LW6x2lKVNIJ1rlAGJ0ZSGWwxY7uqGh48+pB4OsoWop4d6leuTMyhBfeGMNI3WSozp4SDrb2shZ/K8iNGo68FK5ntZA2FZUVWhmpwlt3SokjOmgDGmaXvBDgP91TVulANGiRFypcYJ3Y3Uk2GoMT1TWEkhULMY9ZSRa6K0koNUEaIBtENoqVjXy8/1JPrQisD4JTKWRgCQHPq8rjjnQUPMkuZEiZjOyUa+tFQp78nrQlwDVj01N9+PasqL76r+4p/7WT55XPgbv/n603lRT/VUT/U9r3d3zaM5PMpkwHWCgpEpqWgMqwLvZdJYikybFOC9aZGZlZQzrmGXcq3oqug6S4yFeQqYU6xnyhyPke3GYb0YU5a1oFTh+YsB7y0xZg7HCKUQo2jAchXQvdWq4Z1OrvqWAKUUxrY1f2pB5sj3c064pVVDnDSvvhnY+R27zcj9cg8arrsrBmOAwhJXYgqoYkglsoSF3g04bSSNJsuUdQoLHx/u+Xh6ZKmJpSsc+kTXw8ZqnDZ8/tnIz3zumt4ZnDPc3mw4zkncvbVie0EWpRBbE93SahoSy3sra9WGDlKnlWiOlGWRFXUztZQcG1pHE48H7LhBV0Oa5rdoJ9VW2UWmbP1ug2ur/pPB6XQ9VWNgKt+hfU/YP7Le3TddqgHtW256RhdNTW3ShqLWQiXTDSN+GFuUq0Zp0VNqI9OyGiNxmVBVkaI0lfq0ztVvp3InjahyzfmuKutRCABKaXJz6qsqU7uwLFQN+mKDKpkUEuPNjST8tOZDdR20hCbpghDIuXVgPOn4SF0PMpEsmTPsXwmCqJYkMHWtAY3Z7NDOQJhbEz6IqaatuEFWzhe3N8RpgjDhjAclUgzjvUgBVONbagXKgnco63n41jeJD3ts17eJc20UgXa9a8X6Dm1FImE6yaevMYp2U2nyIjxV43pM7zHeklMiLCvxOKPQZ5QYqrYDUpGUL2fQvW88T8twdYUZB8EwVTEdSWMuPE9h10aqsqQQ5LOqGW012slq/AT9z6vIRzhh21JBGydr/sYrLTnK/ZAkf77Npc9cXNt5yJXleKDvR7CVmhRuMzZ0WPs7y0KIEau7p4jP70P5XvFP/LMXfHuYye+llFLsBie4vyfawVM91e+LeudGdH8I8nBF0otMew6VKo5zYzQhJDGtVOF+6vZgTfk0OVXUXNFGJpKlFI5HWSHr9otjPUgSznbrcc3xmwrsNobdxQAo1iWzf1iJSSZaaInlrKWw23lUm9LVIg2qa65grQWynlJGIZGdqhaMUefpXkqKb30lko6Gm93IfXgg1MyL7oZBy0N7CUEa2SyIouN6kPhKFFZJwlOpMMWVT6Z7Pp4fOKjI3GfWvrDtNaMzDM7wYy93/MQHl3gnnNCLXc8SRGt5c2vJZSatG0pbOenGQqzGYjt58NvOo600q6qlEuV1bmB61Rzxa2NBNo1djljrqIvwKu2mF+aiUueHMVbRX15iNyMqRXGXowBxQJNEg6m9B61Y7u4ox6mxQZUYkmpb3TYjFc6htIWwYBz0m0tMP1JKbmYVfTaq1VxkmhskXz21Zlpcz28bT+EcSOOjaqUoQV+FZSFnCROQlX5BWU0OSRKYUkINElsZlsBw+4zts2eCeWrGGWISlFIzdmkvk9CCJh/uUGlFKy1NDA30Do2VmsE6kTygML1QAKQRA3xz4Kvy1j1OhSL618EUGHqqUuR5lonzKV0zCQpM6ACWbD2PX/sadZ1FwtEwVxJjX8gpUUrBdh2691SawW9ZUCjcdgfGkKP8nJuul4l4TqR5Jq4reQ7n8AHBPCH9PoJkO7npS864zcDm+XMxjpVCrU2ra61MP5USnbESPnCc78klNzNba0B7L7iuqkRaQm1Rr0gTqq2s+3MWlmyM0ui2VKzaIojl4BlF1pIL6+GA6zrcZiCvC3rTy/sQ5hQ1JlJMuK5H5TbVfqrvWY07zR//M7uzj+C7rf/lv/CH+conB778yZO296me6vdDvbtG1FhOZMBcqiQYOXPqWwgxs8YMVaaRp2jNWsG0tTjNnRxDoVRxs4ux6C2GSdiRYlqKKZNz5uqqZxwsYS0cp0RYUvObiDFC0pPAjx6qAPa1bQ9Hmv4sZ1KWhxKq6U7d6XuLhEAB968iDx8lerdhKhOJxLPNDVvfY5RmXlZCTJLzXWAKMzVXeuuwyqLQTGFiDoG7Zc8n655HGzi4RLdR3I49zmguR8dPfHDBi+sNOVac1Ww2HfMsGKab65GwJlJ6pPMeay3OKmmOvKPrPc5bQIsbW5u221KUEBoBQNaxOSRp6ErBWCcNDaIzraViO/8WfF8k8tKOA91uK5OzGCkt0aaqxhVNTQxmDDkn8t0iHMhaoWaUEmQOpwhPbd5Gd2pw2xE3DmfjkkKdtYIKESPnpgct69KwUA0vBLQuVKa7p2SgKg1a0YplmhqXUlHahFe1w4lxlm7oiOtKN/ZUZdm995Jht2sYJyua1yLaWbIkUmnfo2xD/Uz3ktxkjKyWK63JitJ0aSvvmWbysT2KQg2LdKnWtyYuv13h10JJiTgdiPsD2lsokBZZkavWdNbU7v+GXEqlMn/zG9iS0cMg3M/StLq5krNgimhs11rFWZ+WFd1ZjPUidWgweJynBgkJyOtCTjItPiO2Gl6pND2wQmF7WaPXVPDbLeOL5+Lmz6eAAll5V9q1tDsUVdzxhwfyt0/Du05MWK2pLDlRctsAWInLxRisEZxZjqsYt1rAQ00RqkTK5lwoJctnpzXrcY/zDtd1pHURbuhpWlvFdFdaiIAGSi2U+uklBf1BrWUqTIff23X6hT+5wbpPd+z885+75htvjsT8NBV9qqf6Ya93bkS90zJFAoHP28bnbs1mKRVvG36lYXF0i9DUVQkgukiknrei0wypYJTGOUOlNYTt+6WUybFweSku3sd9JKVCTBVtDbm0BxPgncU5TW6rR+ckBUrim9pEKMsDVCEyMNMy52uVphrZEPLmW5kSLbGT9/psvOaq21IpLOtKipkUAykXQlhJKdEbWd8pNI/zgYdlZiqJb8U7XpuJ1SduLx3Pdz2dNVzvOj7/cstu6FljYRw1/eA5TAGrNeOmYzoGUKJbfXP3ilJgu9kyXO7wQ4ftuhbzqdsUqE2AMjTLsjTfa6SsQSaNzgNKEoBKRvUenavA1Ws7HDiH226wnafmJOaVtvZGyddWAFoQPjlGcShXaZIlT1wy68Vo0gD3VpiWWmuJIvVOEneK5KSfNLwg90wOK3Gd5bXF1LSEDQfmWqPYXrc1LZmoJEJYyDGSm0lOG7knjTOoIrSG0sD6buhxFxd0m0u6zUYaxDYVrrWe9aDKe3Tfo2xHDivp8CAufd2y0ZXIAGpuDE/FOT4WazHdKC3YKrxSjJGtNohms03jc4isD3ekacJ4L875KnGe2grEXT4rztzPuC7E/R4DmM3YJqWFmt9qQqvSsl4uBWw7uISEcjL1LE3TqoxoRkXVkJs7fpHLosXEg5ZJ5llKoCRiUybYGbvdMNzeoJ2s/k/SipqLTGGtkQMHinR8ZH28o6jSvpZuE2fb7mHkd06OLXWpNoybwphmpqtFnPFUufezNEPSPKrWhMq1yynit1tUycR1wXgn8aAtrYqcqVVhx61MWUM8M5Of6nevu08SH34tfsd/79n7FvcpN6EAf+Gf+Rl6Z/h3/+qXn/IInuqpfsjrO9CIivEGFNoqSlvP5+aA9l4eBsIRbVPSIIlJxuqmLyznRvPk8tUatNWsS4TGHHVWM08RXWGaM3XJaKDzBmfFpa9lQ4w7Qe5LoZTamOGakmTKKs83LdK0IgYqNDityUUa29PrefNJ5OGVQPerhtvxipvhAk1lWSM5FtYg6941RkJcccph2hu+nw48LgceCbziwGu/R/eVz1/1PNv2jJ3l5c2G92435CTZ9hcXHVTN3f1C5w3D6FmWhNZgvWW/X5srfWaJjkFdCAgeafyENSkNdfMZk9dIXFdKA91rLfGKoKgxgTVY50TLGxdxRhuBnbtxwPgOSianNq1TnJsn2kS51EyOmRLyt+WD62/fTsu9onWbQiuMc1jrUNaeXfpKqzYJl+lhzZkcBA9UYkDEHc1YRhXZQHNHgzRItVRyDqzTkXUKmDZ911amklppVM1CWaiVMC8o69g8f0m3u8S0KFeZ4srBRUxGEu+o+xGMIy8TZT6iKE3zSHOsa0qO0tyfpAIFtJNm8mS8kmmrfmvGagilqpQkK929ITbDkEyK5d41Z+t4+7u0ZnqZyNOEpmK6vmlAC9bo8yQSa0DJ9XNjR7fdSoOtG9g/BFzfoYw9M1cp7bC1BMA0HJVoXEuIrQkVooUcbio1J9w40j+7lftHyQ9oics5wEC1NKyaJY1rfbwj5yQHCyUoJmWbMahUILfpbz0JPVEYYcomaXpU5+W9pChc1tNnoAThZXuPMoZ4kObeDp54nNBOeLEnOUtNkVKRA4AV06Iw5gQ79lSffr34jOMn//CA779Lh9LvUP/qn/lJ/r2//tWzQfapnuqpfjjrnRvREIVV6Z1hDZlcSosAFBB9zAVDxRjBN1Uq3huM1qQkukzToj1lXVawVmOdZm2g8xgLXafxznBx0ZOa8/7U2ZTafB3IM1lp3XiV0oQqrRrDWv68bVDrlBooHXXmEOZczlzCAtzfRb72myspObpBcTVccDteY6gs69qy7FdSTsSYmcOMqQLUV2ge5omH9ci9OnJnj0x25fnW8ZmbkW3v6DvHy2c7LrY96xyIMfPs2ZY5FO5eH9lsPRe7nmkKOC960cPjgnOG3eXA8ThjbWZzMeLTiO2Eu3nq/LQRA05cA2lZifOKaYYhiVYs1Np0mE1/WWMi5ywP6HHAjb1MjBuj8vTwxzQHeItUTaes7ta0SQP2dsVeS24PeIlxxeizbrGCcF5ak3VOSlKyCk/rQloWaXga0UBpmvFEms+TjtA4CxTiPJFiIa6RHATGb4xEWJYQMdZgnaYWRVhXXN+zffEew+UVoFqTXamhYYsKKIrobvuRUhV5f4dKQZowxMGtVIOpJ8EDnaQnaIcdRvHC1SrreGhNaOslS5SGSSvSsrDev6GE8G063XYf10pNWSZ3p8k1MD8+onLCWgu4lhwk7NQYhZupjRjPSq10uw1uGNrX4HxI88MgrzvnpqkspLgS5yAYrSoKXJnOivP/xPxUxsifKQl/sWG4fYZuBw2UoayT8E2NlTAFoMaVkgLr/v6ca59jxvROXPy1QGxMWi2NdwlRDhSuk2vfokDrCXKP6GvP8p9aSSFgvXB3S04SC+oceZ5RClzftYO1CAZSDCjlziEEylp0qdKEPg1Evyf1/H1HP35vmtBT/c/+6z/H//7f+9vf0+/xVE/1VN9dvXMjWkrFWVm7lyyNpujFpDGwWrMGae6GFvMZQ+YQItZqht5RK4SQ0KoybjpyqRyOASpc7DyVxLIK71G1+FBVKikjPMQ2lTVGS0whcAJzWycmiRTrWbdWUqWSGqeU9t9F8uWryA2MghAKH38zsH8s7DaW3bDlZnOF1YppnkihENaFOQZqrszrRCkZrz2qGh6mmdfpgVfmkdnP9IPiZ59t+cKLHabFVz5/tsUYw+PDjFKVF892LKHw+tWBq8uBvnfsDwtd51BKsX+c2V30dJ3j8WHBWk3n4Xi4w19c0qmNTELbdKqUyjotpCWijcYPm2aMKS2nvGB6mfbkEKlJzB22dy1KU6Y+pcHOa1uTKyWaT9ASQBAjeZHseWVsa/p1Mw+9nZpTKyWJ+9mNo0w8U0tdaiijEwBfmt/QAOpCZtBGixZQN/Aoou/V2ohzXItBaDkcySHIpLRK4lZFE0/Q91zw3lG8I9fM7vaG7YuXuH4jU1Ar6/UaxbRV28pZGY/uN8QYYT2I8UjL1L+26yGnnmZkalN5ZTtxxiPZ7GhpvpVpJpp8Qm4ZqIp4fGS+u5MMdm2oStbO2hppLKu40fO6iFPeOsLxCDFinJUGsR3sai2UhjiyzqOdI8WIHXvcOMqKvDnkldYSEdsy1Ut8OwkNkxiYVENi2d6jnSGtsU1CDSCNfgX6yy399ZVoSHNGeS3a2nWRa3Y2n0VKFgJCqVUm0DlJslPvRXaQq3wNJO6VIveR7cS4VEoRfNWJ06qUmOZaE15qJeWCHYZ24IwY66F31CQSFYUETRjnJLo4BKha4l+DpFNhTgldbe3zVJ9qffBFz82Ld378/J7rl3/2vadG9Kme6oe83l0jajUpZnFDK6gJgbf3hhQz05oZRot3hnlOTFMk5cJm49huPCEWUsgMXqOd4fEQUFXy6UuW3/XbrSdEebjVFs/ivMXk2mD5pcWAngxN5fwsKkUSkUqu54bXW4XRgjQqRR5QNGNLzoUYZT36cJ/4xtcD3veM/cDNeEmnLeuyENZIDJF5XSkFljizpoDDEnJhTkde6XvejI9km7gaPD/9uQs+/94FKVRSqtw+G+mc4ZPXE11nuLoaeXhYORwXXtxuqErz+DizaWardV65vtlgrGH/MNN3ls2mkyZ2ivTbV/iup1MapSopJuIyg1LYoUNX3aalhZIqqjQcku/EMNMmRn7T44aNNJ5IY6Bda+IR93AFYUyuq0grchYtHe0mKKItrUrJClwpSbtRYLzFDb1kfedyznkHLYYn69BIo5FWMfFo55uON1NyaGtsmZpqpRvKysoq+3Bs01dFXAKpNdFhjVStcN5BaZpm4OLFCy5evof2HSd6gHQr6a0zulbBM3UjcZmpy7G9ZMVpOK9Um0SX1AxZVSaxwwY3bhvfU6Z6KIWyXpruUpo5Rv7++nDH8ubVWc6QS8X4Du0kValEifCsjYtalGK5v8cohe+HZm6Kcnhob8WcMucRpq/fNmbpuoiuN0ZhkdrWwNba0qcqKYkmVNKS5GAncb1NH55k0o0x1CyHlf5iy3BzLeeLXAR3RaGuR1m3uxYCUEU/m+ZJNMvaUmoQiY/37TTSNLbl9EOdBbQwjKh2TVSVBC0JT0uNjysXMKdIQdFd7IS0oDTG9w2llcTdP3SUNcmmwDnW4xGqNO41Rjms5ixNaKegmqeJ6KdcLz/r+Ik/1OP893YaCvLR/Rv/6p/kX/9Lf+V7/r2e6qme6vdW79yIxphxTtbsIUgcpzWK+RCxTnN91ZNK5c3rmeMcGXrH89sR6zSHKaGp9IMhZYhrwlvQyrC78Lx6Nbd1v0w3ndVUo5pfQZqkcMqwL8jEQv4VCsFDxSwuYoWsi50/4WtUy7KXBtQoge3nVLBGkYriN35toUTN7nrDTb9ltJ6wLkzzTE5FXNI5EVLksBwxGA5xAQvH7cQ6LmyN4nLY8FOfu+LF7YZ5KdSSePlig3OGN3czw2C5vBh4fbcyTTMfvNyRqubhfubyoicXCCFyfb0hF3h4mNluPN4ZHu6PaGvZXQ588s0PSRGuX7xHSbK6dF2H8V4iClORqadSbWrmRCdYCmmewRiGm+u22m5GId9JUxkrSjWUUItJiWtohqTTFEqfDRy1JGlYtUY3sDxG0213GG9bnrvoVFFK3NsGjB+o2pIOj4TDUZJ9lD5tpZvRRaba1IJCnQ086zyz7g+yGle0DHsarzbTd14A5Vkm4MoZdi9esL19Ju56Y5rpp4rhpeQ2BWvr364nHveQAtoa6kkrqxEJQc1N9ylNci4Vs73EjVtx0pdEVd/mkGiNkmh95Z5d7u5Y3ryRRlkbUpWGmpLJS2twmxFKaShGM93dM7SpNkCOhZIKKWasFbOX3+6I00xOGTsOmK6nxNgavzbtbgSBtw5zyClKE2r0+eAAFdNiZUtomLUWo1pRjDfX9NdXMr1MEdWPom9dZuo6y1o7rkJAKJU0HYjzjDpNGUvBXW6a2x3R5LaTZVVQlcZtx/ZzL5IJbSVSlZRkuHxy1tdKRuOGEdaVWrJA+1FiXGpSijxHWbt3nnV/IM8L/cWFJIKh2vZAmnOVC7rr3upWn+q3rbtXib/3X0zv9GdvXlh+9h8bMfb7090rpfjg5imD/qme6oe53n03UiEFmVYOgyWGzLIkLi57vDMcj5H7x5llLdxcD2xHi9Kaw1GMNynDOiUut46u81QU+0MiJXjxQh5GcZVUlIIit2lljhmlKt5ZiQ1VwhuNLd0pp8ISpBmwBjpnKQiXtNbWpCZxJVtkhV1KwTmDsYpPvr7y8avI5XbDRTew9T0pBKZ5JsVICJH7+QEyPAZpTEMJRL/Qv4BuA6NyXG97fubHbrjY9nzyWhqB589GnDXcv5npOsPF1cgnnxxZ18QXP39NKZq7Tx65vh6JsbJMK9e3G1KqLEvk5nokhcybVweub3f43vFwd8B3lhwe+fjLK53bsL25PKfW1CCoG+W1rERRbcJWiMuC7Tu63e5s8BKPkZH0pNQQPQ2Pk1IhLkesG84TvVqRJrfpQE8mmpoi2Wj8OOCGHutdY7nmZnIq1CxNqq7SLMflnrxMaNMMZzEJXSFl8rrKBt/IJFQ7R6ma+bAnTRM1g7IiJTjxYtEK56w45VUFVbBDz8UHHzBsdw3+rs8ubGlwpNlWrkdbT9WWPD2iGteUUlpzZJusQAxVNQscvyiFubzG9QOqJPFrrQ26bh3nTNMiB6oaE+vDG9K8iu4zCvLKOkuOScIXjOhrMRbb9RSlCY/3dL0giChZJLvWSoCDKzjvMV7W9jEmuqHH9qN836YBJeeGYUMg9yVRULKOn2fRxFZp7E+NszYyGde2yQCAGiP95QXD7S2cmlDv5XrESJknWZ3nJLSAXInLRFpm0XI385QdxjN3VPS5+Yz3yiFjOpF01JzlPTQTV00S9kDDSeVGr3DeU5eFajR2GMV0FBN1iZjBk9eWCFUycZpY9hPb6ytp1I0Gq6E6afQrEhWnW3DAU/2OJWbBd/uz2vB9a0JP1VnN//Uv/JP8D//N/8/39fs+1VM91bvVdzQR9d5glOJ4DHSd4cWLDSFWPnk1cZwkWvPz78sUNMRCWCO5QkqVzmm2256SCo/7REyVEJPgjzqH1YKQqUqBaqzDSptgqbemhFqpuWKbE39eBNR9seuFbYjkRJdc0brpGos4iU/pOFob+t7y8BD463/zniOFF96x8z26auZ1IoVICIHH9cCyrqylcD8f6ayjXgUuXsLQG4wyPLsa+ckfv0Erw6vXE7VWnj8bUVXx6pMD/ejZXY7c3y9YrXj+mUumJbN/PHJ9PbIEkQk8e3nBskTCmri46FmXxDIFnr+8JpfC61ePDGOH7zz7hz1azzjXUWJGuU7IBKWZQ1qWO0piE2sp+M2I32xlylck6rE2hqWub9FZGEOYZtJxkpVlSVTKOcNdstZFr1m1lRW9trjdSLfZSTzislBLkQmbsbKaRaG0mF7CcU+ajzjfNdezYI9qihJ6oDRaFZR3GO/JKTK/eRQwuTEYr1GlkJKgqLQyLcFIoXVFG4e/GNm8fB8/bqSJ1ApaxKRCkoYUClo0akVTpgdUSbJOz0lesxNndq3IGl9p0IWiDHZ7hfWd/NkYRIeotbjVqTJVboizvAaW+9eUsKCdpwThe9YTCisJS9MYMWKZcSSkTHy8p99sJB0rJrRrkZcoTGew1mB8RzwcmA8H+nHE9INMEVN4m8IE0uwJhJRaHHmNhHUSjW1ILa61vnWNY2S6XBvrtxbRhN7egGpRr9pQa2OMrjMn+L9yjloVKezJy0JeY5NvgBk6jBN6AmGhxtQkHYJ5M76XVLWTtrtk+XooaRCD6F1zicR1lj+7rKAMquvByT1Ikia6rGIE08ZSUmSdV3bPX1DWVXio7ZClz6zWTD2RHJ52859KXd0afuFPbr7v31cpiaHunWGJT0zYp3qqH7Z650Z06C3LIsiU29ueYfTs95HXbyaWkNlsHBcbB0rzuBdQesgF7w3bjSfnyjpHnNN0nUa42Z5SRBtXTvo7QFeFqghWSCEPOhQZ+WeZTElihrJW0feDbD8pzdELOQs8u5SCVgp7jv5WDJ1nniN/+1fu+cr9ng+ur3je7eiVZ5onjvPEGlaWsLJfJtaYeLMeKF1h837l5rmVKE+teXaz4YufuQQ0b14fMcDzFxvCkjgeV3aXA8Om5+FhQVG5vBp42K8sS+T2duSwjygFt7db5imQSuHyZsM6BcKauH6+I6yR128ObLY9WlmOjxPdYLDescx7FIZCZbjaoY2nzKs0NM41Dmim22yxXuI2QUwfNaWGCmpYoKYLXPd78howvpPkJGVlfa81kJpjWvSe2ih0J1gg4z0MI3WVLHftveiJ2yqXWijrCtqwrjPEgNUWThzJWlBF0FzaG5TrQWtyiiz7IzUljDVyOEGRQpbmok26ZXVuUJ2lv7xg8+I97LA9vzfhRDYzlZKoT+Ud1XZkNHn/pq2mNbWsMhXUkhZUlabGtaGqNMqP+M2FmLDiCqn9+faahQxwakIlmnR9uBc2Za6UvJ71llSRf6ANpvFW1TCyLpEyH/HeS857kmQobSRWt6SC0uCcJa0rcV3YXN9gtKUaTQ0rIHxTdcJoIW5ztCaHSFwXrO1EH0kRQ1DNrTmrqCpkirRGas10l1v6mxvBcqWE1lZYthVqatQBaEY2RTgeSOsiU08NcV3xdsRYKxPp1MIAlOiCK0o+U6Uoq/y+KSmh+xb3WqoQIFq2fZwXtKqiydUWuxlkdd+iZ7UzzaSoUFiqElP+5vY5qmZiiLRbU3ShuiHOSoGaCYcZ//Kzn9Kv2x/durwx/LE/vfuBff+bbcf/7l/+Jf7nf+n/+wN7DU/1VE/129c7N6LTHNhsHFdXA6VWPn61COOSysXGs9k4rFEcp0iKGd8Zdr0/P2A6ZzCdJ5ciEaFWs6yiWTO24XNqoVRFyoIjEue8PW1EUUYT16ZpywXvNd7ZZiCpYOTvpiTP95OpSVHluQJYawgh8vrNkb/2D17hu47P99dcmJHjNDMtMyGshJTYzxP7sHBkZXhZee+zA1c7D1VhtOH57Yb3Xu5Yl8zr13uGwXH7bMM8JfaHwHbXM+567u9bE3rRczhKk377bMM0ZbrOsrvoeXxcqLVyeTGyzIGSM9tdx3G/EJbIbjegFMRlZtx0VDTTYcH5xDQp7KanL03L6Jw4g5sxy2520oQqBcaJuQgFykjiUKlUrcgxEh+Pwl90llKkISklSj56W1MLszKTS8aPDtf14kBWUGcxf5gTX/LEbq2ScGP6Dd3lNf7igoev/wZhmbHGgpFmV594k1qarXV/EKh6W6WTC6mtxYHGjBRda0qFbjewe/mc/voZWrumtSxwMlqVE6Bco7wD2wldYbpHq9p0mg1dpdQZ31PXWfTH7bWaRiWoLYJUmZMBqDnvSksSqpJxHg97uX5aUzNyDRvFoeSCMgqNJGNp71jnIzUKnqmkSA5RUo+0EYaqksOa0nJPpJTx/dD+mZZ0rbaOl4Qn+SwqAvnPYWncXSNSDK2FTJFa+IAGORZWwmGm5Mjw7Iru9jnCE22T3ypueHJq/12agS2LMSmusoUwp2suRqo0B2AVE1HTf2KNEAO0aZrk1nh7K2atJClbaH3GiKkimw+tNWoY0N5Rjbwm3cu0XcXYEG8JksIPg0hJwip0gpQFtG+FSSubBDGgdc/fZ/eZz333v2l/hEsb+KU/84NrQk/VO8Nnbzd8/fXxB/1Snuqpnurb6p0b0ZcvN/S9JabK/UPkcR9IubLtDeMgyUYlg/OmZbuLzchZ03LkpSE9xX3GVKUpOHNF35o7TmQWq+XvnJz6ackNHyUpTiCSAZRoQktzHjtnMLqS00nfp876vhQTGcV/+iuviRl+/uoZN37LNM8sYSWEQM6Z47rwEI/YS/jS5wfee9nRO8s8y9rx+bMt1zcj0xQ5PC5cXvZcXAzcPyws88rV9Ug/ePaPK5rKMDrmOQKF3UUvUgenGQfPw8OMptJ1jvk4o42mGzqOx0VkCJ0jJzGAubFvTNeI71ukaZlZ9g84Y+i2G2E5KoX1ThKYrG3r5JZT34xHSmuM1uSSSOtKeNyjijpD4svpgwBpopSSr+c8qIpz4oqnInzKNnkTALiSjPZSxAikNW53id9eorXCmIGrL36Jh6/8JnmNLeJPpBdkSEskxsg6B7lnqnBgQSD+xmhySqQo90RcI2634/Lzn2O4ujlTF1TTtnJq0hv7UxlH1Z40L6hwbMY2w9kghBKJQ218USrYnqpkvauVooZFVsbWCGtVvqW441tDm+aJ9Xh8m7ikQHvfAh7euu6dczLFVJoSgwQz9B15WYXv2TBGxgh0H61EN5ui3PPeo7JEieUQKG0iW4GaE1rL59oyBwCDJskU8gScN/p8X7iuk/59FVnG+Pya4dlzaTxjFB2l1m1SK/9fuZ6cjpTG2y3NeSbJTBJogBO5SFmDxIoqsNY1o5jnhIWSD0lCCYwRDXNeV2neyaQQgIwbusZeRaD7WlHWIH//JE5vBjqltPBDQxBOLUret5VDUImNDes0VRm625dsXrwvE++n+m0rxcrdq99dQ/vigx+OQIDP3Gz4X/zzf4j/07//q/z6R/sf9Mt5qqd6qlbv3Ih2vSUV2D9G1iUh8iklyUZGk7JMHUtrADon/MTQ3OmmJeGkXJFUSWEGVq1ko6poK0eZ4imliEHc1roKuzRmSV7SRnKkQdA2JzRTrRLdqShv4wDbVFS+fQVn+et/+xVf+fqRn758yXvdBSEm1hCIKbGEwJoj0S08+5zli1/acHvdk2JhnhLea25vRjbbjsf9yjJHdpcD3mn2jwvLEri52eK84XG/oLXGe2lCrdEYa1nXfGat7vcLzkkwQFgSrrONI7rIRNgKomncDWhjWZYgDY0xgrMCtNas6yNqb6nWsBsFXm68ZMgrdYqsTM001Aw6WhHnhTDNxGkWM4t62xCWUkQqYV3TTYjuz4wdputkglarmIwUQJvWtbVmLWLq0Z3HbS+x3SCfDUI0sP2Wiy/8BPPH3yJPB9o8lLgurPOMUlq0vaWhj2wD43ceaqYUicdEK8bnz7j+whfpL3bUnBq3s7Qm8pTso09uCXFZHx6pcUY7mbrXquSPtvuGFAXRVKFqg/YDppl4as5vJ6Yli+ThxHeqhRxlIhgOB5lMAkZrkTvkJM1SLQJbb7IH5RxhXTFaaAfllI4k+4KzLEEg81CCBAsYZ6RJt2LsUfUkdWjhBFS09lQjWlSU/JzVmJsWRnOK41SmGbqq/BxZr+lubumvrxrjM4jhSQl7tZaM7jp0N0ok7OMbwjwJRcG6xjdtYHithUDQ4nZRihpWYs743SUKc77PSkvrqlUJuWJZJXazSmgDCvx2BNWYoKdJ63GWKWrXUdZVJASteTVtUlxDbGEBIkUQLY9of08HA3txw3D7HFWTHNye6retdS58+e/+zo36536i4yf/cP99fEW/e/3Eexf8137xM/yf/19/9wf9Up7qqZ6q1Ts3ojlV5lmc8jHJatc1hFOMmVSk+XRWojNLlqxxSVKStalpcXrGKLQphCYMFci08D9Pk6TcJnBaIQ0r0qgqpSkltwZNCxYmJZmstu+BktWdc7pFkBaMFbf9r391z9/61Td8prvkve6SOUZSkkz1OURmVoZr+OIXOj7/+Q2b0bPMicNBTBkvXmzYbDz7fSDHwvW1oEHu72as1Ty73VAK3D/MjIM4vZc10nVOGoNaGTaOsGZCSGzGrjEzC/3oSbkSFnGvWwNdJ5KGEDKEFectKWVJRNKilSw5oZRinR/odltM37f4QvXW7Z6a7k+3yZ9SrI970nESk0bTfUocp0ZRUCXLg7o1Nrrz6K7Ddh5jbVsrN/c84q4uwmtHtZWz2WzpLi4xrWGTxkqLC70KI1K/eI/Dt75BOh7JOROWhZKKaP/agUM7j+2cGEmypDmllFDWcPHiJZtnL7B9L42OaZPNKI33qYFGWSqGHFfqsocUW1DCee7LKUZT0nsKVcmBxvQbMXnF0F7/aYKKoJoqkMO5AV8fHkjHg0wEa2uEB4uytul0RTerjEU5Qz4baiQxKy9BHOht2qxOJIBmIpJ7Noh0pU0xBWd2hl+1w5mA26tS0pTmCmVtsH1ZQcvUslKVfJ9aKjlE3OAYb5/jLi9ROQMFTpGyOaGsw/SDfCalEo8HwrqAFdIBIEY405KzokR2ltzuG4Q6YMctdhzbVD21z/tt5nxuWlGUkthRBabrKEEm7qbvwDrKsgAK43sxyrXPJ5csn3NLnzqhu0CmxULmUOAldMONW4ZnLzEaahCJwFN95/XjP9vzhZ/uzqi3H5b6uc9c8YtfuOG//MqbH/RLeaqneiq+k0a0pbessRCzCC61lYed9wanpElMqaAomN4SYyUnyfi2Xr5VaStfpaDrLCGJPs60lWhO8rWtkTXyqZGoquWrI5owMT8WdC34lj/vOnng5VLpvCNEGW91vWNZIo/7lb/za/f44HmxuWSJkZgzMQSmuKA3hReftXz+CyPvv9hQqubwsHKcA75zvPd8S9d7Hh5XcipcXMhJ//5+lijOi555DiyhcHU5UCrEOTCOHaW59/vBM0/yYB0Gx7oErFX43rGETAwFTcU5Rdc7tLbMhxVrBNC+zgHrJLqTNhlTyjRZQmJ++IS4PMd2FpWR1XhLOapVGrKSE2laiYcZcsV4KxOqUqC2CWRLnkEJh9HvxsaUbFzJ08pTGXHElypg9VIpNaOMwV/f4ncX0hyVIoYnmeG2h7uClDDG0F9e8njcE5aZdQkYDFXJgcZ5ixs8WhtyErRQTRnX9WxevKC/uhY3fju8SEKPNIRaa7C+oZQMaf9ADRNaVXG2GytTUk4A09pA9TJxrd2IsVowQrW0qMrTir9NQHPjkKLENLR/JE5TW4tLU2j7TiDxLe2ptKmz7TuqlmQpXStaW/IaSfMqSor2upQChSQdVecx44Z1nilhoRvGZhZKMp01uq3mi6zMtRJyQlXSqCvOjF2UalPAAljJD4gRrRX91RVus4UYZIptXfseEW2csGdbYlY6PBAf76TR1S2Ri4LuHKpwNgApVNPKQlojphvwm23TcedminNvv0YpIhkoEOaFvAbc0MtU82Re00aoC8YIwaDWhsuCmkW6kZYZZw1WaQq16ZidaFhBsuljwl1eMTx7Ifi32KQXT67531N98GMerX/4rt0XX+z4yfcvnhrRp3qqH5J650a0VtgfImuUyVrnFJvRSTMVKnlNqJroe0Oslvt9wqrCdnSUKqtAa2Ttm4o0mqVK1rttDtiTiabU2hzSWiZC6uRNkSlGTJUMaFVbFKRMSGMoWFsY+o55CXirsM7y+LgSQuTXv/rIm08iO7NhDYFjKYSUmMvM9XuGn/iJLZ/9zIary4GwVh4fZ9YlMY4dL9/b4q3l1ZuFGBNXl+LUv7ub8J1h3DhxxivFi+c71jUxHQPbXUdqrEvXOaYp0Hdy2ZdpZbORBuV4XMm5knNhHC3D2BFjISwLw+AIUdb4m21PzgVywVrbAmiKyB3CzHycePGFVQwaurnjTxIF54nLStrvUWiss1TbUAWnCVFbFyutBTFUEn6zw1iHVtL85nk+r1rfTlzbZK1mVNcz3DyThqGWt6vuZjJpIsem20ykdWG6e00p4MeRGBPLtDAOA66TJrCkxjwthVwS3e6C7csP8JutNAttXUxcBUbepu+nJrRWTT48wjpJD9lWx+i2Zs65oaNkEppzQY+XOO9FI1irmLtKi+086VBqbdpbRXh4ZH14LUgj9Hm9bPq+MS0DOSVUabD4zUilUpYFYx2KItrJKOtz6z05J1KSmMoKZKXpLy5wzkLO3H/rQzCBwZrzoS2vkTNCCUhraJ1W064aOQxIVnwh57fXK0WB+I/PbnGbnTjhlUb5FseZItr3KN+dOaxxf0/Y34vmNUskaS2CaDoZp06NoWrnkBwSZtzifSdNaJSpo7YiMyg5ijRBydQ45sI6L1htSIvgr2w/4DaDEABixI6DhFeEJnuoBWctFJhyJefE0DLnCYkUA8Z5bGdIy4ryHeN7n8UPIzWFs7lNol2f6jupn/+lEed/+JrQU/1zf/Rz/MZHe/7Gb77+Qb+Up3qqH/l659+wb+4C+zlRc+bqwnN54VHGME2ZFBPOK/rBsZ8y87yy3Vi864irTERBVvZGG0zDLFHfsiCVVWKEKAWrac5VhbHCArUG1lWmG6atN43W54frvBaGTkwH+/3M1WWHUpqPPjkS1sTjYeXLXzlikyORuA+BOSd0H/ncjw/81Jcu+PwHO7abjsMx8/i4sCyZ7cbz/gc7Kppvfnwgp8LNzZZUKnevD3Sdoe8dr18vjL3h9vmO+4eVFAJXVxvWVTinw9CxzpGxt2cg/9XNjpwr02EVIHQtXF1IRvg0BYyCcdMxz5GcKxfXO46HCaUQNzVVUk4rTI+PWL/hiz//83TbnTApa2qaSGmU4n5PPE6SFa6qrEdty0/PpbnEwHgna2er6DeXkr6DAm2pNYmUwqim3cxNVylRo/bygu2zF+IOT0vTIDawO4pTbr2M3hJhnth//SsC23eemmHcbKg5kxUMm/GMmlqWGWU0m+e3bN//LNb3LTmpk2ZymSFGlHdnw5SyjqoMef+aMh9luqUaNumkdUyJElcx+6gq0eL9ToDraQXXzBZNF1rba6eqdn0N68Mb1oc7iblEtJrGWjH1KDEQ5SBMT+M71DiQYkDVgvViOisFYVcmaVRzqeQ1yIFAxBJsbp+hayEfJ0yp7K6vePPRK1SpDJuedV4pa8C17PZlEk2nalpa3dbdJ0lM1QpTHDWJ9rJ6y/jsFt331BxQ1ok5rU2JdTegho00pSEQH94QHu5IRQ5bxggnTTcpRKlCs1AYSoqklInLSnd5jWmT5ZIb2YAKRYu2OKWmbYY4H4jTTDeOlJxwrhckk2nr9JwxQy9bgRDERJUyRql2gNGMw0BCEXLG5ioa4yD3blWRYhwXn/sCfrNp7qpm3jLu/HPxVO9WP/fHRl581v1QTkNP9fyiZzf8cJionuqpftTrnRvREDJew7NnG7Y7mdA9PkZKyWxGizKON29mnKtcX3VQNGGJsh5rqziZLlRc02KlkATvqDQxZrQG44QhaI1iTbAuiWHwTIelNWDiiFdtNZqqIqXC5c6zroX5MPPsxZac4Stfe4Ba2AyW3/xG5LiXte0hLWRVeP6+4Wd+4orPv3/By+db+t6yP0YeHmaWJXJ52fP+BxcsS+bNJwcqlecvLghr5uH+wDAafOf5+NXM0BuuLkdefzKx5Mzzm4HQuKv94AhrpO8MMSZigd31jrBE5uMqE96auLnuMUpzeDjie0fXd+wfJvresb28YP9wwLUppVICbY9r5P7VG25evs/nf+qn8eNO1q9d1xKGNCUF1scDJRSMFid4CUEwPaimp5PgANENCkvS9S35pyBuZwraehlmRtF7amPIqpJLpru9Ybx+Ri2Rsq6yWm3pN5yyO3MFMjVH5vs3PH79qxjrsMZRYpQmxlq2lxcc9nvmZabvOmJMpJq5fvkeu/c/Iw1eCq1JKpSwylraapTvm+NdUWoh3n0EYTntt9t7bSaVWiFH6QKNTODNMOD6jppDW9u396GtNKA5n78WqhIfXrO8+kRMLsPQkpcE5n+aNtdGiDBdhxo35DCjVLvuFMoaRTphDa6TWNW4zBjr2vY/MV7cUteVddpL4pTv8G7D5QvF8dUnop3WoL0l10Jcg6QlKTE7aefAKDEpnabUEmZPrgW85eLFrbjUl4nqPL4TXawyFr25bJGaGVUTcf/AevdaDgoojNEojUxLtbj/awjNLKWl+VsWunEj/Ngc5WBSq7TZRtzzAtNv+LAQiIcDruua/KajKkjrgh86MaNZAdDnNVAVkDPOWukftRK0k7JYpQgxcH+3Z9fZ9jtEUY1m+9nPMVxdQYqNi6rA9e3je9KI/nYV1sJf+w//Yfe579QPdRN6qv/pP/tzfPyw8He+cf+DfilP9VQ/0vXOjajRlWc3A9tdx8NDYH8IeAvbrSNGWI4Lu52mYJj2mXEUl2/MMrmszdSitJHnOMIaPU6JFBOdN7jOnV3HIVVUFZf8/d2Rvhe9ojHikj/xSK2Gi63ncR9RqvDi5QXTnPj44wPOwOW2535KfO2bK8uaWNLKxaXhj/zcFZ99b8Ptzcj1VY+xluOUub9fOSyZ66uB99675HgMfPTRI95ZXr5/wTxFXr86sNl6us7z6s3Mbuu4uup5eFxRGj7zbMt+v4j2ceiYjgveW0KqGOO4vPA83k+EZsLwBnbXG8JaOOyPbC8GqnHc3x3YbDqKsoRlZXe5ZZ0XjDYUFA9v9izHhQ9+7Eu8/4Uv4HxHXVfMdoP2nRi/jxNxf4RCMx4JNkgbSbDJIba1vW4IHmkIy7RynPdsLq9lhZ0zSlfANBO6TBbTGkm1snn+At8PoqtLoSURfRsSqWkDoVJi4PHDjzh+/CHWi/Yyh9yolUgCj9F445geHojOMmx3vPzi5+lvXkhjl4usylM5u7eVNah+kIZGG9K6kO4/Fhe5dYiJp4KxZ61qaRB2bSUlyrhekE81yzTsFA6v21o+ndBAsgoP+zeEh3t0zQLuTwnlrXynWtDWnc12dhxRnSetE6oUdHN6l7hStKzRa5a0JVVqmxBHqjH0fUeZDqSYMJ3D9D0pJKpWjJdbNIXl8YBuSK51niVRqopOUp84rdqCN9SYycejfIapUp3h8r3noo1s0ZxxmYnLyvbZM1Q3yjS5ZqiFNM+sj3fivlca443AtToP3soBJhdJj1JQjUTD+u1OHO4l0qLTROag2gFoFcMXSpNTJi4T2jrimnD9gFaKdZ5wvcd1Xgx4uZDnVaavWqQ+J8TVaQJeW1hC7z3PXz5jnhbCuhf50PtfYnPzTAIA2jT0pEmnFFR4txz1H8X6LdGeCn7mjw7cvPz9IWXonMFb/YN+GU/1VD/y9c6/MS4uOozVfPLJzDwn+l7T9Y6HgxgkLq96coI4rfSdGIZQ4Jyh5IK2RiZ0gDOwBsXdw4yzis3Wy3SiVuFC5oIxmjWKQapzBqvBD44cBNkTQ8YoWUfuj4nOw+5yw8Nj5P7uSOc0w2AZN56/8WsPfOuTI7rL/OLPXfJzP37F1UXPxWXHZvTUCo/7yN3dxPEYuNp1vHi+5f5+5vXrI31vee+9Sx4eVu7uD1zsumZaWri8cGx3PdMUGUYvU9XHGectXe+Z50DfW3KWjGVnLfd3EzkltFJ0vWa36zhOiXVa2V6OovdcV7YXG6bjgvMK6wzrvFBKIcXM/nFGWc+P/8IvcPPsGVaLaUPvRskEr7DsD6T9Ed0QViWs4hZu0adnrJHS5CAu6BICNSVyCKQY2OdXXLx4v2lxK5Qgn5WSnPdiHJurG5yzlHVumsnTFLGBM9squypFXhfuv/5V1rtHlFGUmMkpCcjc2SYpqKQgiVPDZiShuP3ij2PHDTUGtOslBSqs1BLkPRiN7nr5dyjCfKQc7zAKqmqvx0izI51locZFtIu1kqvGbi/RVGpaxXdem4REKUhBgO0tKrTkyHp/J02oVi02U/i5eV6oOWO7npoLOQRM59FjR5wmdFVQGuw+JIkc1aZ9DaghYp0lhgV9cclm6EmPjyjj8ONItZI2BZJClqcVZzzdey+Y9gemNxIJShGIvTKizdWqpUbFLAaz2pz13nD1mfelmW5JR6pWus6zTAvTw57Nezu51rlQlon51cfEaZLDofdoYzDenqkGOaSzcYmqSKus+bW1LSq0SiNakhwKrKakSI2rJE+1IADTmLZ2HNDWEGNAWYsdR5E6VNFISx49dOOOGmJz/yNGvVyEQ2tkim20Yne9ZU9Eu57N9fWZCQtAqnDKtQ+LrOif6nctreHHfrbnM1/sftAv5Tuq/81/+4/xF/6t/4Rv3D0dNp7qqX5Q9R245it3dyvTktltHdYaHveBrtP0w8A0Jayq9IMnpoy1RjAvCJIpF4QhaTUPh0gMgaGz9L1vLnqZcJYqRqQQJHUo5zYpUop1Fi7gPEeGwdD1HWvIbEYt8PiDrNWt1fjOcns78uvfeORXf/MNz19YfvGnn/P597YMvWO77egHRynC7Ly/OxJT5tnthqurnvuHldevD1zsBm5vN9zfzdzdH7m8Gug7zzStXF50OO/Y7wPb0aKAh4eJYezQSjNPK8ZpUmmrqlo5PM6n9o9+sPTbnofHmVoym4uBGMVcNIwjy7LSb3phe7bmcT5MzFNg9/wlX/iZn2VzcYGqTTerxOyRlpX1MJGXBdt11JxJIQItVaiIY1xrR82JlBOm78SoU8Tpjza4bmSejjx+/CFX738WZQzaexSVlESXN24vZA27Lm+5mvKpo1TTIxZxlYf9gf03vsFymGQdmzUxNVZsg6mf/nPKKt9cbtk9fw9tnDijvURolrjKNLMUMArTDSjnqdqR9nfU6Q7TsELinDHi8FdIClCSVXmthWosbrwQXFSKstZv7+FcqqKsoaCpYWF9vCdNwjoVOQOQCznnRihoKUZaYbcbqtLEw4QuGYrISso8U5tTXuSSmjxL4hHWYq9vGS4vIUf0s2eQGtO0ZIy2ZC2JS+SK6zwVJa7yXuQBJdPoCkgTVou49guQRdKSrebm/RdYrckxyQS7FJSz1Frp+o5cFtbH1zhj/3/s/UusbWuapgc9/3WMMW/rttfe+1wiIjMrs5LCYAsadBBd2nQQF1m06Fgg0UKig4SQkGjQwBgLZMtGAoGwRVlGtmRZlF1lqqh0AXbhctYlszIzMjIizmXvvS7zOsb4rzS+f859bFlVJ7Iy81RErE+K24m91xpzzrHW+P7ve9/nhZQYHz8Qdnvh9g5ONMWmRaFmWafXGOVMYk2bulessyKfoBmANA00paFqSJO8LzXL1P68Vm8mt5IzOcz011eckUq1xXwqZxluX0nSltaUOTWwgRy0lNJoZ+ReTcJ4Xa1W9K/eUFKUBCZr5X5KBcIsxjsjWviX+gfX688dv/Kb//jwQn+Wensz8OXz6UUK/FIv9R3Vt25ED0dhGm42jpzhOEaWC0k9maeEUYpYpJG0zrb4QmF35sYYrRUOh4A10K87VFWkmCjIn5N0JEGvOGcwSkxLIWWc1igsYY4slw7jbNOParrOsdtHjseZzgoW6fbVgtOc+eFPd/z65yv+c79yxWYpmrf1yuO8TCkfnkZ2zxL59up2JdKDXeDpeWSzGbi5XfHweGQaZ+7ullhnGU+RvndoYxjHyHrlqbUSQmK9GeRZlgq+98RYsE5c38fDTC4VazXr6wXGaHZPB6xRdOsF0xhRSrFYDcQQBUtTAWNIIXLaHQgJPv313+Dt97+Pc75xJ30zDRXC4cS836NQGPvx4621pVilJO50Y6g5EoI0nZZKDjMlJIlTRFNrZlgOpBgZj3tWd68uBhLXLyVlSdXGz+SygVdtLV3PTWiMTPsdp3dfEcapoSsrKUcqkp5DlYQtam0AdMvi7pb1q9fyAkpBdzJtqWESA1V7b0zXo1xPxZAevoI4oVqTfZ4Aq6ZVrbU2XFFjMPglbrlC5UQtTaYgb5hM7KhQRN9alSZPJ9J+S5nGSxyktoYSBVmltKEE4cAqlIDVlSHst5izbVyrS0NmjWlMTSUNLAqcwa3W+K6/TGHrHMgxCs3AiEs8xwIKbO8oJXP6sEW19KUcM9qLYavUs/y3IdZiIswTqvfcfnIv1IoUPqZLNVYvtKSsBCon5mkkH/aE41EMQp3DGCvorCpudXGaSxCC0pqq2jZE+9bW1+aKzyh0k6hWiKMQG4pEwWol7wedE74o0kS7oReXfRb2Z8kZ7RxusxYdqlKUKAzjqhFJAjLhrVmoBCUltPf0r96KESwLdUEh4P1SAmWcUU4iV1/qH1zWKZabn99m/X/23/wv89/9Z/8K+6bpf6mXeqk/2/rWjajSGqsV0yQ6v+XSo41ibsYHpcG3ZrOWQozyEFda44wRjmbO4mxXwhNVmkvKklLIut0ofGfJuUgMqFK4C9Ils1o6YlbMY2RYGIwxPO9iSy5SrJY9602HNprTOPH5/ZI3N4NwOJ1hsbAYazieMtvnkeenE8po7u9XDIM0oYfjzPX1wHLR8fhwZA6Ru/s1ORVOh5nlqkNrTQiJvrMfm+1Fc/OWgnOSfGSsZp4T8zjLutMb1tdrYoyMuwP9IA3tNAbR2BlDnIVtqKkYpZiPB8ZTwHVLfu0//xvcvHqFRrdJj2lObgjHkTROaNRFE1hpUZ0tgapUgcOLb6hiVguM0pAzaQoXg02J4pRXWmNdx7TdYpyjW1/TrTYY51tSU6aeDUnfWMWfm9EcIvNuy/j8SJyCpOSUSqmCn7JNt3p2XVdVcX3P8v6exdWVXIMxKHdOWBIjEEjClvI9qlsIX3P3HuIkyCaJ+JJpltLyd2r5yM60Dt1LXrwqYp6i5EvDyjkpqSHDCpDGkbh7lq+LGOrO8HytlUgNUhKIvO9RXU/RljwexUSkmhGnSGytqkomsNpQY5t2GotbL/HeS7NtW0JSkuZWUEVZJAyAsY5cCvPu2CSXIkMwzra1OC1AQvTZJRViDOiFZ/PJW4xWl4jPy0BI6WZkK7IGX65J08i8fSYdjtSY2rpaCT82Ci6qNoC+/D6QDK2akWb1LNFo3Fnh28r0//zdJQijJVZpMT7V1GJ9SxIjo7ECpUcaTdX3dMPyct+e3fZYg3GWej4hlXJhj2qjGe7fYgehMxjfjGs0CoeqklmvWmBBmH7W36u/8FVr5eufRKyFH/xmx6/8+Z/Paei5/mt/4Q3/1t/8ycefgZd6qZf6M6tvzxEF5ikydIZh1VNrJeXa1sZiIspRDCeltKWmNjK9SLnli7dozgqmcUTPcYUUcEZjrESDVpDnB5J3vVpYsJbjJBGG65VwLHd7aUI7r1hvOtZrL27pXFh2jh98shFdqtP4Tlzkp2Nk+zyy20mu+6v7FcOiY7+bCHNks/ZUNA8PB5zTvLpbcRwjMSRubpaAuJqdM6RcsM5ilUxEhTqlUFWaytMpEIPEOA5Dh/GW6TShNfjFgCrnaFKRMpxTjEqW92U8jMQM128+4/Vnn7K4ukIrmbydMTVlnknjTBonrLGXJpRaZQJ6iShUWN/LSloXbD9gO8kzzzFgvBjCcsyUmLGdRyuI84zpOrTr8OuNJNc0YLo0nK3h01qe50ZMZ/F4lAb0eBLNaRb5Ra2VzrlmmJK7K2dpzrrNhvX9K7phIfeFE5RUDbN8z+ZWV8aifU9VljyeqPNBNJ1GpoDoZlhR0iyJuQlZ1TqHGVbS4J5d8+1r1xa2UMtHDS21Mu62hP0ODTIJtvayLi4hip+pilPbLlf49YYUoyCjchBXd4kf08OUpkbRSipVqcaIS325xBrk9YLA4NPZ6KelkW+hD1pr5mkiTxMq02QCbTDdol2lqUNCD3IlloK/3rC4vZbIyxQpObUIVXlN2kjKFtpjhyXxeOD0/h15nFuTKfffeR1PzZSYLsEJ2mrCnIkh0i0WH2NRUd+IlzViMGu0gpw/pnTpc0qUUY1QgIDrrSNNof0ZUNbhlhtM18nkPYUG8m+mqfPfb9SCUgqm83TXdxI/mpoUQTWUVylUMljXGudKHo+E7dMf65frL3LVAr/32yO//k8MfO/Xf750of9Z9c/81/8Cm8Hzf/3rf/BdX8pLvdQvXX37RrRkFr0VDWIsFxqPUbL6C3MSdzyAURcDgTOaqtRFK1rOaUDI+rrk2jSCksWdspiclDaEkCglc3PVUYricAr0XjP0HaXC4ZiJIdF7xfXNwDAIuy6nSkoytTIavNdimqoC5d8/nziOAWsNr+7XuM6y202kmFguHbkotrsJ7zWr9cD7hxOKytu3V4Qg+jWJ2iwY28xYslElxkI3eGIqHA4zmkrXWbrekbLoL7uWZBRjxjvXpsL5zEVvDVFmnCK+X/Pqk0+5vr3FOYcqlapra1Yz8TSJJq+0NaQ2xJxQSYDmpekKzzq3QsEYeairWkSTmIuscWuVaMkGEtdWGl23XrN6+wn9eiOTpxyFl1nF7azapE61+M5aCuPzE/PjA2maqFlQQinKNJTz9Ku2PHslsZaru1sWN9cYJ42Ask50jXNs8aCI89s6VDeQUyWftrKKR5pTdAO1V4DY0Du1NcgGXNemfc1BXzOl8Tyr4vwBcNYalBwI+x3hcLockGoukoZUsjSYIQlOSVeM96h+RZhm6nxClUSp0rCKf0uLRCIXdJMgFKB2nm59hSmZEiZJNzLmY5CD0h8Tsoqkb2lvSEfhk3orMZ6qHUCE9Wo564JLysSUcVcbhuVwSdyScasQKlQbBymK5KurwjQ9MD0+kMcJpYzE7Lbpqm6r65oNFTGdKa3atP/UPl8ofUfnhdl4vldqyvI+G0NVtckO2sSzRdaeteHyF2V6TJP8YCxuWGH7XkIdmumsFDnk1lqpSdb5qsovK2U9/vYe2w9CWmhGKqVbxn2S+FD53VapcWZ+fCRO48/6e/WXooxRvxBN6Ln+2//VX3tpRF/qpb6D+taNqHOmseGkkTw3oDkJI9RZKw1VLqQsD6TOWXlAkJvuTL5OiNJkaaOwVrihVcEUs6zhtWYaA0OnGRYDIUGYZCq6WnWMU2G7nyUyszNsrjqGQeDkuUCu8p9aS4yotYaYK8/PM0+PR+Ypslh2vP1kwzRnPrw/Ygxsmlloux/pe0vnLV9+taPrHa/f3DAfZ4yt2N4zTxHnHKWUFjBUSRn6Zc/pOAvIX4le1fdibiql0PdOJqTWYq3wRWspGGewTqa84XhiHhNXt/fcffKW5fUVup4f4oKWyTETjgfILVO7OXtTjGKAUbLOhaYN1JpMFmczihLFzKGNlQSrlsOtdJtKK01VmsXrO4bbO0FD5SQ8esRQVFFNV6gveKN4OnB6fiLu95AjOQjAPLW89FJLM9tIg1FywS87rt+8ob+6QWsj06g2Ia5JJm2qJHC+pfosyKmQDg9i5NFKVr60KZrSksaVVZsyQ0Fh/CCGriY5IGdqGCUS9OKqb9GdKHIIxMOWNI6yXjbSQMn7a9Cqkjk37RblLGq54fjuHVZXOVhcDFhtS6DkmjSgF550CiJHUJ563IlMxXmJ0DTS1JfaIkCbKx9VsX2PW63R3cDu66+Jc8Bry0UQikzmtbOUlCi14q/WdOsVqor+s2oDqXVerUGuLaVIt3tz/PpLUVxo07YcYHov2KWcW5xqaRPnKgeOEMXp7h1aVeZxoipNN/Ro56gxCM+0Cui/lthkJpDGE6AwTnihpYqER9GaeC9EDt15bN/L64uC1MqpcVkVkr5kXfu6ijgHirY4GqT+zAY1sgUgzaKzPgc81ML09Eia5wbcf6lvltLwX/ivLL7ry/gTLa3gf/Lf+Cf5X/7rf+u7vpSXeqlfqvr2QPuY6b3kVmsFOck0yzppQkLIpFjQutJ1Dq0NaZ5FN1eBVBgWjpQKMRa8NfJQ04qYCuOYRS+pNWEKLAYjJqRjIofEzU1PP1hOp8L+IIaDYbBcX/f4zrZnqTS5OWa0qXhnsMYwzYWHx5Hd9sTxFLi+6vnkkyumWHj3bseis1xdLZnmwm4/s1o4qPDweOR6M7C5XnLYj3ROQNcxJPrekXORyWiUdaAbHA8PR5zWaKPoe4vrPLvdiFWSeR9nMTrVKmt91zlUEcNFKjBuTxjj+PTXfsDm+hq/WNE8GICiGks8jrImLQXbeZSzkAq5ZFBVGpYi5pmckjQZTuG0p8RMTAk3eDgzFnMRQH2hPaAlo3zx+i2r+9coKnUe5enTJowAbed71mFw2n7g9PCemiJ5mqkV5jkSQ7zIFTRK0EslUyqsbq65+uQTumEQbmPTOErUZvseJUC3wAxLlB/I00jafUBTBWivKnLysC39CUgNPF8krtMMC1SR68D1Ai5PspKutTSzir6s5/N0Iux3lJjQnSChcgzovpOXm5shp4oe0ww9+J7x3TsIE6rvhFrVNMO6TZhzzsj21zKfTlCg6zt0TuihB4Tjqq2RqVxrZGtummujcf0Ct1qjlKY3FvP55zx++SXTYWToz/rYAg5yzqRS8Jsr/GqBomk40aAcRTeDRv3ozyopElJlenrGtml1adIJM3SCYMoZVUV/nGNAK5gOE2EKGKOxnUUbfZkUp1kiNHtbW7MHZRS5RS0SjBDGkRIj1nUoJTgm4zQlJ7SyYE1r+sEtFqKXHU/UKK581SbfNSQu3WuRbUMcJ5TSTF/9FN5+ilusWoOtGkWhyT5KAuOI+wOH5y21avrFz7f+8U+jlFLcvv7FSiYqFf4vf+33v+vLeKmX+qWrb92I9q790VLEUa0qrrfMcyHGiKWw7B128ExjIoUZ4w1TKBhVsc5wGhPOQOctMSSubzoenwM5Za6ve+Y5C7h95SloHp8mOq+4uR/wvWf7NHM4CFZl6C1X1wPd4JobGuYxMc9R9KBOY40hZM3D45Hd9kgIhftXS16/2bDbZ959/cRy6bh/s2Z3yDw/j9xee3KB7fPE6zdrrNHsn/Zc3y2YxsI8BRarjhATvnPEINnaptM8vNtjncPqih8cru95ev+M7xzWeaZxZhg8Yc74TkuWeMmYYeCwG5lPEzd3r3jz6acMq6UAz6to/2rNpBwJ24NAv7VFa90YiUEmUlac2gIwb6B4Kr63OO/JU5TEH9f0qKmSwoRKWfSaVSZBfrNm/fZT3PpKGrokbu16TkhCfdT2tqnl4f0XTNst1EI4HSmpkHIhN62rsEwb81GJheT67SfcfP49mWhmyXBXzezGmemoq/BBl2uUWzI/P8DpGYVqUzqRMWDaSj7nj02FkmQlPSzQNDd310um/HkHqwzKtSCFZmpJpwNhv6fkJPB1hOuqrUXFKOYs5LWgNXZYUK0nPD1R0ywNZ4pioMqCWsJaSpJDAlZzOBzRTtFbR5oj/dUV2rr2fUyLSC2yrj4bt3PFWoNbb2Tt3mQX1jju3r7l3U+/ZLvdcnW1BufkMygZv17j+h5iEClE+yxrGOX9sWLQUtaSTify6chpjnjv2xo7oXLE+B6tNGUKoColCS8Uozlud0zHSbS7vcVoidesymC9p6TE9PCBNPT0yyWqSRByiihtySmRk4D3zzISrTUk2abUs/HIGvqbW6ENhFkOPDG2AIcmS7BCMsiz3O9hEumGNpoSJk4//gO6158z3L9FqSJT8XYAAkXcPhH2W/qhF+zWy2r+l6L++//7v8qH/fxdX8ZLvdQvXf0MrnmFc6JB0y01Z38QI86iNyyWHakojvtJJiBocqj0XhGTYpwSq6WXdKFaGFaeL74+0lnN1VXPfh8wqnB93XMaM/vdifXKcvdaTCXv3x3YbgOd03gvTWjfsoJzgTBGUq50ncZahTGGKSrefb3ltD9Rq+Lt2zU3N0u2u8D7dzsWg+ft6zWnqbDbHbnedBijOexHXr9eYazjuDtydbdiuw/UnLi6kelo3znSlDBGEXJlv59YDD05zyxWK4qyvP/qmfVKTDkhBIbVkhwixrnGFgVlLcfDzLQ78fbz73P/6Se4zgtzsaGHtO+Yjyemxz3GWvwg06Cac3ORy/qxZpkKuUVHyYUwJ/xqgfOOeJzkQe8seY7gBDyecsI7R1WVAvjNNeu3nwiLch6lCbG2NX4y/RYTTZYc95w5Pnxg2j5RQjO9FNoUEDCVnCu5uapVqdhFx9Wbt1x/9oO2JhZsjmgggzShIvpEdR1meQV2RXj4Go4PaOebGakIdkhr+WcViRa1TpqqFLH9FYRRUrr6xQXfJJN9dWkqxdCSiMcd8XSi5opbLGVrO00Y50WLWwUjVbJMFu1qQ66K8PiEaWv6i0u/VAH1a00tCaU9NSXmaUZ1jsE6WZmv5R4vIUiKFZJCpJtWVjBUYK3C9Z2YklqzXWlOce14++d+gy/+/u+zP+64ur4ihYDbbOgWSzHyJNE3q5YHrywoI9SGqkV3qaylv7mlt479dkeYjhiyTJpRsnZv5qkcxYF+OhyZjhPWO1xz68eYcM5jrSPHRJwmjNHE04kUM4tOmk1jO7RRxNNJ4nutTFyVbjpNpbHOXcD0w/UNxjny8fARx9Xiac9u/hILNWaU0ozjRJkCw3opn0sq5Bw5/NEPiYcDy88+w1rPWXKUTgempw8C6G+mMpV/PpKCXupnqzPn+n/0f/j3+eLpREgvEoyXeqnvor71b9jl0rapGYynzOk0o1Xl5tpjjOU0JrSu+E5zOGWMLiwXjtOYyLmwXnWAYtVDzIp37w5cry3Doufh4chyMKw3C7b7wPEYuLnpuL1dknLlw7sD291M7zXWaTZrz9C3zPRSibMYH7pOmmVtLXPUvP/qmd3zgaKkCb26XvL4OPHwsGcYLJ98smG3D2x3I7fXAyEVHp9GXr/ZkDLM08TyauDx8cjN7Rrfd+wfn+k7xzhFrFWMc6EULQ/gGnn1+orDIfL88IG7+w0xFUJIdEt5LQLnVmgj7NTxOJHGyPf+3K9zc3eHGwaMc21FaDFdz7TbMT894/wgbuCGGCqliAzBioM4x4RfDJRaiSXjO4sxlniayY37WErCeAstjlLTppzasLy9YXn/GqO1fH+kUQZET6jk+lUFZTVxnjk+vCPsd8Q5XsxqsdQWsViJMTc8l2gAbd9z9/n3WL1+K1GSWoH11JIoYWprVslc18MSs9hQjWf+8vdQUdz7Fz2oUmAt2ndibg8TupMpVqFgV2vqYSevY7ES40tKsvauYjZqKezUkgnHLfF4FDTTICv4NAm6p0bBJ9UGba+AXgzEECjTSfSiWe5DpeSQYfvuIkNQypLnmTAHhk/e4qmE/YHF/SvBnR2PzUCWL2agmuQQUCs453FLITbUlDnnx1PlM8FYyIlPfu37fP3jnzDOE/16RbdaUkIgzXM7VGhUKdhFL3CBvqPOAW16tLaY5RrTTE7rK3g8jmhr0bohl1KRe2oOlFIZx5GUM361gFzJuUh8qXVYL7KJFIIYjJQWJFSa0YsVduhJYyS1iaP1HabrBDkWZiFPLHoKhQosP/lUIoJDQGlHniZAywQ6hIuGulRJZ8sFiIlh0YvCoySB6wPWe8YvfkoKE1e/+utYayhxZt4+SRzxObhhChI48FK/MJVyIZXK/+bf+tv81b/79Xd9OS/1Ur/09a1/w+rGAt3tg7hvvRI9WlWMp4h10mCmUFkuNEpbdsdIZ2Gx6ElZVvS7QyJMkTeveuYIX787cH3l2FwteHqeCTFzezewXnqmOfPwMHI4Bnov0rK7u55hcOLGzaI3hYp1CufFDb7dzjx+OHI8jBjvePtmzXo9sN9OHHZH1ivH7asN231gtz1xtelIuTJPkfvXa4myzAXrPdvnE5vNApRi97zHWsc0J7rOMYcMymJNRlO4ur1iv58J08Td2ytyi9Puh54whY+aSsRBfdhNOL/gN/6p32S53KCNlSlizWIWqob54Zk8TxgrTc3FVd8c1MZJklHNGd93pJQoOV60mGmaZTrZMsRpMZJKid6QqlBdT7/ZsLq7ExlArvK9tJFMcOn6RFdYMrVUQpg5vv+auD9INGOuzHOgJGGBKqspqbRYV2m6u/Wa++99n+H6ipImFEYalJzaKl6jXUdVCrNYoJfXYnb66vdQZNGDuk5iIc/pP0q3RKgEvjUxtWC7JfW0E13qsBSPfAzS+IK8D0UmzrUW4ulE3B9bVKWTlex4Eod9bcxKLRQCbR12GAghksejGPfKWWSpmjRASAVK0b7WxDwF1t/7PotFR9w+sbx/JRi040kaViqq4YYUyBpfges7tOsFKdUOKOrcHLXmi7Ob3jnefP4px8cP2K4nT7OYlWKUBlFrlHHC4tQK5rn9c1qTLlPuWjPe99x//hnbD+9JMaLmiNGSlFRqJpZEqQlrteCRaASEocNq0w6JMylkrHOS7lWyyB208EBLmIR92mgG6Coa1yra4xIjetGzuH9LSUmkC1o3E5FM00uL9DTOIt21GKFKjPihAyppDqL9LcKvJSe0UZTdlsMf/D26+7eYIhGj2jtqKeQYxDCWX+iSvwiVcmF7Cvy7v/0l/8f/5+9915fzUi/1Uq2+dSMqa/iCM4phJeu8GArUhPWaaS4t4tMyhUKYZ/reYK0lxYy2iv0xQKlcXfXsDrLGvb/r6XrP09NMipnrjWe56plnmU5OY6B3YK3mzesl3eAbeKcIskiQkdjOUari8cOJ7eOB4xhwXccnb1YMg2e/D2y3JxZLz2LV8/7hRBjnxgWVxKFX92tiyKSmzZtPgc31WgwvMdI5wzgGvDfMc6aUgncarRW+H3h62KEUXN2sOJ0izhpsPxCmWbRvWqNqpqTKFCqvPv8Br16/pl+v0LWFuNRKQTFPM3Xaoa2VzPLaEESq6RNTusDLU0iYzpNqodYWMGBEpygRkqa52xVpnsVp74wk0iwWLO9f47pmyKj1G/9ZQZk2gZWGv1SYDgfGD+/J8yRr1yDonuZaQmsx5agzBckYVrcbbj/9jH61lgmhkVjLWkR/iLHovhczihNIfTrsyfsnaaqNF3h/LW1i6oUPmoLwTI2hpBllO4y11NOzfE3ft6YzyUr73FNUieyscSYej6TjCWNdi4AslHhu4BsovYqD2/YdWEeKEeLcgPwK4zQ5KaiFqhXKWNFfKk2aRnKtbL7/PYZFz/zhg+CytCYdj+g25c7ndXvlgpbSpsN2i0viGOhLktGFLDBNnI1naTqRcxLQ/Tw3A1qVQ4TRzcxVqDHhrzaUeRLjmE0Y17fPJAs2q4rh7erVK7YP75mOBaeahCHHj5zTFh5ABdt5XN9TQiLnJGgwK3gnKHTLhUxcM6IvraA6f4kHVSiRUTQds+4c3c2trNVLolJIk+S/G+Mu8hRtHCWIWS9XzXwa6RdCekijNKG1FIw2l6AHO/SUnJn3B0r9gn61QPvuYwJTrVijyfFFI/rzXKVWfvhuz08ejvyv/o3f/q4v56Ve6qX+U/Xts+ZTpvdG1mAFYozSnyhFjoXOil5tu53xXrNZd8RUiS0FZToVloOlVsXzbsY5xav7BaXA49MMFK6vO4aFZ5wq2+1ESQlvPkZ2dr00mzllUi5oBFSvjSIl+PDhyPZpD8Cw6Lm/W+Cc5v2HI6fjzHLhGRYdu+1EiYm3bzacxoRSmeWqayQAWS9SKuvNQAwJ5yQ9R2I3FdOccFajqsZ5adR224nea1zfMU8B6yV+M8XYYNkNrZQSzi/43p//Vda3NxgrRhnVDFclRcI8C5uyaTK1d7IWLZUa0wX8jYb5OMrUTlcUCbJgmGrJNH6Q/EvLg92016K7jm65Zri5Fv7oeZonwNeGg1JtUtnYnzFx2u4YHx6Eu5mrRLS2NJucC7kkvGpA8FLxXceyRXXabkAp0e8Kp1F4pFgjzFDrUW3ym08HaULPaCjVuJNKoVTLNI8zZ+ZsqQXdLSU1ajpRu4VMDUtqjVgzJ/GNyWUIjLtnmRbq85Q50kI+pRlLWXBIFZTvqdYRpokyzRgtbFpqERRZZ8lTkM+7eZ+mw5GiFavPPqfrOubnJ5EIKM2832OclwNK4/LW87+piuk6bD/I53iWLLheJuZnQ9fZZIWipJmUYtOo5gaPPycnCfO1VpEbuM5LupNWKCzWD0C9RMXSgiqUVihluf70M7a24/DuPYwzuQiC7NLYo3Cdx3lHOk3kxj9V1gg4P0f65UDXC8M0JZlin/XH9XJwEd1eVaC9NKGqyUgoSvijBXAKrU17L2lpS4piDfE04ZyVNXzKkCXeVllzeZPldUFFYxc93Xot/NGcKcjPgFKILvisI36pn7uqtfJbv/vuBcn0Ui/1j3F9e9d8L0ijHItsbXXLh1fiRg0xkXKh6y2dd8KNpAq0vjR0U4bxFFgtLet1T4j1kj1/fT1gveVwSNIopkTfafqhY3M14DpHKZUUIqlIopNt08h5rjw87Nk+n6i1Mix7bm8GrDM8PY6Mc2S59DhnOR4n+t6yWi+Y5oi3Fd93zEHWyNpoTK0trzthtExSQojEKAacrhNnvNLCnQwh4r2ks6QkEZphjmIA0ZK2E2cBxd++ecurTz6hWy6x3st0K2dKrqR5Ip5OgLynZ1PN+WGfYyTPQZrXth7PgLMaXQuqQkznxqsNT6toFmsR/qV1HjP0DFdX9Mt1mzSVhtRpD+fmJr+YhlCEKTE9vGfePstEqUhjWkuRa62QchQeqTZiXFkNDFdXLK5v2tq0tuYYaT5AUmza+yB58Zp82lPDKG72cxNQaGlR6iNy6SxVMBbTLaSZzQm6QRr7FCW1qOGlLo1O41WG3aGZglqMZgOpozTKqCadtVQtkZfVeXKYIQasMwKzT1lc7u3eyUa3iPrKtD8QS2Hz+ecMqyVxvxeigXekEDDWCrS9lIYfgprlAOK6HuM6zgEBNQaU9zLxPichKd2m1ZmSAilJchNFJuFK68skUKlvNFNn+Ps8o43D9N3HLriWJivQjYog6VLKOK4/+ZRpv+fw/EjvvUgWWlOH0pcceEJpn5PchKUWbN/hupbclSQQw/SDAPCnWSbhnWsxsRrtLH6zBuSzqTFSpkmuzcqEXyJC5dCovSEVmHdbNM0Bn+WeLy1lStUKBjE2oSil4JZL3GqBhY/Nu6AIYJpQzsrP20v93NW/8x9/wRwz/7v/x9/7ri/lpV7qpf4B9TMkK4GqBWMkH156CkWIlZQSvTdYZ5u2TRrQOWSsVfSdY5okM/pq4/HechozMWT6TrNee5Q2bLeR42Gm5ETXC6h+sRQney2VFORrOKsxRhqZ0ynz/DzJ3yuV5brj1d0C6xyPjydSTKxXPbXCdJpZLD3adxz3E0Nv6LqO41ESVWhYG21NW+OKAaXkRGgmjd6C0hVjLSEJnF3wSi1DXYGKAeMcxnfM40wYZ/p+4P4Hn3L15q04qVv6T216uDRP5DC3eMPatIhWcDkhSBOaCsZ7tLXEaSJTcL1vQQOQWyqVOeNvUFStJIYyCxvUr9f0V9e4rgMjWkisNIbntTcgKTNaHtjTfs/8/Eg87C8A+9qSjmqVhrdWyT03peA6z3C1ZnFzg+sHWam3pqnCeYMvAHjdpqHGk2OixBGl5DM4/0GZ7ram85wBf+GXKnQ3XJzptRRp1NoUV5KcFOes85IzeZ4I+x1pPk8/FejaHPhWcEZKTDBohRuWJCrxcELF6fL+1vZeKy36aa0qSol+MYdAdZbFYqDvHDUESkzYvm8HDN0m4MLL1AaZglrBHQkZQMgGknUuST+qAdiVdYLJLJkcJpmSKyUTXWNE/5tzC1yQaF2ltcR3Wjlk+WGJ8QuRE7TJ9yVliI/vL9aCMRw/fCDutvg2xS1JcuG1MSJZqLJN0NaR5kkOM0rhhh7fd9QYSUEkD34lLnZybklYrRGnopzDrzaYfpDXMEfRIVe5PuMcNSVymxJr7wkxMm13WAmob+gr1V5zm8AHAefnlFHKYNdL3HKFrlkaWqCcNw9JTE3aOcr5hn2pn4v6S3/rp/z06cS/+R/8mCnm7/pyXuqlXuofUt+6ETWmEpr5xjqJ4jwdZT2/XHrhRdaKNor9SRqCxWDJBQ7HiNVVpp7WcjxG5jmzXlkWS0fKlcPzzDQnFJKWdHXdS9OoJZEphtxWyxrT4g4Pp8Tj48h4ClDh+nrB7f2SlBVfv9tTS2a1HgixEObIYnAUNNN+pO+MuNZHSe6xzR2uUKLrS6KJjCGhjSQ6TYcJ3Vm098yjaMjOSTy1gtHy57u+x3Q98zSSY+Lm7hW3b16zvLnBdL108imTydKMTMKcPGeDlxgu6+QSgqwlKzJxspacE9VorHYtq76SdWvctJG8b+eo2gq3EwGAD9c39NfXzQTT1vAt2/7swOY8SUTiSOfjnjSdKEH4ehVQtZJLJpVMqUW8V22i1i16Nq/v6ddrrJc1uzKuTe++4fRWBsy5Ce1I0wlSuBwCaptooYw0ZaW2uNIKNBRUyx8nRQqxcUgrFclwP+td5dJkajgfD2LgafnwtY2bz1zSs0RWJm8OvVqJFGQ8omKQKWCWfHiFkiQnxDiXUiJMwoNd3t8x3N3BPInxpbm6lVYXg1lOMs1T3l58bMb3oqHUtt0LIzWH1pi290vJQaCWQgoTOSeZMLckLaX0RTZTckafp3+LQRrRWjB+wHiJZ6z5jNCSrHl1TnAybeKqNdN2y/6nP4Io2uucJJDAWtGBK4Rpm2NsMb4ysfSLnm7RQynEEETP6boW8ym6XWVbPKyW5td28vNDQ23J1LOgnUU7B2hKiXIIdBKne3p4xiotGtIQMFqjrJd7xBjJoHcSyFGnhOo03XqNykXuhbMMQaumOy1o7ym5UMpLM/PzUL/1u+/4f/3O1/ytHz3ydAzf9eW81Eu91Lesb92IniaZ+HTeMMfCPCWGwWDaGtpJBiWHQ8A5zWrpGEMlzJnlwrJcOmKC5+dAqZnlyrJYeaYxsz8EmZ5qYSVKZKc0L7lNQmutWG9RVHKtjGNh+zRxOgYqcP9qxdVVTwiVn361Y3Bwc7NiDpU4TyyWsubMObNcekLMl6mU1kYiIGvFGkUuhVwkrnCxdOLAnScWSw/GMp1mwTWVb3YtMt0cFp6cC7sPjxjref3Z97i5v8MvFjLJkeBxebj2S6aHB1QIaGvJqUHXAW2aczcltLcySVNGTECCTZTpTS6i/yxVmJxKi4nFSPMB0K3XLG5fCRezrV9rNagSm3aU5obPbRWrmQ57ju8f0F5jjKZUzTlxKU6z8CRbAy4axMpis+Lq7Vu6xao1GF70rUom2pxnS6U5911PVZY0HlBZYiWVNqLrLLVpIrvm7p44qxRSzmjfo1Wlhll0tN1CJAUlA2e3fxVtJ4WcIuF0lEYpyrSrKoXxtq2QFbatis+tqVltmMPUnOUZrKLGSs1RdLUScg6IFjiOJ1IM9K9es/7kE0iBRDtQpNyMZBqURStF0RpjtUD7tW7TbjHuoK3cC8YAQgsQp3wV+UGtpDiJPvXMkD1P02PCtDW4MgbTdagQGsjf4hYbcYbnIpO/WsBYmdQamX6KLkGDqpyetxy++DFlnLBGcFK5gjIG23XS6DVyg3BKDSkF/NDjfCdpXuMJasENMiEvKWKMlfsWkQLUWjG+ww4DEolUqSF81HUq1aa8iZKi6IG1Ynp6xpSK1pWYgkyErZiShJkq/FplDWkUGcDi1S1GQT5P/muFokSDnot8ZlUOXSW8NKL/ONfvfbXjX/p3f5d3u5F32+m7vpyXeqmX+hnrWzei3gg4en8UTedm5YhFczrNDE6RcuV4nNhsHIvlwP6UyTlztbYMgyNEQT+Vkrm+8iwWnsM+st8HcgWrwRjdDEuuTacqaU4y0fMGKNQKx2Pmw4cj4zhjreX+1YLVuuN4jDw8nrC6cvdKcuSn08gweEpRGF0ZemlCnXOMIeG9IUeBk8dSKFW35iqxWnfMpwA1c/PqinGSqEDfCQDbWEOp6mIe6pcLxmnm8csP3L35lDe/8n1WN9c43zV9oqKm2HK/rxluXmH6JU+//zt0BXQDdCstTUFusYp2saBaSzxNMnVWTZunWnZ7TNI0GMmJLzmR54CyluHqhtWre2lkz2ttWkfXUmxq+mjoKVVzenokHA+ik9Tq0qjpdg2lcSzJoks11jHcbrj+5C2uG6Q59n1Lu0EmrBqgOcKtuNlTgTxuv5FlXi+rd9XczYImCtQsMPkcM3q5xmpNTRHdL8E6KLltkrU0oVrW59Qi2tvjoWWjZ2zfQ0myWq581FoizbLWGjUsiWFExYgq+aIfVEYYpueVtzKGNAfiOJJzZvX6juWrOyiZPM+CnKrIPWK0TLSTyCxQmlwS1mhs16Gsbz+VVq5JIf+sJR+dDT21JOI8Uao0sJLzrj9KMJq+tYSAWyzQfYfpPGWa0LYTNmytqCpGMRC9K7ppYzVQRQ4xPj3z9Id/COc891LRZKwzaPVxGpxLEVe6tcQYMM6I/KMW8jihcsatlthhoIQAiNQiR0lUQhX8eoG7uqK2JvycHHUuMSQJtkwZ2bZM2y0qS1BDLQXd9ZzjflVLC1Pt3oiniZwzi/tbIStMczMBygHrbLArUZLGVHtdbrX82X+zvtSfeu3HyP/4//T/ZkqZh5dEpJd6qZ/b+vaueQzTKbAcFM559seEUonlYBlHwbS8vpep3/MxU2Jk2SuGhWcOsD9EnKlc3XQY5zidCttdlF/0WrR2Z0YoSqaSgoeCfrDkmEErDofE+/cnQogMnePmumd9NTBHzbt3zxgDb95eczgGpnFivelJsTTGqCXMAWsUx+PMajOgqVSjmaYASO69VYXlsuO4G1G6cn1/y3E/YU2VlKOYJFmmVBQZay3We54ft6Q58+f+if8iN69f4xa9TLQU1CoMSoxlcfsKv1yjtGV1/4ZwPHD68id0zrekJDHBKKPoVityLsRxizOOEDIxBnwn612gAc0V2ovTvcSEMZ7F3RuWb962CM22iq7NMOQcKHPRXyrtKClxevrAvN+KFtRqAd8bTVWKcbtHtxVqLYKF8kvP4uaG5dtP0NZSw4xyHapFLtYUmv6Qpi81aN8TwkyN4YLTUaoZTGr9TzaWKVLTTEmRXBXu+h6NOMZVN3DJB1e6NdS5NbGaGiN5noinPaWIdMRYi3KOuB9bpnvB9j3Kis5Xmw58zzyeGhpMo6wiTQnlRGaQ8iRNs9KkaSaMJ7S1rD59g1NyUChhlsMCiqoqtveiucxFaAFIepLrLW5YoLWnVtUCBFoj1ppXCpQoiVFURRxHieo0mjROzaDfZAhxxl/dtdW9APtVkSm3W4j5p9Yme7BWWKyhTRGda3pNSc06PT3w9KM/gpJJtUoOfQWVpTe2nQU0YY6UXCRlLMw47/B9h7ViMNTGoIYOPfTkIocr1bTRSitSirje0V3dorSjtgml0hpjrMhCGiM0Hk/SLFvL/PgMc5D7VCGvp20QJJ1JNLOyepeQA3+9pFv0lBQoKSKhUWJ+orF2xYMoJjHrHaf9/h/19+xL/QlWrZV/+p/79yi1cpjSd305L/VSL/WPWN8+MqQkXt10zAkenmc6Vxk6y34fsFbx+vWScaq8//qINZXb647FqmMcK6dTwJnKZtPjnOV0TOwPiZQzvVMYq7m5FXRTbc58ifFWAsuu8jCbQ+Wrd0fmOdJ5y9W6Y7nuCVHxxU+fMBo+/d4Nz48jMQTWm555ynS9w1gjKCUF4xToe0ecA0PvOJxmjDHMc6LrNP0wsH3cM3QO0zkeP2y5uV4Rm55MW3HHG9VA8Si++uEfsdrc8Jv/pX+KxfWVPAhzaavbto1eLFne3stEczxSasYMK64+/Yx42JMOB6zS5Bwx3mIXvSTXnEa0NaQyyaRGK+ZpaoYxg/EeZRBGqEr4qytWd6/pNtfSfDbtILUhkBqWqVZxL6M1KQQB1B/30rgafXEh5SkwnsSxnHKmZvlcTOdYXF+zun8jmtR5EhONc9J85wRoziJSZRwYy/H9l8y7DwxXr7Drm4sOkeb8RykB1YcR2lq7KEt3+1Y0mQ1gX3NqJqiGadLNYd1W5ul0IBz20ni1VbJ2jpyyDF4xIn3ICWM1xneoYUk4HCFIDKqymjyLhlAr0yahkgWfU2Q+jVRjuf6VX0WniELe4xJmUBLbaTovRqKYBDyPpsSA8wa/WqKMpSp1mZ6eXfEXDUaawDohE4x7mZRbezG6KY1MIo9Huutr2WTHTI2J+ekZM/R0VzeizSyFMs+yfq+FOotBC9f4mkqavOPDe3Y/+THeKqrxTVpQMUo1tJJodwVKH0RHehixvadbDFgvZAetFcV3aCc/DxfmqJLPNeWE7T2LN28/ToQRTix1bu+DWMpyzK1Z1oz7PSnM+MVZx2lQJaG1wmiJ1UUBzqOUTEZ7P9Ct1226naixtClwm4bnRI1BSAkVakzsD0cOH7b/SL9kX+pPpnKTQv3T/9y/x2GK3/HVvNRLvdSfVH3rRnR91bPdJcbTzPVKNFi7Q2SxdKzXnsenmf0usFo4rjaeYd1xOBTGU8C7ymrdY5zldIgcxiy8SacotfLq2rNYSARojIkYC85prFEXEPs0V95/OKBrlnz6tWd9s+Q4Zr7+8gOLheP+/obt4wlNZblZcDwGFoMnVyMPsSprxN6LKcN6y9NuwhtNmCLD4Oj6nv3zgcXCoaxnOo4475ljwlqDcx25KoyRrxfnyPHpiVf3n/C93/gN+s01xnfNVFOpMVCVxl/d0F/dyNqzCHibhj8y2rJ585aH3e9ASWJK8h3j4ShgddWaxyqr7TwFWZU7i/EOpSCMgVozi7s7rj7/Ac67pv+TFX5tWkaJWazUEgFF1Z48zjz/5EfUEgSzpDS1qoYnksmcrrk5isUlrZ2jW1+xfHUv6+EYUF0vzRQVctP2lWYcso5CZXz/U8LuGdMNHN59waZf4IYVwmdCXPw5SxNaM+l0gn5Nd/NK3s829YQqDdwZOdTW+TVmqIl4OpLGo0x9UxDTiu9QWgw2sspt6/baMFvGEvdbVIgywayQTyMgDWGhXuI1targLMP9Pf7mFqsgHXeY1UrSf6yn5IRxpk3mmi64vVfdwuGWm0uzr5qxiyaTgDa9jomqPapG0nQi5XiBv5csByHtDDVH3KK/GG1omCjT95huIbD6IpsKtLjIKUWwWbpKolEz7J0eH3j4wx9iqWSjqTVjnKZEuS7rhRSQcyGHhHGWME1UKt0wYNBy78SAtk4MRik1yYFBqUKeMzmKZGP5yVtMJw75mqM43p248Ms0k9s/M32PGwbGw4FwOOK7jorGONvQZgnnfdPJBjFr1QK54JYL/GotMoYidAPtrWhJi0hrcszy/2eRz4QQOT3sGPrhT+BX7Uv9cWuOmZgL/9N/5T/g9756mU6/1Ev9otW3bkS/ejeiauFqaUhFcdoG1mtLPzg+fJgIIXN77RkGS7/wbHeBaSz0HaxXHmMMp2PicIzMc0TVgraat2+XLFa94J6mSEoF6wTPZKw88I7HxNdf7chR0lw2Vx2b6yX7Q2K3PXJ7O+Cc5fHhgPMKNww8Px25WktSTw7y/QRJKBBsYx05Z7RSTFPk6magYnh+3DMM8hp1CPjVkjhHrNacxkLXWUzDvZz2J0qGz37117l7fY9fLdGuZbOnJJGJvsetr/DrjcQnliy6vKpQnURUEie6Rc/q7VvGdx+YY2F6ft8YnYiBwxlCLeKCP/NOjRFziAbjDctXb1m9fiMpM7ml1uhm1mjMU9mtiraRFBmfnzh++EANszRnuZJTpJw1jDmjaiKnhDUGO8h0b/XqFYvra3SbSJ71jxJx2SD4jdWknCPnwun9F+TTHusGSkj4bsH08CX69WeCEVLIVGoexegTEwxXdDf3suKPU5usChOznlFDOQvrsxSomfHpkRxmjHXUksSd7xylZHQV577YUdqKWCsyhbh9loQrI0aekiLaW2rKVGUgNVRXSYLK6gf81TWWStht5Z46TQ0Ez2Vqec5EJ4tRTVuN7ZcUNCpXSZQ6N6HnRpLmFlcaaiROJ6gVNwzUkuVglQoYTWq4sLO2uNSCMQbXrTDdAt31YvJJLdYTIBXR6rpmumoSiWm7Zfvjn6BLlVAm5GMpSQxmGlmX11yZTyeMUuQk0Z3LzUog/0mSvrTzDdHU7qXQOLM5k2PCDp71p59g/HniKsY3VQq1jG3aDYTanPwyuU/HE/3Qy5S5VDCCafKblbjrtSbnSjyMlJRwqwHr3AXJdAk0qBKpWmNA9UP72WgSEaOZn3cMq0HOPS/1Z15jSDwfA//KX/8h/85vf/FdX85LvdRL/SnVtzcr2cqid5zGRM6l8UAd2+dAToXrjWO99GAMj0+BOWaWg+bqqkehOewTu8NEDGJ66HrL27crrLOEkJmnJFrOzuCcNFlVaQ77yPt3e8bmdr29GViuerbbkdMpsFh4UIbTKeAHS05w2J5YrzwhVVk/14wxAmkvGFIuUCMhZsIcubldMM2FME0MgyNG0dYV68gh0veOaQpYLdPEOSQOTwec6/j8V37Azet7utVSpoENS1NLQfUL+ptb7LD46E5XTROpC9VI5jUNGD7c3jHu95y+fg8l44Yeba3o5HKRaWVr7rRqYHetcasVi7tXLK5uUUZW4qJh/Ojq5gw0Ny2NJmf2H95zfP+A9Q7tnRicmtrwjNqhrZSdd7hlD86zuLllWK25xFk2oDtNVyedS0NbGUuKgenpPTXMGD+AMqgs0ziMJuye6K9F81rHIyUnSk7oxRVuc01NM0T5/FGi/RRJgUgfqtbSwOZE2O+IxwPGdaRJcFDWu7Zyliapxkit4ghXviPFTNofMUoLN7JkMWI1qgJaX/ippSTRZ3YD/uoGoyDut4g3X6bgpAxGstZLkmutFWouWG9xizVVyWevvOecFX82ztQU5LCgRQqQo0zATddB+y5KlyYziChjm8YWmZS3RkubHu16SdsK7bNtBiPtmzsfmSZXZZh3O7Y/+SNIM74TuUBOwtLNMWOMBmdIWRKYVIUYZpSGYb2WiFTaQUGD0V4Ojy02qpwRXI1WsPz0U8ywEFwZpU1zz62v/KvWil3I64jzxLzbYp2T6XwSJFNFIlVriNJsO0uulVQyylncciHnohahSvsstHeU03T52dCdww+eqjT7r94J+x5Qzvzxfru+1B+rQsr8/ld7/qMfPfJ//mu//11fzku91Ev9Kde3bkSV0jxvA9bC7c1ARbHdCWT6auMkIjMrHh9mck5crRybTUfMklN/PAjk21jF5nrg5rpHaS2JPVMiZ3Be470RPWeG7dPI9vHIHCJaa+7vpXF9ehpJMbFcdoLziYmud+SWIiP80orVQKkYZ7HOElNlPgUWC0tJBa0q17dL5ikS5kDfcuwF4SMQdtOaqnMW++k0k06Bq6sbbu9fs766olssBDlTIJdE1QZ3fU23WmN9c6ufqZW1oHKV1CURwkIRpuS03ZJOYpKxfYfre2lacxVNXymUJNMupYDzevz+NV1rDEszJZ11oPI8b7B6LXzKsN8xfviacNpjtGqBAVnaqJIJMRGmGdsSk4wxuNVAf31Fv9rghoU02rYT573WjTXf8E9nZmithMOeeNxCw+2ATGj1IH8XpSAG5qevJWayFlIM2MVaGsj5+JE32mI5qYUqlmtpfnOghJl0PBHHSZJwcr40RdJLSjeYc718FnQ9OWem/Z7Oi1GnnJma59ejlIQMIIlMGajO4xZLTK2UeZRJcq1iKipisCshfZxsamF3Wm/xq4004I1TiXOiGy2lUQOqmL2UGGdKEl6tbrGdSsu1y3o+SvPnLKqcjWug0Cjt5P2uRZqzSxOqLpz6WsSFjtLMuyeef/pTyijxn7U2/bMWrJG2AsIvNZNjaZrNCMjPhja6HZra3aeNoJFKoWqDQtz8NDe7WywxzpKm04XhiqpyOGiBATkGtHPYrmMaE8cPD3hvL+a22prRWiBNgqeynaN6LRIEaxmuN9iug8bpLTFffsZpxjvtHLXWRh8wjLs9ZU4XRFfOL4aYP4uqtfLX/t7XPJ8C/8Jf+p3v+nJe6qVe6s+ovnUjejzMbFbScKaiOJ0SRsvaXZzxlcfnmZIzd9ddQzbB8/PMfj+hyAyD5eZ2wXIl+rs4JcZJVnLeG3wvJpBxkrSk56cjlMJ63bFe98RUeX4e0UqxWvUyuTQK580lE971jjBHjBH+JRq0kfi/GDOd1yiUTAFz4bCfGAbLyg8ttckAlli1rBi1RltPKrB/esZUw5tPPufq7gZtbcsCN5Q5UJVFLzf4xQrn3cc8ljaZrOcH2qUxlOnMfDoyPj0wPnygxiQ8SSMrTVXaKjlCRZpQlEJ1HYvra4bbe2kMG/RbXFGt0UK1KaJcSU6Z8fmReftEno8CZW8JOTkE8jnKtMHesQZrDX6xYHlzS3+1wZgOqkY5L8xJBdDA482drYwhx8C825KOe9ErWktFJoumc5eJISlRSqVOI2k8YbsB7bx8djWjTFvvVmRSeH4PzzrKEIjTidTMW9KgyXuhrJhOVGmMy/OOVWuqNqQ5ksejMGG1pjStoOLs2m7vY84UCqVAtRrfLzAa0nS8bLrlY1UNh5VFq3rBcWqM88IpNa1Jdh7ljCRy1dr4p1Wae4RVmnNoDSrQoPQKI5LYhgxTjdEqg/KKoqJNL+xQoxp94Iztl2sELjGfyhjm44Htlz+hxIgdmjazyPt2jvDFdlQUdQ5yUAyRUgvOWUmUag0mLeEqhdgc6FYmsihwYsAz1mEXPTVHwSVdeKkareX+zdMkrvnOE0Lg8O4dujZubgkXM1HVglxSuYUrIA1sSZnhZkN/tYYYhfyQJcY3xYjpukvcqrJOtKnAvDsyPW3bdNzI1y7f+JBf6k+t/vX/z4/4l//y3/+uL+OlXuql/ozrWzeir256/OCY5kqcI51TrNYe6yzbXeR0klzv22tHv/SMp8R2F5lOM0ZllquO65sFw0K0mfOUCaECmq7X+E4SUPaHyPPDkfE0oxVc3Qws1wOnY+R0mlks5YGYkhiaKsLx7LzBecvpGCipyHRTGUm8iVmGj439WVFMY0SVRN/JRA/EGFWQNV2JEecl2Wn7tCPnwmZzze3dPcvNWjR5xqFbXGLtevzVLd31FSonyngE23FOwZEuqTWHbXJYgPFpy+nDO/I8tmQq3f7TSLxnSsJutAZtxFzhhiXDzR391ZU4fFNou9+2Zi21GXCkCVVKEDuH9++Ynx4vMY+aCrkSs8RPhtiaUK1wzuGHDr9csbi9o1+tPupMrbz2NgKE1ugoI/88zpM01fOpIX+KuM2txbQY2DNsvyKTkJIFWG58J4k/WqOMk+YnNuj6OQdcOFTUIqD0NM/y+WklefEARnBMqihpQEuRyarRVG0JpxM1BEwzxJWSWzoWl5QoERVLC5ei8Gz79QrrPCV+Y/KsuERJqlxIIV0OA0pr3DDIgaVNNbFi9qvnZhAEWYRMAksIlDBSFWKmgYvpTN53i66OGiJ5nskxYnrR7mrXY4dvgPm1arrH3OQSNF5sBW2YTkd2X/5UUFJDJ/9fTKKrbrIGrVSjJVTc0BOmGaXAeY/RCm0sphOJTIqRHCe5V5X8TNcqzabt2yTZeZSVkIiSC6qW1hTby9RbW4seBuI4cXz3AQPCIJ0DSsl9W0rjzaqC8RYSlwjX4faabhhEwqKVwPGp1LM+GsjjBCjsUt7f+TRyet6jCmgvcajo+rF5f6k/lfpXf+sP2B4j/8Z/+Eff9aW81Eu91HdQ314j2nv2h4iqld4rVpueohQfPowtPtOy2fT4zrLdzjw8yUPGaVhvBq5vB7y3xFQYj0mmSyiGXtMNFqVk5f74cCDMkX5w3NwspBHczdRcuLpZEoMwNr23AqvWGo1MnlKujHNivV5QlSFG+bO6ZchbJwD6w/bEYtC4xUBOiZoyBdmUEzPOGryzpJx4+PqZrlvy9rMfcH1zjW0uYONlzZxLxizXDHevsc5AmKUp84O4uLOsL9V5qlciFU0YZw7v35HHk6zTZQCIQia4gDSFSqQFtSUNdVfXLG/ucMuNTPyiTAnVed8q/KKGZhKd7TROHL7+krDfY9S5+bGUUslR1twhJFKMogXte5TRLO/uWNy8Qjsn00Ftqea8hk/SHJ4necajrCNMI9P7L6njSeJZz9IA3TR/KZNCRFkrDUiKxJRxiyX9eiOvvTZg5aW5Fv0gJV3Sg3KMxOOBlKKsolvUqmoYKFDi1i8FyS+3aN9RSiVNIyrMDciuGugfaW7bmQEqqsqEL+WI9h6jtRigkrzfuhEGgMvUmSpcyqqAmnF9jxkWH93xpkWxlqZvzS1e0lioihJn4ngUDaa1WG0kEMDYhsUS006ZRnIMYiyLM8Y57HKF9l3jvH7jh1fL4aaW1FblCm0d42HH/uufklPELwaMVoRpJhwlOIHOoYwizqKL1c4zn4LwX1tMqTEW1/UY52VKmpJMR7VqwH9BJ7nVAr9eyfZdflipjccrxzOZCudmVrJdT5wTx68/QIiYXiaYZw9cpU1q2wtVWmO8Y9wfGG7W9OuVyBuivL+1Tbrz3GgR8RxSANlGioJpd8Agn98lWSrnCzbopf5k6//+//0Rf/vHz/zNHz68ZMK/1Ev9Ete3bkSftgGnK8ulZbHqCBGenuWBdX3dsVrJ9PDhYeTdhxGtCsvBsV53XF33GK2Yp8Q8F3ISvuBiKcYkpR3b55nnpyMpRtbrjuvbJTlV9rsJYzWL5cBxTJSSWQwdKSaMVZSiCCFjFo55Sqw3S6w1TONMSglnLaUUSVCqcNgdWC87rLPy/3tHajozpRXOaAHuH46Mh4mbu7e8evuG1c2NwNeVwvSiF82pYm9uGe5eSdLPfKKeYyprW8WfNZMXnqhi3G45fvklSjVDTJapYmkPWjF1iOxAW4k1xVm66xs2n/0A0xBJNc0fp4RawspVNZQYZN0IHB+fOb77ihqFlaq0Qres9pyqTIenCUqlXwzStPiO1e0Nq9s7WanX2vSlpsWanh8azYGvNVjPtN+Snj5Q5rnFTgqQXTsnZq2cSTFJylDTcBYK/XojVIHLOPKc+15ag1dQZGnukKlXOOwEVG6M9LgNBVmThCuo83VVmYRqKweXFMNFKiBNqpTWipLPLQ7SzAEpRqzvsNaIHvPcoDRZhSRcIV+rQq3yNY2u2H6B6RYtNbU2rakgxEqYkchUaS4phTSPpOkk3FwrAHdJf1IXnFaZR2nircVe36HHI3UasYu1IKAUMhE39qM6o0V4KnU+oGjG/Zbdlz9G1Yp1go5KMZDmSM0F4wzWWXIq5FzwiwXjbkeeI13vm4pW3ieMocQkSVfOQS3t3nVUpYUten3V3i9I8ySHkLOLC5GhVIpMdX1PTInj+0eIou1UVAl5aKoWpVRreuVrnD+r/mZNf7WRnyslB8CqlIQkhCDUAmfJMUHfyy9A3zM/P2OdRaMk+rRWakhUBSm9NEl/kvXXf+dr/uLf+EO+fB7Zjy880Jd6qV/2+plc88uFZbUZOBwjHx5nOq+5venoB0ecM1/8dMeH7cx6aVn0HddXA4uVo9bCOGXmWVaDxir6XjO09fmH9ye2TweohevrBZurgdOYOe5HlpuelBXjFNEU1lcD++0EVJZ9x+EY0EZRUsF1jlpgnmbICaMU8xxZXy3IuXLcHbjaDKQqaBprzw9rh3UCaS858/z+kZwVn/7gV7m+vsX3PRTQVhKJilKgLP2bO7rNFaKRrKhhKY3hOb+7tOz3ktoUR7P/+ivm3RPoSqnCqVS1UHO9TNWUUrjeX0gydhhYvvkMv9qIc7pWyjw1UP15Csjl7+t+TSmJ55/8lNP7r9GqCs+ySuOT5tQSHMWNb71FF1ldau+5ev2K4eoafW48jQEjaUfkLMxJAO1QrcEbP7yjHHeUaWxSh9Zg6JY1fx7RtZU6NVKdZ7h9jfeDtH9N10mbZKIEGaSUolqPqtLAzbtnSoPMizvckoE0nsjTjHEe3Z8Zo6rhfDK5BKxzYAfyHMWQQ21Ts7aKBaoSDWaMiX69hpgalJ5LTr2qbXKr6nmASk2SaW+sxvoFpl9AlbhN5Xv53MJJ0qesQ/mBc3RnnifCfg+mrfjPk98gLM6aC2WSyaBxXhKRKihlsKsrjG/NoQKlbNP4NhNabpzVBs0fn554+uKPZK3uPLrz1FKIDY/mBo9GkSaZXPuhI84zioIfRG6i22d5vodqChfdJVpJgpWVSbVfLWU1HiMYmabXLNPhUgWpJTpRhbGeXCTfXtWC7j01BNJpBntufm07r+izMkL0qps1i5sr8ukATaMtKVK1Iahksi0SBmmgtbOcnnYyhe29mJlKbcguqEpkKi/1j14/en/gf/5/+5uMIbN/AdK/1Eu9VKtv3YhuNh3LVcfxFPnwMGGMlhz5hWM6Jb766sDTIXK1dDinxZS0dKSYCXMhNI/J0BucA9d5Uq58+LBn+3QEqpiSNgPjVNjtRjabnnHMaFXpvWW56jkcIyEk1lcDuYC10vQUZSkx0/eeGiFpxW43s9wsUCjiNLJcL1rOvEZriFVhEGap9Y4wT+zeP7FYXvPm+z9guVrgjMQgig+oUuYZe33D4tVbXNeLOrKIG55UKdNRpnHAxa2kIM6B/VdfEQ47qIUwR3RVOCcmHkyhVoGTn13sKI1Zrrj65HvYxao1aUXW8Yj2U5k2DjSiOdR9T5pnHn74+4THR6xz4lY+RxgWpNNSWiSDqtL1HdPhSNWam9f3DOsNqk33tHa0MRvSjfORAtAc2dPzA2U6tShJcSajaPIFadDOrp5aIrUk3GbNcHMvzcgsSC89tMjOKvgjaaw/Tl3LdGLePsuUUEnMqKRhJuI4keYoDm4v0galQHtHiol0mpvkwMjfp0pKT06iwzROppoxStOqoF8uqeMJt5R7KDeDDqWibZvW1vMmX1zvWoNbrCTUoNEOdDc0c80MMaKtR3V9kxtI8zoftjL9tlZc3gri6Yi23SXtyPaDwOcBaqaOY9NhWjmUnDWWpcgEMGdqbUikWlGdZxpPbN99gVGI2a7F0MbtDl0VpvMYa0khiLTGWOIUUEZei9WaXGsbNJuGUkqyzm5doTZyP5acZIpcocwSi1pjQqVMaRuAs4ZYaYVerKnacnr/gTILtxaK3Ke2ueS1EgJCqQLgr4VSMilnrq/WxMMJ23ftINMm7GddcW46bS1hELob2H34QD2NuMXQ8FEICqqtirXVmBd80x+7aq3MqfDf+99KJOccyz/8L73US73UL1V960Z0WHp2u5n3jzOqVm6uLIuFYxoTX78/MWW4W0uU5t39gsVgmadECKIFNarQDQbfWbRWhFD5+us982mmothsetZrT0qFHDOvbheMsxgkdO9wXpOrIsXMct3Lyg0ARakKRcYoKDEwHmcOp8ir+zW288xTYHm95ngKkpgDhKpxzmFLwg8dx8OJ3cOO+09/wKs3rzHWY1x7yDf3eSoVd3PH6u1nsqZvGeqkACFIf0fTu/keVQSbM+5PPP7wD0jHQ8vWFic1WpzsANoq9Lnhajngi/u3LO/fXpiqtRbqPF6+RzXf0LIpje4c4/Mjz3/4Q0oIdIuWCNO0tEVV0ji3Pw/KVEoszNPMsF6xefsWv1xJ/6w1+B7RWuaLjlJlWVeiNCkm4mErOfalUrWWVbNXbRIo5iFBLGVUreSS2+TqtTjGxwPiwneydjbn3G8jK2vVFvjTyPT0gRJaspE18meoxNNJGhcvjnPmGTUs0c4Qw0zOGdc3ze4skxjTnTma5zjSDPNMUoqsNMPtDTpHSvVU48SsU3Ibl8rK3BhDaWthVYWf6lfXmMWSOk+CKrLS4BIDdT6iXSdaz4Y1ynEmHrboMwLJCMaohISyXtbLWjfvU0Zl+WzyOKOVRXvftI5VaAQ1SxxoKXJfIp+Vcpb5uGf3kx9hpGVuNImEGmdqyGi0SDpKwVqLHizjbs/iasPm8+/x9NVXPH/xJQvnpAntusbCNxjfjGXFYDoLqpLHgu2HZmRrfN3cptRWt0lqvkyMlXUcn7akccQ3w1U6HoXjWSsUQZ0pQFlZr5eamccjmzevIEWsMyjEpAhJkqMalivl1PBSkg42Hnbk0wnbGvnSJsdxnCnU9nk0icdL/cwVc+G/88/+FUILK3ipl3qpl/rPqm+vEX2ceXweMVpxd9OxWFjGU+LD48QUMoPX9J3m9m6JMYrxFJlmmUYYA93g8V4esqcx8/jhRAozzjtu156us0xBnLC+M7jOEGKLMFSQimI8zE3n1hqHWs5GcQlwqYXTMWEMvPnsCoWYLxbLJTlX4VLWijEarzVGVYo2PH/YEsbI9/7cb3Lz+hVaW7TRHwHbSqP6BatXd/SbG3Ht1iijsBhFq3kG1leJwWSeKCVzeHxi+9VXlGkWIxIaoyvaCnYnp9wCZLys73NC9QPL15+wvHnVjEuVmqXZVa35OpOZ0PYC59l//RVPP/z7OO3E1W8NOURxLoM89M954lqMHCllVnc3XL1+jXGDdNJnbqcWB1WtyEqelvttLCFE5ucH4YNWWXPWs/bStmuOubn2uUww+9s7hvW1QOVjkNhN50Tv1yDugDSZxqBqJZ2OTA/vZSCrjKx8jaGkQjyeKCkJx7UWSgzoxYDyhhgjJbfJWhFdbG0mI5liVoHxU6mpKVGVZnh1K4eaHMWpXZqru4Hiz00KRsws54hI16/Qi5UY1JRC98vmAh+pYUR3gzShOYHRlPHEtH3ELTdyMFGCwcpR3N1UYVwqY8jjUWQHy0VrTI0kJjXtsbJijFOm6XFD0w9rcejHaeT47ksMMtk3fY92hjwJZeIcl5rmGeMd2hji6US/XrL5/Hto67n55FNSyqT9nqHvmj5TdM6lys8pRkgWpCgT3M4LGilEWc2rbxqz0mWCqo0hHPak4wHrDLVkyhTaZJOWdCX3SEo0HFgljCeGzQo/DI1ta1oYgULpdl8ZRZ5nkXP0GqUgbPfM44jrOmqU6FOl5eel5IztHKaXCN3yohH9meo4RVKp/A/+pd9ifjEhvdRLvdQ/pL51I/r4NOKd5vrKs1h6xjGz3QZUhWVn6HrD7Z3ENJ6OmZSrpAEZ8EPXjEWZOVTevTtScqXrepYLw2LhOBwypylhrRakkjIolViuF8SUGaeERkwYspkr5FyZ54QxmhhEhbleebrBMYdCTplh0ZNTkgdoqfiuw1lLzZFTSIzbE51f8Gt/4TdZrJcfp5JJXLXGd+jlRjLFF8vGApU1c5lP4qC2tnE8M+eZaJwD2y++YPfua/FzaIMx0uCeDdaxTdm00qKRc47h+prV209xwwJoerowXR7IklbkLg1ABXJI7L/6kvHhPc4Kg9Q4id1EJabTKOgdJw9vZbjo/zZv79m8fi0P9nPj4jq5QBndXnBTymhJphon5uf3oulUZz1oFk2romlJhSFZjcSaamNxi6XIGYq45U3Xge8+Jt6c/6VlAkwKhP2O6bAVHFWtmM6AkUCCEiS1yPZ92+iL21p3A1nJitW1aVdNUZr+ZvSS1a5pU7pCKYmqNYu7KxSQxiPaWT7amWSyT/nofM8hAMLadH6Q+yDIpFJ5J9rgnKlhproOZb2sy1HE/Y5w3OOXG9GLak3JkZxEH6ucQXtPmWfScW6NlLjM3VJSjEhnIL0cBM56XGo7cFiHMpY0Txw/vBNDUT0boAS4r7UGpykxCdIJMc+FaaZbDmy+9wOZcueMrnD/6afs3n/FvNvjnRf3fKmQMsUoSbuKQgtQzlFTucD9a61tsluF+1oqurPofiC1nxnbdZQQLwe3mqoc/BQyhW46bkExweJmw7BZU6JILFSRDUopfOTX5kIeZ8GsFagawiyEiLN+VFlLHCVWVp9NfUqTp0iewh/jV+svX21Pge0p8M//23+Xv/OT5+/6cl7qpV7q56S+/Wq+U6w3Aq8/njKHg6QqOadYbTqWS08plemUCUHQNMZp+sFijTiFY6qMp0QpipQLSwP9IDDxXAWJ450GZRlPsUHGG1oHI3GSqkoEY4GSK9bKBMZaxXJpsc5x2M84oxiWA9MoU9RcxLVsEFf69mlPOM68uv+Ut9//nK7v2lRKnNcVqNZh716xuL6T7xvbA6lKDjkpihGnSC64MpZaIBxP7L78KaenJ3TJH80nigsoPUVZd2tjsM6Is/j2jtXrT3H9QM1JjCYximNdAVTJV1egjGvu8T37r78kHo9o46SP63SLBc3kNtW13slDvFZKLXRXV1x9+gl+uaLGBMqgvftPvB4ZM7dmx1iKUoTjnvD0QYwv2so1KY3WCuO9TNiCRFTWGES+2nX41RrrPDVOYvLvF9I8ncH+jXF5WcXPM/F0oEwj1jhSlrhO4YomaSpyEl1lg9gr58BasqoCUoeLo/rcdGljBIVUi0zkUhbOpYZ+s8EoRTwdZfKeWvIVZ8OUOM/Fud10jUrhhhWS857FlNSQTjUnmUxqLQixOMkQ/bAnTmOLfpUpcC2ZEmKTUchbkQ47eeu9p9aMsRa/FA7nRzbtR2lGrfJzQako59HakuaR48M7MULlj+SBXDK2aImElU+R838L48zi+orNZ59hrG+yCqhVoSqsrl+RimI+nRisTDRLyuRUsBaM6y7XVVJL7DoLSirkWeJaTe/b4UYx7feXBpAqk03dkpDyHKioRhgQBm3Olf5qSX99dcFAqUJb4zembEvzKkcJBtDWoJxm2p2arECupwCkRKXiunaQ6zw1ZeI4Mx/HP9Yv11+W2o+RP/h6x1/+21+9ZMK/1Eu91M9c3x5of79AacN2l5jGCFWypzdXzTUfC/NcCFMil4J3hmGwknoUC6djJGVIqRBjppSM7waMsZxGaWqHXjSBp9NESplSwHcdpQqKRVNJc6C26E2lJQvbGlgsBS+0343YtroNUzhTfWRVrSrzNBOmgMqaTz7/Fe4/fYvzXjSntaIKoDV2ucJfXdEt11zyvcnUlFt8JJKolHNbSTtSkBjC/Vc/IYwt6Uepy8O1FC3/PWVxq2uLdhq/WjC8/oTh9l6ajJzl66bUcsThIkBt6KCSEuPDB04P72SdryW60Tjb1u8QpkAplX6zBCo5RFCGxe0dq/vXAlnPWUw7VrSzpLnpF62sopFpWy6V6emRctxhjL3oPmspzcWsieNJmjfUZQ1rvKdbDDLBi62h6CVvXlb9GlUbXcAIaieHmbB7pqaM0VYSj5RqDZ40XFopqmuIo4ZhstYQSkTliremaSflerTrGtJHXZzvFcTl3g8M6zVWK9Is/NPasubP5h/ROZ6xXLKO19pc0pJqzijvUc5fJrASNCCmshpnai3EaSJP0yWRqxbhe9YU5bNoWKg8TqAVdiGoMJMs/uoKY500+iDfr63UpTHVYOTvozUpThzefUnY7+S+Re4j7S1KFaFAaE0aJ5EXNATV8vaa9dtPBRPWEpzQyFS+ymd6++lnjPsdcb+nUsilUEvCLFbYfgFGk88YJECV8xRTX9BU2llyhfF5i8oF5RuSiQrt2nRnKXOhJjmAaq2paNyqZ3Fz1Vi5pbFt2+FOWfI8X6b8OUdJSTKOaT+iEUlF1W0SXEpbNAijVVuDdoaUZZMiQRQv9Z+ukDJ/9e9+zR89HPjX/saPvuvLeamXeqmf0/rWjWjOit1zIMwJrQv9YFmtOjpvGafMNCZy42F2nWFYWHxnKAXmuZByFZj9GEk5cX3d03nXGtQs7vcKMSZKVZSqZYIHzamciSnJ5M209VzKWAPD4ChFEUMWFJGxhJBa39Yg5LVw3I/UBNe3d1zf3LLYrLDd8JEnqQ1Yh10u6K9uBPVDaXo9pLnKuU3JVFt1VtCG43bP9mtJLlJKHtgt1Zvc0oeUBtuc4MZqXOdxyzXD3SuGO3GQE8PF2CMs0CqTLmUuCS95njm8+4p5+3SZTKoiBwNtpPGZTxM5BNwgJpg4z2jfsXr1muH6WrSYuXx0jFdE25jzZaInF2wI44m4faSMp6bNU/IgP//ZUihIVreqbWJNwS1X+NUK05rcaq04xi+xo23iWmkJOZDDRNzv29pdk3MzuCiJgCztHhNtp26T0YwdFvjVEqcVx/2WcDphabpYYwSy7oysiedI1YqUEna5YLi5RVdBKNXcUFwgE2xoOleRBpyTgJRSIgOwgvYxXS9O9ZKBTA2hTTtlMixr90jOSRBCDT1Va5WmtTWhFSgpobse03lKmqFAt74WjFPJYNpnftbTnqHuDdCPMaTTicP7L4mHg4D7jdyzEq+u0U4SxXIRwoHoPAvDZsPy1T3W+caMbVUrIIgljENrw+LqmlkrxscHaoq4vscuV9J4NyYuLTkKrdGVi7ZXaU2qcHreoVvEpyQdyQGTIq76WquwSVWiJIn0tP3A6s09zosGFFMk1MGKtrmkRJ4bWULLvaUWnml/lBV+ETlLbXIPhUydldaXbUhJmZQSWlf8avi2vyZ/KarWyr/6Wz9kDJm/+Df+8Lu+nJd6qZf6Oa9vrxF9FuOA94rFsmO9kqjN0ykzjZKOY4ym6yzLtcOdna5U0YeOleNRNHWv7pZ4azgdZ9FM0mDiCpS2aJppWitZu2uIqeI7J+71JGD0zikWy56qFPMsRgbjHKVN5ZQG7TQpTJwOE/2w4dX3PuHq9gbrvaxE22q2KgG599c3+L5rJiFpKIlRJn+lIXtKlQdWkUSm3YdHHn/0Y0qa6LsOrT0pyxSvntFOIKtDg0xnrGN49YbF7SvssESdp4glNfeV+riyPueeK8V82DM+vmfebuXrG42qNEyTTBXn44l4GjGdRRtpPrrVhuWr1/jV6iNVysgqu4a5IaiksbxkmGvFvN+R98+k0xFrhU9ZWzOuu04a8SSNc1GakoOwJ1fXuH4QDaGRlbpSkvCjmtu/Jkm5wciUN08j6XRo+tJzZr38GX12n8M3Vt+ZmqNMXTdrjJepp9KG/fsvmWPCt1X52bWd51nuNypuvWa4vkLVQg5zm0QXWbsrha6yslZaDE0lJUnM1Abr++ZwP6+MReMp/VoCa9DKUOJMiTMpSvOrnb9grmq+xDhBreSWhmV8L274kiGW9r1kulepzaBGM5DVcwYAaEmTCsc9u5/8GEpCK4H6ayMTf+NcS+rKpHlGe/nfJSa69ZrF3T3G99LgadEzq5wR8m4B110+P43FOc+sNf7qWnTN2oiOuiVC0fLq5YdR/p7SUKzn8PABnSSeswT5GVPeShMa80esk9GQQXsL3jPc3uCHThrTFiCgXeOGpkKeJqFMyG8BtOuYjifSaRJc1Lnpz2Km096gvUUj2uSSM2mcqCXRLXuseeGIfrP+hb/0O/yb/+GPv+vLeKmXeqlfkPrWjaim4Lzi6rqn6yy5KI6HSAhZYjdrkYhLFHGuaFUkIa/APCXGMdB1htVmQQqBOSSc1RdlWgFQmtzyt8+JQrqKs9x6Q8qiFw1zYNkbhmVPTI3daF1z0xdiTJiGwTnujpRYuLp9w/0nb1mslxjnLrrBigZn8Jtr/GqNc6ZNw1RbsaaLrhPVGtcz5iVGdg8PHJ4e0TXiOmmECvWyYpWnI9RaMFYeeH6zor95xbC+EgzUN53p30xiarpTTAe5MB2P7H/6Y3Gqn6MiEc2idjK1nQ9HpuMR3znJCbcOv9ow3NzJhLfW5qxuufFRdIlifjLt68kkOuyeiNvnxs1sTniUpBk5I3zVEKnky1pUeUe3ucF3nRiZrGsTxaa1bO+FvL4qqCGlCLtHahihylRQt0QstLlkgyutGqC9Nq1jxQ0L/HIp74dWItswluXNKx6/+IKcJhabVZugR4mRVIpufY1fLuV/T5M46ktpWtKWSV9Kkye0bAIlznDtBzGCaSNs15byU7OYrpTzMiVOUaJIpwllZVIvP0xywBIskJjQ0jwBuk2oNbWmpg/tZCJ4wSTI6z5np18MXu3gNR/3bH/8I2oIGGtEetsYrtpZIQZkaci1c40xCn61Yrh9JTreFNtZqB26zh+cOuPCkANWmCkl0d/cyvuRshzuKigkLOB86qmXf8uovuP4/gGVM9b7820sX6NKqlgplVIVVquLq79Y6DdrnHfkaWzECSUHEFUpUSQ+ytpL5kJFEcNMOo6XDbtpko5cCtrp9rtGDn7izs8SJOCt6Hhf2JcA/It/6Xf4yeOR/98fPn7Xl/JSL/VSv0D1MyQrKTY3PcPgmafM6RiZ5sQ0yQRPW00IiZwKTjwszBNsd5H9fmJYOLrOMR4nvLdoCxVZEZbW7JUsrnOtpQlMtWK1PEhjlMSWEgNXqw7beVKbUNYqD/acE9TMsFgwzzOn7Z6aDK8/+x53b1/TD50wOZsWTqHIzjHcvxGIu+yn5eEbZgGQK3OBq8sUVJqg6Xhi//4D8+GARtz1pVZSW0+fTT/6si0VjE53e8fm7aeimayVktNHRFNpxqCGA0JZeQBX2L/7KfG4Q5OhYagohVoyxluomTRFckz4vsc6C8riVxuWd/eX+Ex1ZlsiU13pFarAwZv5KIVIOOyo0xGVBGtTkbxu471oC2n9T1vFlyIr5261xja3dtWSKqWUBV2Fi1nKR7d3c/0///iP2P7kRyyvNyxvX6HberWkImk9tVJTaDGXhaql0XfDEtcvP3IetZFm3mh8N7B+/ZaHH/8RZtR0fdfIBIZhuZHJ+TxLHOo5YrIktLFt0okcPEpbMSOfpenb6lkhuloliT01BZTxshouWfShBeI0SnPaWJaqyRiMlaazVkjT1JBhjlJLy5bXGNvJQaRFc3K5FqDIJB8jK3ZtDOF04ulHP0RluSdKEloB55jUpn2Npwm/HET2USq272QS6pwY11oMqOgo5drlQGAvTXQJE2k8yuTXajGOda5JJ6RRvSRVldIkDxndebZfvUflhF8uOIcC6LPmOIt7X1sjWuo2Eccb+qtrnPMSf0ttkbUG1bBXtSqZqMaKKtKQhnlmfNqic23RoE3uU0RXap0VvXFMVN2a4BhBK1wvB0Dt/B/7F+wvQv3Ff/8P+St/50u+eDoR0ktT/lIv9VJ/svWtG9G7+wVaa06nxHhKjGNimgKlFIwx5Fjoe816Y+l7yzxXttuZ/X5itenwzhBDYhi8TDIuJpyW0V0KoEltzSsjEphiwXtLzIpwOPH69YqEMEaVVpQK3hpySmgL3vcc9kcOD8+sru95++vfZ7Ve4TqPHTpx24dAwWCXK9b3b/DDohk8FMRCnSdpJJoGT1Vx0isFOMPh/QPPX3xFijOlFqxxksZzTunhozteNK3CfFy8fcP69Vtx56ckWssGzK9NKylPZQPOo60nxcKH3/3b5NMO52Tqq71goHJMGK1QRZpHtKFfLQmnkaIM61d3LK5vUE1TyHnSl7OwT0uWh/f5ga41cZyYd08tBSiB85dpqW5yBlRpOkD57LAW6zqZgp71lc4JVaClH4G4yC/rde0otfLwe3+f47uv0FpxfHrGLVb0i6U0bWcjTorE04hucHKlDW6xxC8WnPfSyrrLql9lSU1aLhfEm2uO22eMlcz7biUHjjpP0tAYC5R2INBN/yt615IbMqtGtLbY5QaljLixG3KppkAJE9r3aN9fiAO1KsJhL827E21nSeI+t71HeXGIl+OMseZCXNBKo2rBWP+xASqZWnVbG9A0obXdm8I3jeORw8N7jNaXCajxTv7OWepRIE4TxjlyFS2q7TzLmxuc74T32aQI54OCapNmaXhta7wDaTyKiSxBqUnSjBrUV8xzgJM1u3BPM9X27D48UqcZP7SwhAJV1YubnwLmbGZSEoNbyAybK7q+SQaUavIR08x78vvDdL1sF6yFnEnA6XELKZ0VLqTUpt7OYo1QAGpuB9qUSaeJnCPdaiVf/5fYp/Q3/v57/vl/++9wmhPzSwP6Ui/1Un9K9a0bUesM0wTHY+J0ChwOEyVLk2iNoust67Wj6z3HsbB9PDGHyM0r0SSmXOkGj6Li+44UJSs8zIVcKtZoeY6Vgiy3Nbkour7jsD+hgU8+uWKaMylFwS0peRCnEKR/MJb905an9zs++7U/z9vvfw9vmxNWGWqq5BSpKPz1Lcv71+hm1MFYiJMghy4oJlkhl1LF6GIdzz/+Q3Zff2hGioI5a/cuq219MbhoLWgb1Q+sP/+c5d1rYcSXRD3vCUumlniJZ1TKCshdGab9kec//F3S6SjYG9OMG7VQQkG3MPoYk/R3pZDGI8p5rr//A7pOjEHKdtJItGkrsTWhIAxLa8FYwvFA3D9T00yJSXBQyAFBu6Y3zbHxKptbXYFfb3DeQ5ipBtQwcIlSMd8w1LSUJZShpMRXv/N3CM9P+K5Ha01KkeevvuDq1Wv8YgVUynQiNb4pViQV3WotesTScmO1koODaozWrr8wXq/fvMV2jmm/Z7m+kdz5aaSMI8p5SX6qrRFRgv4555ODosaA8x67vqJqQw2T6Dy1/ni/aCfT0zbRV7UyPT+irMN2vWC/ahHcZ9c3xFAhHU8i7TxzW6sYq4wdxFlei0wotWkYLVpD2b6PkaYzhZnD44c2+EztcIOkkiktB72UmQ8H/LIXTW7JOO9Z3d3j/NCa20YmUOqyUpdprhxGRFNZSfsd4XSSNK2c6e5eCQYpZMo0UpUSegOgnHBcVTWMxxMqJZz38h7HRD3LDc7mt6aFplRSzmij6a42LG5uKWECKtr4hheTJreWeGme8/EkDXTnOHzxjnKaG3tUzElGgXIG0zuRHmgHSrYDKUZSCLjeYxsqinb4+2WoM+Hg6+eR/+G//FuUUknll+TFv9RLvdR3Vt+6EU3JcNgdOZ1mjqdISoW+k+nnYunYbDy5GHa7zO75gLGat59cM83SJFmJqqFqQ5wDBUUMidMYxdldIEWZOqaq0Uox9I799sCiM9y82jBOTbvmOmLM6FpwVoO1pBjZfv01KWh+/S/8k7z63ifyEC5tGmQ0OUSS1qw/+x7d1a2sYzWIjuAo4HiQh2OpogcFcfgWw5e//duMTw9YI7gn3Uws6LaOrOdJKNgWDeg2a66//yt0yyt52J5jQbWnTjt53lvRFIqzWRq1/fv3HL78I3Hmn2MNjUFrJQYepS9IHmlAMilkpmnGLxRpOtIt12IQak1uCUFYljFKMICzl4ns9PhA2j+jlbwG0JekGgWi/1MK1f55iqKVdX2Ha01HyRm1WMmavxS065pusq3OrZiVpsOB97/7O6TjETP0MnkCjPFMhz2H7ZbrfkArZMqsjOj4tMINvaToXJradp1Ki7RAK8q4p8aA6QVb1XmPWS3RtZBORygZs1pd3lvafWJUQVlpRIuSaFPXd7jFWrSu8yiGIKDOo3zWrm/M0vM9UJj2W2nc22TOWDnUlCanyHMmzyPaWnSD8aNAVyVJU8bKz0oMTfdcWziBEvNcIy+gNCkFDo/vQGlJmcoFaxVGCX5IWYNxWigCzjSzTsENntWre9xiBalhlkptklPVTFGqGc3OgstMHo+E/Z48R7TW+Nsrec8noTQoKmbo5b1phqFSCuP+SDiccJ0H1diiJV9kH5fDYNO/CmEg4jYrVnd3lHluhxvdEpYQ2UxJ7ecQ4nZHGEe6qw3Hxx1pd0IZTcpFEs28wVgD2qKaiLQiU+ocJkrMF+atcIGNaHX5xY/4nGMml8p/63/9l7/rS3mpl3qpX7L61o3o+3c7TqfANCVKqSwGz9AblkvHsOzI1bLbTey2ezabnmG5YLeb6HqH0WJJKlX4n8Z5MYmEyPpqYJozMbXExFpxTuO04bAfWa88i/WKEBJGa2mcikxKKpZMIc8z23dPLK9f89kPvs9ivRBjTq5gZbqTC6hhwdWbT+iubgRIL7Zo6nyCILiXShEdaNO6KWM57o98+IM/IIwHtLXyMGvoHRDwtmCW5OFrW2Rhd33Dza/+Gq4bGlMyU7UgfmqeUaZNZYyTh3DDAx2+/orx/ZfCNC3iend9J5rWlg6TGkvSWHOBhuuu4+b2hpor48MD/vqefrW4pPuck5BU18tEzxiKgtPDe8rx0JpQOMsiznnsJUWM6yU5KCVKjJQcccMgBq2Gt8IKR5OUUb6DGFp33lzUaE5Pj3z99/4euha65VLat1oFpQMMiyWn3YGdfsfy6lq4mVVWsd16JeYRpCmXBqYdNKxF2Y5y3FFDRPueQiEdj4Tts2gCbcQtlyjnyWG6vFaFRlmFckYasWa2sa6XaeXFAS76U4l01aIRbdgpqqHGxLh/bj9ZjoxqTWiWCXgVbqlSYH0vHMuUQCvRpvYLmRbns45WXaa153tF1BtiZEshcHj/ToxOyrYALE2KGWsr1p/NgyIh0U5wWMY4Ftd3uGHzMbCgpDYE1ZfDl9INW0Yzcs0z0/MzcZrxiwVus5aJdzvsmb5rf0eieWlN9HiaOXx4xBtL1VaCCbJwT8scLq+/NmZryYkUAn7ds3r9VnSbOUFV5JQwjZ6hzvrVWgnHI/Nuh/WW4+7A9LDF916m5U0yIN+3oFShJpoxKl00vcZ5/Hp9kQRI4ldtaWq/uPV0nPln/sW/znH+xX6dL/VSL/WPZ33rRvRwnAlBpmLDwrEYDKuVx/c9U6gctgfmeebmbo21muN+pBu6BmXXVIyYfGKh7xUxSBLOFApaKbQuGCreWpn0hMxy5ekXHSkDWhOT+OuttRijSSEw7faEqfDJr/4m959/SteLTowoqTtoQwbcas3i1RtpALKwE8lJkEktCUj0bc3NbQw5BPbvvmD71TsB8Pe96DkV33AENxxRzaiicd5h+57h/hXr+0/EbJNi07KJAaPmBu1u7nVJSUqkeebw/h3T4wc0Z8ZhkTxs+JhYBJiWGV9KFWmD7xiGhTQpVqHxjO+/wvkOlePlczgbbJQWtui8faJMo5CqEG3leSqmvWS0G9+JQ75IlnvJGT/0+MUK1db0tbSc+ZzAD7JSzvmyji8lcXh44PGPfoRWGt91rc8S/FBpSUWgcM6z//CAdZZ+fYOxhuH6FtN5zsxM9Ef9ntJW8sRPe1Qt6MVSOJDHI2G/RRuL8UrW4sZc9Lj13HpZJXzUtoPVClTXYfwAZ7e6YB0uDTfWf7xnSqKmTNg/y4TOddRcROvY4lG1tZRcZGrcHPOlFAgTxVrMagGczVFNI83ZjNR0x5yTxQppnjg9PUlyVq6ULAEKtUAOEWPkgFAaVN44S5xmnO9YvbqnW9/I16y0prBVKRepxrlqraTTkfj0RK3gl0vcavkxneqce98MVUIfqFAV0xg4PTxj0LhhuCQeXWD+tVCb3pt6PglV/NWK1et7VGlu+FLIIV701brrGx6tkA4n4vGEdp5YCscPH+i6Du3kd44Y0QQRZ7RpJj8x2cWYGgRfYZdLOdjF8FEaWsXQ9ItYX29HDlPkf/Gv/UcvTehLvdRLfWf1rX/DznPCWUPXWYbBslh6tHUcjonT/oSxivvXG6Y5E0LEeifJRqZF76lMihXrzCXxx1pNpyS3SBew1lKqIsZE31sqpsnhMigHSprVHBPhFJkOI8Z0fP7nvs/1m9eiSztP14xkkuM7+vWG7upGpi7nRqaUj7gk01BB+eOqMJxOPP/0p5y2W1mLa4HzKyMNQqkC1nct071WS+0Npuu5+vxzhuvbZuiJl56CKqB3pc9587JezXFmPhw5PXwgHw+gDDlnqBIPWmvBakPRmnyJTOSCUjJG4/uuaeZMS8Gp5NOR47svGK5vpXE+JwXVwrx7Zto9oVJLpaGKgeyMFnIWtEPVCKqQc5a1dkr4ocO5XlajjXWqtHAqaclQ4pav4EQ2cXj3jsPXX+P0GaauZMqVq6ysvzFVtl1HbzTH7Zbl3WsWNzdo4xtDqTmxLxpUJwai8SBpR76jpECeZyoV2w/CmGwNUG2xrMoYdJG4U2hg+ZwlBtI4tO/l/skt/Ukj2e2tkZcpG5fpdpwmqqoY78Xn06arMugV1itFIl21MaQoTF3jLHZ5hbYeUPL5FSEDUM56zfYJlXx5HafnZ9I8S2Pa3j+ZaGdsu59TjOQkjW2eE9o5Vm/e0t+8kvcwhYtJsLma5LBiWnhCA8rnODFtn2QVv1pRaxFQvm0GNtv+fBV5xrnJjyEyPu9QKeNXC3Tn2s9cvRyMSjML1ZSlAUZhho7F3Y3c+zlRcmqaZUEtaduMjijyaaTGiO098f/f3pv92pKm6V2/b4phDXs6cw5VGNsSfxlcc4tAcIW4RIgrc4UQYhQWNwwS3GAMxmCsxnZju11VWTnUyTPtYe01RMQ3cfG+sXY2Ainb1dVZ3R2vlFJXdp6z14oVa8fzPe8zjCPD45FW6ztTko57ScqoYER7LsA+ySahgnWO7nJL0/eUaWRe2svByIH7i+Waf/9w4qsPe/7m3/01//Cbu5/65SyzzDJ/yefHxzc1nr7zrDcNTRvIxbDfDZQUWa2F2YtRGpKmqZJTIgRHVgNSrfXsji8p450TF2/KNMHQdIGYqrTdeMeUrWQ2eqcVj9A0geGw5/i4Zxoyl1fPef3552yvL2VdrjmQeFl1m9Wa9vqGZr0VoJOTrBFL1TYl7RNXx7xpGkqpHO/uOH78wHQ4IiiyCAOJABKKsGjeOa1STLimZf3yJaub55JPqX30P+wmr0XMGEaDvamQp5Hj/QP79+8w2oducpaNrLMCEI0ha3D37Do3weObBmucghsrD9xayCnNCIjx/g7XdgKMz9FMD6TTAWs8pYqRBmsl1N9IL7rx4bwWpkI6Hai10vUdznrmTMk6u+ArTwavFM/r8jiceHz7jsPtJ5yKIUuWeJ1aNbZnPhwYQ1FW2rUtq+1zuuvnuCDmJs5R9Pqfzx3tRVqYTHDkNJFHMcxY38r7KkUiwjQaDNCO84Ktml0ZoyQc+CDreCfMPM5oHJc6882sbRR3famZNI2cI4+UVbYaTWVqOa+bDVI1m+NETQnXtoSN6HjRkHuckXvEeD2AmR9c50waM4e7W8o04YJUWWoMLNQq+tkquaSpyOEjjvLfXrx5Q3fzTA4e5/tR3j+5iibh3PcuytA8DeRpVPOYNA7lKOUWhCCZtLVS4ngGmBhDypXD7Q5iZnV9cdYoy3dN8njLlKi5SAKB0V56Z+g3WzlITaOA25i1djNo9qlclxInaor4viNOI8f7R5zz+ODIMTMdR/n6NjCbyNCSizgUUpKDQbNd0Wy3yt5rUgYVcsaGQE7xT/Ar9fd3Ho4Tf/ufvOMffXPP//R/f/9Tv5xllllmGeBPAEQvLlq22xas57AfOR0n2sbQr1piFDYxNHOOoJGcz6xRNnPPtbXChAbPNIrWtOssXRfIWeCFC1ohiSE0YrLJWGzOxMOeh9sd2Ib+4poXX3zGhTIns2az1IJteprrZ3SX17igru0sHfFCa1ogU3XlZ6zHdyum05HHt2853d2KoapWqc00AvRkay/5iM4/gT7XtmxevWH94iWuaYW5m93YdcaEZqYxxcxTK8e7Txzvd6T9TowpGIpV9swIIzMzTbUISMeAb1pcEyQg3wobZa1kW+Ypi+nECqAsaSI+3uPXa1kfP9xDjlisrNODsn5I6Lz1Hhsa0evFgVoqORd8aEQPCgr6wlmfKW/PKJiqKjfwjIcjD7/5luH+Hqc98iUXHKpBdFbqO4u+TxBAFwKbZ8+4ePVGNJazG33W5Ro1U6UoiQYKCvM0kqcREyQLtExR9afad64RVDlOUm9aqugfa8GFFte2UkHq/DnF4Ayq0fdqjMRgGUOOkkOKcVhnyFUc63Pt51wLihUW0KixqkwTvu1oLm70nKM6TZDVuLVyu2jCgAGqKaRx5PhwL+yg95LcoM1Fs3LAOkeaopiWmoacIr7xXLx+TX91rddj1kx6AdbTqEC7keuqWUclTVQDrltJ0sAkcW3WS6qDaySPtiSVYWCokvjPcHcLMdOuV3KYjFF+Dxjzg+D6JPewxnQVI3WaTnWfJT+1mf2xPFUjjVtlmnB9J4fHT3e4KikVaMEA+lprkZxj5z3WWMokebu1gl+19JcXGIOwx5hzG1UxYp7K4+nH/pr8vZyUC//x//wL7g8T/8M/+M1P/XKWWWaZZf7Y/Gggenm5Ile4/XhgGiYuLiU0fRzm6BT5heeswXtxqs6aONE6VmoxgGUcpU/98rLFeE9KRQAfaEC1PT9YjTXYAofbO477gX51xfXLF7Tr/gzC5G93FAz+8pLVq8/FlDKvb0uGND21+VRZORrvxVxjHPtPn7j/7huGh3sBfvpQk4eiaiY179AHfXBWQ3dzw8XLVzQrbffJClysw6D/W9uSpGNdwMj++7c8vn9HjVIbKSaUikV+hnX2XMso7FDCNOJ0N9XgjMUaiwuNPOhT1HafesY0ULEukI4n9r/5Fue95HzWQp1X5FiKeWIkxVQkTF6OkVoqYb0hNEE0taViQkOtWZUFTlkkRdkKTE+7B26//k6YV2upSISOKcgq14lxpqijeQYZrm/ZvHjJ5uaZFBvMZhp1TAsQ1OtirDY+FeLhURjoRrWRk4DNqmt0ww8ATy7USda2hoLvGsJ6i1FmeC4wON8vBqRWc36PljSeyMNB6y6FGbdGAGhJCd+vObdN6dq5JIlA8qs1zfpCAv5rgmrBzfpknjSiQqVTEYbz+HBPilHAlOaSClMMzulqXCOIXCvrZBcaVs+fsbp+JvpK3U5gtahhPMn3U+ULs2a3xolq6lm/XGKUzOCmUYOdyDmqMr1SXlCpvuX46Z58PNGseok9S1m0pDpFNZrWCjjMtZJLpr1c03SdfmXLLMEWk1wpmlCh6/oYca1otg+3nyiTuOdrlsNoRQ61ktHqsE04B9enaaKkRLte0V1cAkZMU/OBQ2OsXPCQklay/vmcf/e/+UdMMfO3/vG7n/qlLLPMMsv8f86PBqKPDyMP+xO1FJ49WxOawOPjKP9PNZrMTAogVZ3aLCTbOEfOsN8daILl8mZNKVBGaRZy1eC9oxgnK34n7vP98cjHbz/QuJZnr7/g6uaG1XaNAQ6PR06nie7iAkJD269YPX8pphRlfupsmHkSaiIrXjBNSy5w//Wv2X37tTpoRWfpvdM1bqVoDaJvxLmccyIby+rVS64+/xnBeWG16pPRxKgLviqjKc82R0qZ3XffMH78KKtJIyySrNWrrvKNPHTnNWaOEDw2BNz82pzDtS0uNBKmHzM1SVblHFwvhJzG8kzT2dWPs9hGAKxRErNqv7yhYKq48kupdBdX8jDPE9U6ATOaicls2FIdJFTMGdR/SxoG2iZQgJyUdbViriLmJ+aNjCmVsFqxefWSbnspjUB1NtFUvZaiY63nVan8zHg8UNIkzUQxUs5a2EpJRastJS82j+OZLas147uWRo0781r9nNuph6hZW2uKdLunYSDuH6UZySL3yexpihOuaSjDSf6u2RDnheXz/UqC19WYVDUT9CwbMWCqPfe5UzLjfsfx4U7upSxygFrL2cTj2hbnLHmUTnvfdQLKvWX97AXd5c35Xj6fUmqhTqKRNr6Rb4cmRZQ4Uci40EHJlEFSApzGcp3rws4stuwwavA8/OY9DBOhC6IJpVLGKKlkOEpMqn+W4PpSYBoHuust7Xol96NGZ+WURHObk5jZNmsxLZ0GfNeBsew/3hIPJ31tVTNW7dn1b60RjbATVjbHiZykvrO7lm3KXA1qvSRalCTg2ngn4PvPabPSv/03/4C/80fv51/JyyyzzDK/l/OjgejHjzvaVcPzl5dQDftH0V9ZC9ac0YiuEQ2+8aQBUhxpW880Fe7vD1xsG25utpwGzcLEklPR2HSDJYlzvlbuPtxx/2nH9uKGm+cv2NxcsFqvBGCWStMEjvs93YtXbN98gQ9BwEKOCkITNeezG1vYLWFITOiY9g98+sU/Y7x/wCLB3SlPAmKLvCZjDD442r6hpkLOBZqGq9ev2b54JYaKOApwUOakUoWBBXlohwbjAuN+z903v6YMB81MFUBsjaGkjAsCMPWxTskZZ4CupUyREBpC02CckdadWs8rSuDc6mSco5TZjFEJbSfXQHMirTq+Z1OGazxVjTmGSh4HjHOsnj2TNWWK4ALW+nOUjeR22jNIkxxUx/2799z/+iuC9zTaI17y00ElZ6lnFMOWweia1a17tq9f064258QArMFUo3mu4vypo/S2ix4xCgjNUVzo0ygaRzeHkCfRFs7h8AoqjbVUm2hCS9hcyHtI8WyWqdNELQljfxCZlJMkKRwemQ6P5/dvtZEKDKXKfVALkkeaE2UUkFOHAdd26i6vgBwcUPORqbNkxFKtk/+7Fqbjnof334uRZpiEQXbCPlI1QULD1ysS1F7SiAuW/voZ/dUzOZBkAdGARKDFqCY8f5YHGB8EhNaE63pqLuThBAiYF0mAVJPO2lJTRAttm07SJfaPNF13fo05TqJzVn14VtDngmTxTqcBv+lYXV+LWdBZVWUnXN9JsH1MNFvR0k7HA9aKS//w8EA+DTQhUHImlShNU3NTUskSKWYMxEQeJnIquODobm7ku5YSeZQVPxqxVWOSQ4SxmEYLH/4czb/33/4j/vCbe97eHxcQuswyy/zez49fzd+suLpa8/g4ElOhcRIlU42VdqGamaKEd2MspkYMGecdw3Fifxi4uVlxcb0ljRMuWIqxpFQJumI3gA+BOEY+vn3HeCq8+uJnXL18Qd+3eB8oURzFLnjatqPr1mzffC5B2VqvSKqQJ2FHNAtR/jGYIFmXhw/vePjlP6ZMGWtgSomUqzw0UY+ItTSrjraRWtIpTpIN+uY13WYjYCBNonlzDoowWGZeJTvtdXeBYffIw9e/pk4DJYk72VrRoxnAtuLmrdWK1EC1kgRPTZlutcL7ICkETqKAapnzFWe2UR3lWWJpvDW0K2GRjEoR5pWsoUrep5cQeJEUWHLOuH5Fs9qewbxpekzO6lqfDx1WgZOYOkqBT1//mt3bt5L3WmTNX2ZDkso05KOomCoHBFMNzXbD1WefE7qVbkd17V+tEswCWvN4kmQENTWNjw+k01FWqNbh+l7iusaRipEcVCPaV8mIShgK5JHgPM3mQoDgOKhLPKm2V1g0jIBSNDc27neMD3fS6oTkj87rcBsCru3JpxN2JbrIuN+LPrgWrPW4pj+Damu0PlSLAjDuDL5Fnwrj3Y6Hd7/Bt+GP6UttI3WaBgGEJWfiFKUbvRZ84+kuruivX2iawRy2r4x7jiKtMO5sJLTWSkZsTrh+g/WO4eEDeZrEKZ8LrglyX1qvbLuYwGxoOdw/EB92eBfkyhh7zpw11pw//ycJR+F0GvB9y9Wb13INnXze0mQmv5pKrTQXW2wIxP3+XEYwnI4Md/c4NeVl1TlXJN6q1oprAsbL9cnDRIwRYyvt9TNc01GnRMkTtgnyJ6coOaMYke0YgwuNJGr8OZj/6u9+xX/5v37FcUqydVhmmWWW+XMwPxqIbi833N2fMNbQaGpPrFZBZ8VrKPWYK02ZZB1bYb8bsBRev76E0DIcJ9rWUSscT4WVN7StESxlHfvdnrvvP+LDii//2pdcv37BarsWdmkqVCcPZNuu2bx6LbWZIUhou1WmJmmAugWjzTkYcYIXLHe/+CNOb7/WsPjCOI6kIiHW3kk9obOOEDxNKyvAVAr9m8+5/vLnOItE36hOEaesS9F8UGslVkj1hofbW/a/+ZYaJ9GyITE/Nsha0Pug7KKXB0hJ4sh3gTicaJtWzSSSlzlrCWWVbqhVwr2rMrm5VELb0HQrDWL/gR72vKIF3zaUXMhJwHiKEdd1tJtLAbcpQ6Myh7NOE31/c9uMIZfKh6++Yv/+nTB0wauOE2HqVCvpgsRSZQVfFkt3c8nN68+e+s2rSCZNrZJF2nbgCvV0FDe/OvPH+zvSMOC6Ht8LyyhVr1Y74+UQYGZwl1VTWiu+32CCGO9KnhT46nrdtxC0dCBFYbNLJo0HxrsPhNVGjVXicC8l61pbV7oKYMb7OwGlmmgQVmvmHFDpjp8lG2r8ouhBCkzJTKcju4/v8c5DrsQoAfwuBKgJoyH/1EocR3yr2spaWG0v6W5eyXsveU5mYt5agFFmFolRspbqLGU8YZoO23WkhztJEbi4wOSEadQ97uz550qureG4e+T06RMhBL0nIcckq3XnzkBO9L3SLx+HkWIr1z/7DMak5r/5XpF7LB2PhNUanGV63JH3B4x1TLsdw/4g18tIY5qzqAREfo847/FdI78OxlEbuirt1QWhX0lkVJywjcV2DeV4UhNhwlaV82QL1jDe3f5z/XL9XY/o1OEffH3Lv/Vf/H1JnFjw5zLLLPPnbP4EGtEjwTtMzVQsSasGvTU4Z5hyZSqFUCU8eoyZ02GkDZbL6w2pGNJhoO8COUOMlYvG0DaOXA2xwP7ugePDnu2zN7z84jMurjYY64gHqVZ0SCNLuLzk8suf06431JLIk/a8G2SNrCHiRNE1UgomtIz7Pbe//GfE3b1kTxZZjzsr6+GukTWrwRKaBhsM0zRhfMvm8y+4+OwLWfGOpzNTJ+YcBW3WgPGSO1hlrfn46SPHD+8IIVA0Psg6h+9bypQkFmdulFENZQgSI2VrZnVxQRojwQcxQ9UqvdmlnA1O8o8A1FgS7WZN6DeyYnRaj+k81VmMupyNdwIIi2QrFgzttsf3GwUvBUKrukiJLiKpltQ6AVMG4hS5/epXDA8PdG0jbJjz0kCk0V3S8y0fSdHUAd8EustLbr78uSAIrT6dV/BQVdcprTdiipIygWn/CBT6mxsBxSWTU5QVPEY1y3IIKVkD2pXmtt0K1/YClk5HqJlzPWjTyWeRNWZIc2dLHBjub/H9WuKKDMKSYgRAxYk8DBgfsM5Txol0PBKPR5p+Tbu+0IxWpyt01bhWIxFIPB2WyJnpeGD/4T22QtZ7OUUpDJiludaqaatkQtNSraHUTH+xYXX9QqUIAlbQa06R2koazfOcJsnFDT1lOoEPuKYlP+7I4yhlDAXw4r4XltpQy2xeqkxj5PTxFl9E54weiNLxpG1hgoLrvK2owl6OMfLyX/qruAqpVpVXV2W/IR6O2pxkKVNiethTS8EHw/HuAYqAcmMQAJkz1ljRfzorrHyqlJIkHcIZXL8SPXmKkrBQC21zgS2F6j2maSVrFpE/1JI53T2y//T7BURrrRzHxO4U+Zf/xt/+qV/OMssss8xvNT8aiDqLrO18oFRwQdd6VMZUpPe9iAP48RgZx4mrbcNq01DUyd20wkiSC+vekWJmTGJs2n+6ZzhFnn/+M569eU23XsGYROtYMsVCcdDePOPizWsaW6nHnTB2oZOH3JwPWqsaTYwYEYxjuP/A/rtvJTrHB9IURQ9ZCqVU+q7FODEZWe+p1gix2ndc/fyv0G8vKWk6Zw1KH7isx2uUvEMTGkzTUUsmnY7cf/st035H03eUKJpN33WCnUohbDeyqExJHciiGYzjiLUSjl9zEXOS7IC1BlFAIHbWpRpyKRgHq+0Frl2JQck7XZOas+4UUG1coUidEqUm+stLQtOJPtIgwGk2X81ahSCue2kmqkxT5PbXXzHuHvDBycO/ipO9qlmsaFyWmKorJld8G7h4+Zrtm8/175p744VpFObTaXxUwTSdMr+FeNhRciJsLlWDOeifdaqznF318tkY36g+VTSQtmk1VmluaFKm2DfC9EU14BkjEofhQDnuaTeXwgobq+UGYjTKRYLpbddhrKfUShkOuKbFBk+3vTkDc6wXCYR1stZXoFZLPhOWaRrY337QvFmoMRNzwZRMiZJ7aawRoK9gGWupZLrNhtX1c2VaZQVu9O+tGgslzVISXWashaYhDztKzvjVlng6UIYjthHdpbGBWp6SC6oa96gSJ3b69AmrRp+S5btUcsQYR3BGTWP6R0qlFIglc/Mv/pym7UnHIziJVLJNODPx1hh831NrIR/2Uk3adRwPR9KU6PqOOVUDI4kMsikoGGXfMYY01fOavr24gAJpnCi10Gy2uOBIhxNutcb6hjh60ulETgnrJXHC2PDb/p79U5v3Dydyqfwr/8HfXtjPZZZZ5i/E/GggWgHjNbvSQByjuF8NWKywHMkwTZFgKlfPe0IjwffFQq2G4C3GGuJUSblig2ccI7v3d8TJcPPqc569eEHftdQoZqFSKyll/HrFxatXrJ+/kJzLYY8xTow3szHJWAE1BarGzZQKh/sPDJ8+QBIWMU5zZJKAnib4c3ajMVKbWY2hu37G5eef0/QrzYusupJWzeEcBj5rT43oBeM0cvftb4i7nVZZiinLOHMGdb5tBahNiRxHkRs0vcT7WI9xjqSrzfmBa6x0cxvr9EcLSMxUbONo+hUg/eUze2rOgej1HB5fSpnpSXJOrG5u8D5IGLl9Wr0y52DOO3bnwAg4HY4Hdm/fkvZ7Bcr2DKZKTGjYDt5Zqq5nTamEvuXqzStWVzcioSgJze0CK6BZMLeyktrnXnNmfLwXDWS/0pak6WwUqnO0j5EwL1PU1V2LpAlYrfhUc06lYtcXcngBAVlxgtkoliJpOJJGMRnV2ZA1Sw207cdYp9FHysbmEdeIg9s2a3Fso5AwTU/b8dDoexc2z1BJ48D+43vNdw3kqZAnAf1GW7xsI8A6l0xRTbZ1lXa1pb98rkBTdI61lKfs1SppEOKMVxAeAmU4UlPGNj15GEjHg6z/rRxiiuayGmv1GgsAjjGze/8Rxkjb95JfWqPUcGKw3s4wWNf1og/NVC6+eMP68pJ0OmCaQBoGfNeev0u5FPyqxzaNZJfGSHd5yThOxNNAt5KfN/9eyuPT4cGFFh+CgN6cxAjXBLqbK6zzpP1RvmPrNdZ58mmgWg8+SASV87hGzH3TOEkZgP39MCv96v0j/+Z//n9yd5h+6peyzDLLLPOnNj/6N2zB0AZHzqLFq4o6nDGkmJliYRgj21VgvZa4lJig7RvIwvZNqQqAspITenrYc7g/0awuefnlS7qmwVVDHiIVMS1Y79g8u+Liy5/TbS/FAJOV6dJWl6pueEpUU4qArThFTnd3DLvbp4QhxGSRa5VYIgO+C8Ke5iT/vluxef2KzfMXAkzTKMyZCz9YNSJreeugEV1cSpnh8Mjjb76hjiNNK872mrMGbWt2YtBYmymRp6hxSqLxs8q4mVKV/bLC9GEoUzzH0tRaMKbKOt8HQt+dDS/q81Y9pXR/Y6zkK2q3NkDOiTgOAni1SclYDy6obrI8ASe5cJScGR737N6/Iw8nQuPFKGLUvCNp/FiMYtmnIPrQBS6eP6e/uhHG2qq+sho1jIuzv4wDGCfJAFbAUNw/UEoW88g4MNeb1lIBdUnrQUT0sgWmUSJ8vMc2a87VqhoSjzNUBAzXHDHIQaHkxHh4pJaMX62gitvf6tq/6qrZNi0uBM75ovO1TxXbrzUwfjZ3qWN/Dv2Po+avZnCONJ4koimLaaeMo6y/q4DJJ3e8aktzlWuVEu32ktX1c6SNyciBp2p1qx4oJA6qKpCuGOfIw5ESR1zTk8eBqDpcAecaCm/UlDjX5iIHw+PdAyZmmlV/DoCvNeO1qABrSXogMlU2D7kW1s+v2N7ckI4HCeWvopc21lDmSC8XsKERg52xNNstU4yMD3tazTGtmrxQc1FyW3TSLkhtaJ7ieSXfXmwI6w3xcU+tBb/ZYLwnT5Owr30v5QcmSkzVakUaTgyPByQ8/6ftYf/lux3f3R75j/7WP1tA6DLLLPMXbn58xaf3pCwr71qemmpiKgyjPIRe3PT4xpMrTGOmawMpZZLWaEqrkiMNI4fjgDGBm9dfcvniGW0jzFGJoofLteBCYPPqFZevX+E3l2A8tUQMBeNbKoWSozwgU6KmqNFFsL/fcbq9JR8P8mC2hpxlXWy9hMFbN/eWS24m1tJcXrB5+Yb+8gqDPhiNPbf3nMeouUXD/EXX95Fp9wkU2An7NOcaOrxzGC/MaxojtUhOYlUWy7mnVhvJAZ0rKZ+MQcYaSi3kLOyl73tCaGVVXLVRyaipR1kx5n52lQCUnMXBXivOBYa7T9hnzwntWsDRHHyOUWasApZ4OrK/vWV4eICSCW2roepqEprzNiu6xubMjLWrntX1Fe1qq0HxGcnSfHp98hkmud4KnNLpRDzu5b05ry5sYU/PABAUhD+FoMu/s9jQYJsOa51cR+ufmN6SAK26/IH2Ng4Hcs60Gwm5zympa13ZVmtwXf+UyKCfjZjVDLZfYUJ7zkevRQ8QzssBrtSn+8d50njkuLsjjidsrQLIUpb6S2PEdOMFlOcY9a1J6kKzXmlOqD9LO84xYroSn2tmAYlxqlLJKfdfR46TdMeHINmoFcppUGbWzRj7fBA5fPhE2h9oVyvJTI2JNAxaTlBVEiOJDnWWSRhDe3PJ+sVzjYSqlCSHHdv3lNNRGMvyQ5kG2tB1YPf+IwHRO8+Hj5rLOfoNKsFJLmnSdAFjKs16Q2g78jhRciZcbCXTeJrIp4PW5FryLMnAEKeJw+3DWQ5i/thp7M9uvv104H//xQf+zh994A+/vf9JXsMyyyyzzO96fjQQ9W1HGQZyKsSYz2L+NCW8g9W6wzcBiriwm8ZDFZYQEKbEVobjkWE/0W+uePbZG1abtYBCFbPVIuHV3c0Nl599zvrmGbbRXMh4OgOXqiYOUw3VaMc1lmlK7N+94/D+e8hFczmlx7qUivcOp0HVYtypxDyB9/TXV2xfvZYVd83CujhHNU5AT6nnh5IxUI30sx8/fuB4+4EyDBrcXygla2yRtjFpq48pkOaMUSdA3daKP4dmzxWPAkLnjfDcNEWVLNOCoelW+NA8XQtjsT5II5E6s40TBpkcsdYyDUfyGLHOa9QWlBQZH3f4bo2xXiN6RO8pEViOaRi5/+47hscd3gdcEJtyTqrJLRUTNEg+Jrk+1lCMpV1vWF1f45vmvKatqh2cc13niyrh6gIU42HPtN+fDz3WG6yfM0KRFinQrnJFfVnW+tY3uG4lIeW6vj/3iM+gczqpkUleS8mRNA5UoOnXApBLfcoSNZzD30vKYLJoaRE2XdIQes2N1WrOFM8lA2CeGFJjsC6Q08Th9gPxdJAYLK3KzElKGHyQz8k2njyJ3GT+TNtVT399c67ExBita61nrawFYSjhDLjzNFBrxjatNDEdjxLJZJ3KIqJ+z5TVdg6mRDGe/cdPjHf30rSFIU9yAKx6CCi1PkVgGaPymEx7tWV9cwVTFElD8OTTCb9ai15V24/MOIo+FgHQp+OBx4+30iTmnw46BsgpaW2o1tnqJmSWH/iupd1uhUAeTpjgRFubEmUYKNNIDTP7b6g5koaR4+5ATkUxfcb+GWsxd8eJ/+x/+RXf3R34e7/89Gf7w5dZZpll/oznT5Aj+oIP33xFyRlrDSllSi40jWW17Um5EqPo2azzIqd0slI01pBi4vHhiPU9L37+hqtnz6W7vD61ypScwQe2L15x8fkXktWpSKzG8cxA1mlUVs1Q5wpO33C8v+fhu69Ih6OwV8adWSyqBMc776UScxjJKUpkU79i8/I5q+sbfNPwFFOkjKJVBs0ooDECamqp7L9/y+nD9ypHFJd2SdrhruyQn93UKQp72LaUYpge9zRtI9fIzLJTf9b0lR9GJgEgGYnGWrp+g9dcx5yjdKRbBfQ5U3KkooYWNXClLIYpY92ThhQnObClMh33dFdSkVlnhq9WpsOeu2+/IZ1OBP+DkPo5HqgqM6xh5MxNQ9bQbddP1xU009NQS8R2QZjM2QDm5fBSx5F43DENo+SQOqfVkrpmViCJVnzasw62SM6kD6IHDRqhNTOQZ+Yzyj03o/wszvx4OGC8wzWdyAIMGIyuiEVikGMkDSdKTPiuw/eeUqIcAppWc1o9OCcAzYCxDaJjVWbNgAkNKU7sv/9G2Pj5frUKcrG4xmONOUdW1SwpCClOtOs1/c0zfNs9aXpVw2owT1pfZUCrNp2VOFLJ2H4FuZCOB4wmYNSk2a5GQ+tr0fs2Y0PL7vv3jA872rbVlbUYtuzM8qrGE2WqrfPkGAnbDZsXL3C1kqdJmM9TlHgtIA0DzeWFRqAVSp4o3jENJx7f3eIw+L6j5iSB9F7YcmPEVT/rk1OSAotaC75vWb98gdVcWeMdtm2p40Q6PkoOr7FUY6TtaZwocWR43JMn2SwUTYwQucnvfkqp/Dv/9f/FEDN//1cLAF1mmWX+csyPB6IvXnH/4R1T3jOexEW7Xnl8aIijPBxKLXhv8dZqVaY8EKdh4vH+QL++5NkXn7N5foXHUabZLWxJOeK6ns2bz1m/ev1UJ5gTJY6Y0GJDS02jPDRVz4c63x/ffeD07jthtEqlIpmVXvWC1jlCFwCJg6mlUKzF9iuuf/YF3eZCQVI5P+SqOtKlCl2yKWcbchwndm/fMt7fYo24cuPpqE5tRxoGgnfaIAOUhDXiro5RArabEBSoK1taq2QBpqRuYHWQa63mNEWavpUsywJlnPTniblpDj2vBWoSuQTK5pWUxDnuhJkrFAUgWvtpYNrvME1Lu76UYH7jONx+ZPfuN5hSadpOmeV0Xm8bA6FtxI2uWZg5SxPP+sVzVhdXZ6CIMp0lFwksd161ohoJpdmU4+OdtA25IB3qVAE8XoP8NVzfeKlCrSXp6ljuQ7faiKYXI8BI17w1RancnDW0xkqMV5443d9B8ISmVZaT80paAuQhnQ7Ew5E0nMAg8UY54pwTja8Tbe9srqLks45ZqjHlMyI4coo8vv1KtYzCZuuLEla7EW2lsUZag1LEhSDArutYP39J6Hpd/1e9VwXMoq1GJSXMzG6bSp5OkrG52kLJEpFk5HsrKnC5Vs6rY95Yaky41YrHdx9I93c0TYs1lqRZts5J21ZRHYD0wkv8V8oZmobNyxc4bb5yTavygkLoNhJ7VWHOw8V56jgyno48frzHGktoRdKSkmT8GjXaGSPFFrZpyFMWeUCK2MayefmM0HWk40lKINpWMnZPB9JxACe5vCVGmCZAWp/SJJuEWrJsT1wgjsNv8zv2R82/8Z/9PQ5j4o/e7n7nP2uZZZZZ5vdpfjQQbZuGzeU1d7f3OFvp1w0hNNRSCa0jToWu8UgGn8GEwOE4MjzuyFPl8vlLnr1+yepyi6tWgZG42E9DZP3smuuf/Qs020thHmuBOdOvXwlblKIGk3sxulipCLz/5mvGhztml7hmk8tDEolyCY1o6Io+9E3Xs7m+ZPvqtYTHy1MV+ZNGQ7iNAImSNaBeImGOt5/49ItfUOMoWlDnyHHCeoOpVvq+g4COnBPVFkK/wvqO0/0DNVd80+NmI4iynHMouqzyJWEADEkzNn3bEPq1rCXLDMYCJsg6vSYx3FRjdUVaKbUwjSepP9WMRnI5d5/Xqg/eKk7x4dNHnHFYF9i/f8vp9iO+afA+MJ0G0UtadBWqRhMfZP2bJdKnmsr61Us2N88FzKjuU4CdvGZB0uXs6jdUSoyMtx9I04RfyWq8piQgvfEqAygiWdD+8KrsqLUG5zyu30i0FuYMcs+tRQCNrv6VUa05Mj58EgCIE2bPVjBznJa8t3jYialJBBs474XjNFbC8Y2KNhptZIoR6wxzUP15t+8kRH/37msE/KEku5rRnMO1rVZiJtECK+M4Hk+0fcfF688kwL5kyXXVutGaxWxzVjTWejYY5ThRnJHYqzgR7+9Uh2vBFMXJUpBQ1JBVYsSvtuze37L//p2UO2DIOVHmRAeMHCww57W3sU5esqlcfvZKNJrDUTNYHXk8ELqOWgppkl76Wis4T7i4xJxO3P7mLZRKaFR2oRrq2dBGlUOEOPoNMGFNpTq4+PwNvluRTqMwpm1LiZm0PxKPok8Vct2KTKAJVOuI01HuFVPPG4rpzwCE/mv/yf/BP/zmboljWmaZZf5Szo8GoqHvefbllzzcfsDUSc0fAhBqgb53qu8UXeUYM8e7ewwNL7/8kquXz+hUD8o0SYxSjORqWL96yfO/8lcFfFQ1oUQBoaZbiyM3Reo06IMCAbp399x/9SvqcJR1XGhE22VRnWQlrHp8G8SEchioxpOd4+qzN2xevNQqFqNZjOW8zlcaVLSXTlzutRb2Hz5x98t/CqloSLl2WmfRxE2nCRcCPgTSMFINtBdrjG84PTxIpaNrJGfTGko10tSk7naDBIM7J+vGjKybm36FC60C1yxr6kYe7DVKQH1FWVKBqpQC02Gva1Zd+eYMwWEV3IqJrJwbdtLxyOP77yipMO0f6TZbWQePapIxRrq8a5bWIF2TlmkECq7ruHzzGf3FpWw0dZ0soE/eu7jcpelKBLCFPA2Mu3tKLbjVSq9FPgPcMkaq5pFaI81VQrBmDFYCy7s1YAS8Jqk+td1K36TIPrAGkxL0a8pw4vTpHTYEgg1noxj1qd2HWpgeHnFtwLY94/FErRXfdYTVSvWpcl3E6NVQp1FYO9sI0HMKfBUQ7t99o1FcRd6nF3MYzqiuVMoRCpCmJAYdDE0T2L56RejXcvCYFcu16s9zqpUFatZyBsjTSJpO+M0Vpmbiw6287hAoMWN9h0ED7w3gRftpfMPhcODw4S1d15NLIcVIiRPGONGtZmHxKYUmBFIWbWW0hosv39Ct16TdjlortgtMj4+UMWI2G/kel4TxKwHbSeLgDvf3ME00jUY6ZeS76bwwzc6dEyWqEbafUrEO1i9e0HS9ZIXGiF/rwW0ciIfD2VxWlYW1bYPxnuH+nhwTvvEYrIb1D4SgYP1Pcaoizn//v/tD/tY/fscwb4aWWWaZZf4Szo8PtO/XrA28/vnPeffVL0SV5RtSEpYx58xUYLNqyOPE7sMDq81znr9+TX+xpr3YSIvPFMEY0hSptuHlX//rrJ+/VDOHgMGaRmFEQyf6vZyopwNUg2nlofzw9h2P3/yaPA1CNBkxJFkjrvKaod30uKbRyKlMtZ6w2bB6/pzt1RU1aW7kvHafQ/GNZWarTGhkdZ4j919/zaevvpKVe9diNUDfWKT5xljaviemxOnxkbZraa+uyKUyfPhE8AET5iBuKwYRYyTCqWSscUocFlJSPaSztJsLqnH6wM1gxTxmnKdMUR5scRRjVJEu81ILw/4BZxxUr1WeCVMKLngx+phZsyk6z7kPfHzY4Vwg9L0wwykJa2oc1RkwwlKS8zlg31DwXcf2s5/Rbra6jY5asar/OC+AzDup0qRIHmiMTIcdlYrrN6LpUzNNniaRUeSC8YGaK8WAqbJ6N4DrOnzTC7iP4pamGEzTgdVV8byhT4nqA8TI8Ol7rAtY36pBS6tSKZBFEhAfdlhnsdsVdZLPODSBsNmIMankJ1a3qpa5Jkzby2HKVj3MOEqt7L77mhRHTJEMWbwlWEfNVdIOijjbS6wSV2U9cZLQ/Os3X9KstnLfqqZW+u6lN97M+bDGSvlAzpRxIp6OuO0l1nviYY9pgtTiRgG5pSC6S+vFyDONGAw5Z47v3tL1Pd53mHFiOB0p1dB1rWqSCyXJ+0u5kLLoZTefSVboeHtLjomwWlFzpE6TBNVnkbDUUiUrFUetE6fdI8PDDoudzyuyJbBgkEOjAYwTfWc6DWrGS7h1R3t1TYmZfDri2p5KJU2ReDzIdzpYTAUbOvxqTakw7Q/EwyhrfiMa2WkaCUGNf2py+21HdNqV//4PvuVv/I//ZGFAl1lmmWX4EwBRcfl61lfP6NbfM40DY8zi4E4C8trGMu4PnI6ZZ5//nMurG5q+p1nLSo9qxIxRoXv+nIs3X9JeXKvLVcmKNGntpK5WjZEg8FKgaYkx8fHXv2b48AFnjJh7yKRS8U6D272n3ayw3igzksgZ2usbrj7/guA1NihXrY1Ut3EputrU3BsrGs04JT7+0z/k8P6dONW9w3nJMMy5ksaCDw5sZTweyKXQ9h3tdi0AfX+iaXtmJ7z3XoGdZDXKAv4pkihHiaRq1j1Nt1LzijjRTQjCZnlhGLECavMpShail5iqmBKhXckKPRVylPB327WzVFNB99yuVEkKnELTYI0YmFKKT9ejCFCvzoiSwUi96RQTYd1z+cXPZWWc0zkm6IwArdVWISs6whwF9IwjadjLSrrpSKeTMJneS15tkiB0oxWVgk8qrkqWrGskx7LESSUOyjidZQiik5QWo0p1njycmO4/YKyXvEqqMrWVOmslqyHtHzHO4C631FyZ9o/UFGk2a6xx+vNm3TBPOs2mF8AdGvnZVUoSHt+/JcdRwriMwTQO12iNJnK/GQd5TOQp4VpPTBOhCVy8fkOzuRBQbcXsZYxEOuFaTJ6oKrfAWTm8lUo8HbBth2s78vEAJcnPVLlEmSa5BkF1rWmiUpnGxOn2lia05yiyudvce4cUIyAg0ErJwzRNWGPobq5YX10x3T8IcL+8JKdEPp0I2zWuacQEVTI5ZeLdPb5vmcaR4fGIM1YyU52V4P6coYDzspZ3weGCZxoj00lAvW0dq5tn1FrJ04hfrTXBIpOOAzVmlYfIZ91eXGJCYNg9cHzYSV2oasHTlHDW4Jxkkpb82+WI1lrZnSJffdjzr/+nf++3+ruWWWaZZf6izY8GoqYUrPX0lzd0l8/59NWvyLnStp42SAvQ4f6IMys++6t/jYvtRjqf2yDsh7o/Cpb++Usu3nwhjTUaml1LhiTZhcY10hmvTnQBEIHpOPDp6684fvhIaINoAasBHF6d7a4L+KbTh/BEnhK261i/uGb98jWh7aSDvirAMbqStE6Yj1okX9IYqI7j7Sfuvv4V+Xig7ToK4DSHNFtx3DpvKTkzHU445+jXa5p1z2l/JOdC2/WAOWv5irJYcZS6UanilAdWieLUDX1H060p08TcoGR8K/+tNdQ4B9UjgK6K7jOOUjbQtD21aKc5FWeMBOlr9E9OGRckuqikzDSO5DzRdp0YXWqk1EqOAnysMn9P63hDnibSNNFut1y++UIiqNTkZaxRPS/y71KUoH41KNWUycPA9Hgv5hwv+bJUadzKGvslVaOiDTXeSxqBqQLoXRBzTlHDk9P/mx/0y5esEVyAa6jjQUCo8wLonWEOgq9VKmqNdVo96STQPotRKQ8nwqonrDZawan/GCf6zFowq40ASwW+ILFCh4/vSI87vQckdN6iemKnGlsjB6c4DDjvKQbaVc/m+Uua9YWmAswZvmK8O6/jnVdm9CnkPY4nqjOE9Yo8HinTgG0aahVpQ50GWW+XDClTo9w7OVcOnz7hME8gFIky8laY4hwjtUi2qnVzxWYiXG3pN1tOHz9inaW9uBSz1eGgjUZePhuE+ZWyAYdpAnF3hGIkLUDCFcScpix/zhPOe5omUDXRQoxShc2zF2JmnCZJPWg6ilbE5mmilCJlEk2D63rJN50GhvsHvLWqoUaNY0+RXTnLvffbzC/ePfKv/of/22/1dyyzzDLL/EWdHw9EmxbrHPE0UN2KWgxd6wjeMR6OHPcj2+vnPH/9hrZtcc5Kbp827eSUCP2ayzev6C6v5Be9soHVWIhiCjAuPDGhqpvMMXO4veXhu28xOdGvOukzz3NjkKykm67FOCuaOA0+d/2K9ctXrK+vJZKnFgElOPASsWSMVaexBJxjDSVXhodbHt+/pelbYqnk4yD5mUbiq6ZhlHVwFeNVu1rTNB7btgzDiaogVBzt6pimUkoSt66CNIBSC2kU8Neu1zQK0qWa02CaFhda+VlZQWituo4XA03SWkwXAqUmMcCo2cc6Xb2qVnRea+eUiHEEU/BNq59VVkAsf66UKhraOXpJ2cBcKu12y/Vnn+O7lTzIZ7Wb5lAazZs11qn7P1NzJB4Hpv1eVp9AHAYNafcawSNRQEYd4M41WO8FxNV6jquiVkzTCuacosopunmnKw52gFrJp0fi44OYqzQ0/1zBWQq1ikHsHH6+0vekvfLNeiNmGqvaYIxcU1B9qJeaUCMGomodeTxx/PiOeHyUVqg0B/gXyIXQdwI6h5E0RtKo9xSVpg2snr0gdCs5kKmzyc61pnMQAVXNV/UsRZj2D9SaabYXIt+IE7bpNIlI1MfGea1EhRqjgNBqGG7vCRWthJXvVooTPnhdUGScN8qGzqa8if5qw/r6kvh4wDiL36zJUyQeDpRpImx6rHWyQYkRjKXZbKBp2X+6o46R4FWC4gy1aI4tqCYWaYSKlZpG4jBSnB4cUsHFRE2FsO3PcowaJ/k9Y6RW13X9+fA13N5RUyW0rYDpUuQ7hLY2FU0TOLu//vlmAaHLLLPMMv//8+NX803LaX/k7tdfc/j+Pa31lJx43B2pyXJ985qrFzc0bSMPsAImC+gzXiKBVldXNL2uLZ2yUFRd2TqMC9oZXxSIGsbjkePHDxzevVfmS56+VYPGJR8UjOZUxmESEOo962fP6G+e069W0lBUM3O3uJlDwDHiLM75nMM4jROHjx/J45F2swI1ENE02CAr6/FwICdhdIw1NKsO3zSyahwGnLGE1VrW8erwLqmQYhJvlAazl6KtPRjwlrZpCX13fn+ubQV0Wy//bUkKYMXUMutBc5zkmnnROBrrRH+JZJNapz3zWQCQqZWYM7kqg4jTlpqiEUlJa0mFyS1VCgCcRhOVWlldXbJ9/lze52wyq6guVFjIuYDAGAU1cSSeBtIoUT4SWTVHDFmRJdQqsUlO1uumCQBUKypi673Wf7pzs5WwehMEL+AzxbN2k1LJ8UQajgKI1YR27iuvahSrwuzl01Gua4zAUzFAWG0xrtGfWc+xXBUwvlHNrKoYrafEkePHt8THnX7e5SxzkGrLVowxUyQOo8YaSQ1ss+pYXz+jWW300FE4h9abp89FzE0iczCNGLjicU+OE+3FhdwjpZ4jqJiBqFaEWu/lz+dMLnB8eKCMI75p5KBX6vl1GWvFhB8stSS99y1pmnBtw/rmRuOUWjEz5kIaTsRhwPfCUlKqmgE5x3btP33i9OmOZmaRrTjxixEWk1xIuUhubq6M+xPGyu+Ci5fPxFA2iEGsvbxCTxYKwKMoB1zANCJpoVaGYaAUZEOim5f53pPrJNXB9v/dqLbMMssss8yf6vxoILr7/j2H779nfLgnOM9oWuIQ6ftLtpdX9Kse450aF2byRtpS+uvn9NsNpiRqHDFrYZUoynxqxmRNo+jUDJRUOH66Y//2O+Jhz9ygLtmkRh82VXWXWrM5CiMY+jX9sxsuXr/Gh1b1ctqdboMYOay4/OvclqRVmsNux/H+TrqwmyAa2ClJXI+xTFMkjoOstp0lNB7XBFzTMg5iGGr6hqCvyfkgeYVV9JYlqxO8KuNLEaOKb+hWnazPa6Wqq1wiiiSIHGNw+mCsyuzWH4LQDJh6zhS11mOcUQAqK/+apXoxpSgsdddijCebIoH8pWCQqBxrncoCRB9ovQMtVOy2F2yf3eC7XphS0Ad4oVp7rgaViEoJ2C9xIg4n+dhCoxIABYTmqdscYzFVQMi8sq4lS0uQsdimP4ffn8FZyWqCas4sGspqpeOBnEbRQhoj3eEz2EgRkEpKYyt5OGm0mBYKmEpYbwXIIdcXBZszW3jOCkVfi3PkHDl8eMu0e9Da2YKpst42hjMTS8nE/UkPJHKPt9sV6+cvCOutZJNSJWweQMHf+TujbC1eqlnTaQ+20l3fyEo9RWwrTHedmVAQx72RDNaiprPj7oFpt6NRDXXR782cplaSyhyYRKbhPTlFqqlsnt/g2/6pxakW0nEgDSf5fnQdReO35oOUc47Hu1sOH0UGMGfFWuuoiPEQJF2i6Xo5mJQi5i1fWV1e0fXCcIY2kuJEGges7akxkk9HSkkSJ+fcWc8bjwemwxHjGnwIlGk6m+KwVgsT5J43xmg81DLLLLPMMr+L+dFAdP/NV/qwtvimYX1xwfrygqZraNsG5xzTlHRVXamNp7m+YXV9Q9MEMVPUCu1GoneyggVlp2qaFFRAPA3s333g8P495HhmLw3y8JONtoLRmTzNmQL019dsXr6i225F35aSMJ2zBVf7+qo2AjG3GFU4fLpl2N1hgdA0YnRIUt1oWqm5nE4nSoo47whtg9Nu7mmcsMbiewmwt2fAIGAoK+tkkGgpAxSDgC5naXrpQ5fsSotrZH2co9QnWoOEfWtPey0S5F8VYBrQasSZKVa2FzXvoNFEJVGqsEmhbYSRy1kinIokBXjvscpg5lzOkUAlJgiO9c0z+u0lrpEYKlPLGRiddYuq4SspY0oijUem40nAYNNoAoBG8jAHsus70TxLo9dJL6hGJblzVecM/KreS8K46fXQtXLc75gOj7i+x3qHQeUKmq5gccLoBWm+SuMo4KtWarU0lzc4zc+UaywsbZ2D9VX3S52lDMJcHz98z/S4w4ZG9JVZVuClVEyVuCFUW1zPOaMSC9XfPMP3G+bsVWGUExgvWwOD6GZLespiRQCWMZZmc0VOcigzbaf3YNY/80PJBJRpAuc53j0QdzvcbCyrkoQhmlawToB/HEY1kzmoCRxsnz2j215IEkQtUhs6nIinE65tdDMgmZ3FoHplz+Fhx+P3HwSEWqhWAaMx1KJNVikKAPXymZdcqLbSrNeyXVFA7BpPY1cMD4/sPnwgGCsHXypCiHpM40mTsPFtaDmNE9EFNMVWDhhV4HqpwgAbY3ELEF1mmWWW+Z3NjwaiJQpr4kKgsRbfBqyzeGcFjJUqjUq14tdr2qtLLl9/LlFBmv9p+7VkR2YJ4pbswDTjJcBy2j3y+PY70m4ncTTGkkoVMGgtplRhoKw8jLPWNmIt/c0lV59/SbveAEVBqDKh6Dreef3fwtzMZNrD92+ZHu40xsZScqVENck0nuFwYDqK+cGHBh8cvuukJjQnQmjPLUrWe5yGrSd1c5d5HalGm1olhUCuo7BAVGHKbJDc0jyOgMU2jb6fTCmZajTyxhjJXkQe2sbMnenKJlLPiQQYYYCz6m+9D8JSKvsHFWfl73AzOEyiVbTWKsZ0bJ+/oLu4Qr1nImtQ5kjRsrB0UcGh95QpMx6OkgPqgiYWlDNTaI3RKkrkHrOi1RT8nHGukZW4AiijYf1PjpaECUF1geYcVh73D0z7R2zb6hrckaMYokrO2NAQh1EMWMFJFFjJIkHwjvbyGtt2gD2zYjP7KSSw1ESi97LRz3f/4S1xvxfnt6BP5lglM99/tZCH+CRPqdKQtbq5oVltzmypHA5E+yn3vcXUrNFjqN60EvcPEFrcSuKvyjjg+vWTLMLUcy+7/DkoMWKalt3HO6b7Hd5aZcVRXXGQe1Js/kQ1M80sPcayur6hW28kFzUn0jiSTgdp4lqvcb3kuJZJUh+sc/g2MOwP7N+9x2vWacHoAWP+ZaANXOfQ/Cz3bk74lae/WOt/Jg1LczuZDw3ERz7e7rh5foVzjlyypEfkyHQ84ZoWawMr3zCcTlTjCH1POp6UsTY4K5Ia573oWZdZZplllvmdzI8HompeoBZl9ax0QHsnv+QpZGtoL6+5/tnPCE2L71eUaaRisOtrAR5xPGvsqBniKGwJht333/P47ntqmuQBZS055bNsy8492E7MBmmS0Hu/WrF98Yr+5pmstuMoL7rWMwiVek779O+KhMBP48SnX39FOR0JbSMVlmnCWnHGSx72YfqNAAAHOElEQVTnnpwyTddIfiea11kNBkfTBqz1QMEGXfclqQzMKWtLExK67r2s+0uhW13o+lkettZbWXfmJExVlQe3qVUYrlwoxpCG8Ww2mkHoOQeVWUOoJhuh1KilMk2TaD+tPzdbSa0jeNVO1gopz+DH4KzICvqLS7YvX+ODAEnj/Pl1U7T9CG33yVlYTScs47C7B+OeYoMswsjVouv/MqMdnPOiMaZSS8Q1LU4zQs0sw/hBGL9UnDZPgG/Ol9zvmPY7iS4Kqh+eW3JykbrMcZK8+TbodapSm2kNvu1xat7CIADSPOkbhSkMcp1yUqlA5v6br4inQdIQVHtY4axHlTx26YsPQdq+fGOp1dNur2i3l/KZKFMvhii5F+XUJPIWvTkwVKbjIziP73rKOEKcBIRWNflY2SBUq1poWymp4Po19x8+Mt0/0HYteRzlv1fts/VWwGuFaZokD7TxZ7a5u7yi215QcyYd91AKtSJB/060oqVkzcmV/FrXBKZhZPf2HcG5MxtsjcFWq0Y6+X5QIYQOrGEcBnKcCH3DxfPnorlN9bwpqVUZ+1xZbTZQCrvdI5vLC/k5tTI8HrBVgHkpWXStrTSGpWk8H6owFmcrzss9mfICRJdZZpllflfz481K6ENNH8TOzEyZEdwTAtvXr7h48UYegtZR40AZD5h+qxWWURklYYRqkbaZFCN3X3/L4dN7vJfAcMm/zJhUsRTpAFe9VolRHOYYmostl599xuryRsDXNAhYDq06mzUD0Go9oMbMmKbjcHfL7S9/iVNHbSmQxoizVuKEohifrDcY2yiTosaGAoaMD/7cMuV60XiWGHWlzllzZnXtmLKwM91qI9fPIsHkKjXIUVnKPNcMZqqG1udcJCOxnV3BAv6k8lAVCAY1P9WzmSXHyDRKtaE1TrWZwoQ6DdUX0FLJRaQVvm3UIR3pLrZcff6lsEPTJAeJ0MrnmJOwhUWKB8Q9bmWtOo2cbj8ClWazETNU1hzKJDKPOr9wzam1XrvLs3Sr+9Xm/D7OtKOChWqAphVAlifR1VrHtLtj2u3EJa61rCUm/WMzKy6SAtetFLSXswHK+RbbSFQW2nKE9VDEtDMDYFCzEJWaM7t335HHUUPRjX5mmZIK3nvRB9dKHBNNL/ml1hpimmg3F2xevAbVngqzOzPNKvFIUa5xlXB/aiWe9hgf8Kutmm0StmtEyqumnVm+gUYT5Sli257j7pHp4wfatns6xKiswTqnJiUB8LVUGi8Mds2RcHVFs70gHU/kGAnrFb7VqlNnoCCHjpSFoXZyEMm1cP+bt7Kedw0pTro9yFSkJUswuMV7J8YlLZpwTWD14hk+dCJpqOLaz0l+l1REAhOnyOb5c+zjI7dv37HZbvDjiKlW47/E9Oa8Va14wQbHaX+UvN8UhWX1jnF/ZHe/9L8vs8wyy/yu5sfHNyljZRw0QcBLqZVSKsVZLl6+ZPP6Z/Kgr2BSJB0eoZN6y7kHW9hIXZeXyjRlvvuDPyAfj6wuNxosLQ/eUoXRa/uOOmstYxJAhqF/dsPNm9eEzRZjK+U0qFmkEaYMdG3vVF8p/ew0HbfffsPh++8IrtEVMUQNG/fKkOWS8Y0j9GviMUr4d9dQgJqidIIrc+uCgKg8TJQ4UZAQc4lfEsAZU8Q5S7e5EKasimvZeC9NOzGe9Y5GTSoCdFB96oH19Q0lJtHsqVkJDXEXp305my4ohTxOpCTgCKNMNGCKRmtpx71BdLK1FgGEzlKrob9Zs331GcYGqfGcwVGOCsaY/UsK1iQaqsTI+PARSpXPRw1Hrm1IKcrrqVIPaa0UBIi5SOQUPgT86kJA6OxcLmgIv74PBfcUjXuylnTYMzzc0WyvlaVFgJsaX2btbBlHXN+p871KiULOWBcw2lolcV4IU5akZED0oSqLKLqad47b776mDAPeCFhLQxTTC1WlFnIvxmmS+zklTNeQxokQGi5efs4cOTV7tI01559Tqm4QjNHKWUinPWkYCBfX5++V8Z46ycpdpKMOk6Ku0sUZbpuOcYw8fPMN6/VWK2Cr9K4bcE6c8KJtTsLeNwHvHMMYsU3L+uqKfDxRU6K93OK6ToCut3pv6ybA6CbFivZ39933uAzetxSUKTZgbdB7pJJiPq/pay6kOBLjxPb5C/r1hjxFLXmQeLGaq5ZWZKbdI2F7IYUQwXPz6gX7+wdq8XT9Su6fgm5H5IAS+pZWDwo5Qdj08tnGxOnwKGUVyyyzzDLL/E7G1Ln4eJlllllmmWWWWWaZZf4Mx/7UL2CZZZZZZplllllmmb+cswDRZZZZZplllllmmWV+klmA6DLLLLPMMssss8wyP8ksQHSZZZZZZplllllmmZ9kFiC6zDLLLLPMMssss8xPMgsQXWaZZZZZZpllllnmJ5kFiC6zzDLLLLPMMsss85PMAkSXWWaZZZZZZplllvlJZgGiyyyzzDLLLLPMMsv8JPP/AETJFPAFFeftAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create generators for the video frames\n", + "num_frames = 150\n", + "\n", + "frames1 = img_arr\n", + "height, width, _ = frames1[0].shape\n", + "\n", + "track_path = '/home/haw027/code/private-physics-bench/stimuli/stimuli/generation/placement/b3d_track_imgs'\n", + "frames2_base = [\n", + " np.array(Image.open(join(track_path, f'{config}_{trial_index.zfill(4)}_{i}.png')))\n", + " for i in range(STOP_T)\n", + " ]\n", + "\n", + "for room in range(20):\n", + " print(room)\n", + " simulation_path = '/home/haw027/code/private-physics-bench/stimuli/stimuli/generation/placement/b3d_simulation_imgs/'\n", + " frames2 = frames2_base + [np.array(Image.open(join(simulation_path, f'{config}_{trial_index.zfill(4)}_room{room}_frame{i}.png')))\n", + " for i in range(num_frames)]\n", + "\n", + " # Adjust the figure size to match the aspect ratio of the combined videos\n", + " fig, axes = plt.subplots(1, 2, figsize=(2 * width / 100, height / 100), gridspec_kw={'wspace': 0, 'hspace': 0})\n", + "\n", + " ax1, ax2 = axes\n", + " ax1.axis('off')\n", + " ax2.axis('off')\n", + "\n", + " # Initialize the images\n", + " im1 = ax1.imshow(frames1[0])\n", + " im2 = ax2.imshow(frames2[0])\n", + "\n", + " # Update function for the animation\n", + " def update(frame):\n", + " # try:\n", + " frame1 = frames1[frame]\n", + " frame2 = frames2[frame]\n", + " im1.set_data(frame1)\n", + " im2.set_data(frame2)\n", + " # except StopIteration:\n", + " # anim.event_source.stop() # Stop the animation when frames are exhausted\n", + "\n", + " # Create the animation\n", + " anim = FuncAnimation(fig, update, frames=len(frames2), interval=100, repeat=False)\n", + "\n", + " # Display the animation\n", + " # plt.show()\n", + " plt.tight_layout()\n", + "\n", + " anim.save(f\"/home/haw027/code/private-physics-bench/stimuli/stimuli/generation/placement/videos/track+simulation_{room}_w_gt.gif\", writer=\"pillow\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "10\n", + "11\n", + "12\n", + "13\n", + "14\n", + "15\n", + "16\n", + "17\n", + "18\n", + "19\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqIAAAFUCAYAAAD/Il5qAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9Wa9jWZatiX2r3Q15GjP3aLK7uipA/0fQSwmQChIkARIEvUv6VxL0J/RUt1CqvHVv3syMyIjwcA93MzsNyd2sVg9zkac3N49GCSg5EeHGQ26uvblJnjP2mHOMoWqtlXOd61znOte5znWuc53r/8el/7UP4FznOte5znWuc53rXP826wxEz3Wuc53rXOc617nO9a9SZyB6rnOd61znOte5znWuf5U6A9Fznetc5zrXuc51rnP9q9QZiJ7rXOc617nOda5znetfpc5A9FznOte5znWuc53rXP8qdQai5zrXuc51rnOd61zn+lepMxA917nOda5znetc5zrXv0qdgei5znWuc53rXOc617n+Vcp+6YY3H78HQCkA1e6VUKZTNpN68g+v/fR6PVvgi6q+8kz1E9aqP3F/P7X+mNf01hrPS73y2MN+Hodlqc/s/uEIZT152uN11YstX+z31dP47HkVai0Pj6nHD30m2KsWebTKTu7u7/h//D//X4QQMEauoWqFGBO1Vpy3WGOhKrrOUWplXQPGGIzV1FKx1qCVRilFCBHnHMYaOU+lglLUWimlUlVFo6iAswbnHPvDRKmV68sL5nlBKYUxhs579tNEyQXrLDml09oAOWVqrWitQUEtsg/b1l2Wlfv9nqHrGMcB7x3eWSry+lLKxJSgVkqtbDcDSmkO08zHm1uuL7eMwyDnwTpu73fUWrDGAIq+98SY6LoO5wxUKMjrW0IgpUQtlZwLtYIxinHsscYSU2J/mOicQymNsQZrNKVWQojyriqF0rAsgb7z7T2HECLTvDAvC19/dY13DucdFcg5453l/v6AsYacMtM8Mw4DXe8oueKc4+b2Du89fee5v98zrwvXV5dYa7i9vUdrzddfvcdYzTwtXFxcEGPgu+8/UmvlYjNirSGXwrurS2LO/P7b7wkhMPQdX3/1nnmeiSnT9z3rujLPCz/7+h1rSHz1/or/+f/iv377c/ojpT73JTzXuc51rv8/ri8J7/xiIPrK8qdbr4HT9sgfv/wX1ss9fOk+f+qx/dTX9XybzwHf10BlPf7vxZJv7/3pOg9//9Qr2zygwTc/KLW+gmQbaH288rOX9hIIv7KO+pH9AlU2Ot1dSiHnjFKKXApKKTrncc5Ra0UphbWGWmXblDO+81ij5b5a0FpjtBEQ6tvzAO8spcjzvHcCvvYTKSWsde1fw+V2w+39npvbezbjgNZaXpqCi+2GJQRKzmhjSDkBFa0NSilSzlRAN/AKmUql1srlxRbrDLXI6zhMM7NSWGdxDSgrQFtDjYn9fsZ7izWaX/7sK0JMlFxYQkANmquLLfOyYIwmxExKBecc67xSi8NaQ6mVUo9vj8L3/nRBtywLu/3EMHRQQSsNSpFLxilDKhmFwntHbq9LAdO0MA491lpyzmgjANV3llorISXudnuury6ZlxWjNV3nuLs/0PeezThSayGGRMqFWgqbceAwzfSdxzlLqZ4PH2/xnWPoO+7v9/z6X37H11+/h1r44YcfsNbyy5+/59PNPYd5YTMO9J3n46dbttuR/+rf/x0fP92wLCt959Fac3NzxzTNDEOPcxaUYrPpKeWcgnyuc53rXH+p+nIgqo7M2Y/XETucQMhxgb9YvVz7MdP2+nG/xvK9xgA+/vn1XT/hCT/7N+sxYvtznhf1dNfq5d5eHlj9/Kt78uRHCLg+vkeh1OdYzcqbF0Ptgde43dcO5Xi8uWRCiFgjQMpog3OWmAqUQi0VYwyVIkyoVqf3X2tNiJFxkOdMy8rQd5RaAEXOwqwepgljDOPYE1NinlY2m4HdfmYzDlxsR5ZlPQFprXS7XTFaQ60YLaBYKXUCak4JSLbaoLWmNMA1zwubzYh3nhgjSsHY96ScoUKK+YGpzQVrLUopYoinYx/HHu8da0x8vLnl6/dXAhJLkXOgKvM8Y7Sh5EJWCq0VSmt0reSUWJeVrvMnsK9QUBWpMc4hRKwzpFJQFYzVaKNPr3EY5BjmOVBrasyy3L/RhpQiyxJQSrHb7fHeE0Kg6zqury6oVHLKaG1JKdN5S84VrcA5Q6Uybga6zrPdjOwOM4fDwrvrS9YQWUNk6DzbzYa73Y773QGAdVmZp5mrqwvGoed+d8A5h7WWvpcLBBSMm4HDYeKwP5ByIeV73l1vGfr8I5/Qc53rXOc61x9bXwxEf7zRLcjly2HVYyD2JW3047ZfBlveuu/zvOaPt+sfQNED2nuxR/X0prSXH8O+lwzlA/n49Mnq8Q8vXsUXAOUvecbpIqM+sJCqgczH7foXu2nbn1r7nzuO14/1BRw9saGvraUwWp/2aI0hpfRki5SStMutJsZEKRpjDApF5x1O2RNYtVqzrusJLBttqA3cWmPJOdF5Ty0CwmJIeGcxrS09Lwt911GNRmVFqZWu83L8pZ6ApFKQGrhzzhJjwmlF5z2qgm33UcE5YRJjjPjG1FEhZWn1a62IMZFzxliDrpqcCyEkpnnBO0ffeaZpJZcsgDcXtFZorTlME845NpuelBGwbgzZ6BNA1loLC6gyULHOElIk54zzlloK2hhiypASoFobPuOcwbl2kWAMuihhgLUiIa+/6z3WGHb7A147YkzEkISJ7A0pFVCZyhEsKwGta6IfOvqhRyvZZ+o8pRScNez3M0PvWWOk83KBUWtiHHu22w3OWtYQyDmz2x+Y55WcE8PQkZOMCajtyLpGOiCsgfv7Aymdgei5znWuc/2l6ie05r8E9DRY8aQN+6czfo9h5OurHcHdYxaUp/e9jmtOgOf5XKvcfwScnwPArzCb9eXNl/tRD/d/Fkd+7vy9BNjP4erDjGW7783lHh2EerigeACjn3/ej8+BvDF+cHzsEeCtr61ZK6WWh1lJwGlNjFFmIa0wXADGaKwxxJAoRUBYzrW1ymlzihpnDQXTgF/CdPp0ArVWlCIs5GmuFNVGAIQFVEqRUsY5aTtTZZ6ztNnMFIUJ9c6iUA0YV6zR8jpiwlmLqpV5Xggh0Pde2uCoxo6q9n2SNr1uTOUaAqVWnDVYY1BaUUpmWVc24yAgLSViStKCz5XeWsaxZ15Wpnlhu9mwhkDXebTRD+e7Csh3VlhIrQ2bcSSEQC0VjGJdgzynVJl3rZW7+x3vri9kXAGopaCUjEXElNBaYYy08kOU+dwYk7CsOTEvM33foZS8h3JuHcPQtwuGxOEwyWt2Ftf+L4xzbbOtpn1uFUYZtpuRlDPrGlAotuN4mg+utTLNC58+3tJ3Hc5buShTwgI77/CdsNTnOte5znWuv0z9pNb8Y8ykHv33cwDxScv6BHA+z1r+OdvVr60Oj8FyffRfJRD0yYt8YCwfnvsl+38E/p6s9xzyqmf7OYL5L1i9PluyVp403D+zyKuP1Ad4eDrk0w7eAJqPGdNne1BvzoE+5ztfYawrL5atVcQ0qbGH9UQjS2tYWveFiMIajXVWzkkF5y2hAdNApNQqbJsSxrSUwhqkbWy0ISVhMEupwnrWSspFzkStaEFLrCGCgq7zTUClcEaAadd31FIoRURK1lpijBjt8c5xmGdKkRGCzjlyLSg06xrxbX61FGnFS1teWvTGGjZubOIlOQUll8biFpZ1RWtD54UdjSkzTTPTvJzmLEWUVOm9Z11jA+y6nS8Bn6VWYV4NKK3oh44UM6XIudFKoZwhp4Iziq73LMtK13UnsF1qFqCr5GdjNM5aDvOCVlCNgMKu863FX0TYVjkB8RAC1lju7vcMfXdiqLWW9y7nwmYzMgwjOcvxxZBOwF0bQ4ozu91eGFnv6bxvoxMC2FPJdMafQHhKicM08dW7K4z5S44Vnetc5zrXv+36ciD6Cp54CZre+IX9FI0+euDYDv7ssx81/N9m3d4GcMf5xnra/dMjeAyNnwKkJ0u9icWe7/Dl6xHQK4CoNuTwFJB/bkjg8a1HrOqzY3l6eG27N5Z/BeOd7nh+XE9w5LP16pM7Xy749nzoixtPHzwei3rK6Cpo6mwBYyhY1yDgwVrmKHObqlMcpqW1dF1TjsPQe0pry6ecqRWZCy1yZo8MWy2VNYTTHKrO+tEnsJJLwTrXREfC+OnGsmmt6fuOkgtGG4yzhDWSchbgizrdPh1be705lBNAFICqWdbI0ABxaQIthcJ5ERwdQZo2GqU1SitqLSfgd1TxD0PPPM/I/Kol58A8LyLKAVLKaC371EaTYpKZ2hDRWtT2qYHVI4NcqqYWGS04gvPNOLLGiHcWbSo5JmKMWPuIvSyVzTiwroEQA6atqRqTqrV8mo/MMxXmeUErTQgJa/VphGBZVgH4bSRjuxkppbArB+Z5oesEdHZ9Ry6F/WGi77s210s7L8tpBlbWlRGQzntizHjv3vggn+tc5zrXuf7U+kmq+RO79SpifA6W1Om/L7d/m2E4gpuX4PNxi/wl+Puxes48vsbtvr7KI+73jyRGXrCCtT5b6zHd+mVrqidg8Hh8j/vo6nSmnorHXt/tq3e143yOZ6UN/fiz0M5RE9S8vuIraPjFlvXZTw9zp8dLloe2rbS1nbPkUuitwRiN0boB7XoS2VhrRERkDEppcil03on4xhrmZSWGSIyGoe9ke6NPlj/Lskqr+pGyvpaCdraN08oox1F8syzLE5V+beyrtNfNaYTAGsPSBFPGGGKciTExjh05l5Mif7c/cHmxFZa1MYfzvJCSPllNyTEb1pCxRuPbrOo8L822yTEMA7UUchFbJN8AXNf5Ns9aWdbQREcWo82xR4A1hsM0nfaltCKsEWctJReqkn157+i6HuscSsu5Pn4kSs5YI+e0Urm63HK/P7CuoZ1bEV5prYGK93JuRQC1YK1hHAfWdW3sqow9mMY0x5jQCgGenUcrRSlFxi6M5mK7oVLbOAdYK/O3FxcbmUtFxGZKy2xq5z37w8zmx3+9nOtc5zrXuf7I+mn2Tc+wxJGxeg0aPtQbTdjmDakezSM+bpB/8UEcn6Hqj2zz4/XAU375X57HTOwLCPakba0eMXw/fgxPmdXXW9/H7V4uqZ7erK8fz+eO4slIgnp896t8atv2GZB8jK8fI+Lj449uP1rk2Wzow76P9kwqPMxP9l1HiJGYIiEmLrcbvHMoJVZCxzViyuQiAFpAEs0/VLEZBhZjoFR2uwnvrYhbvIMYUVgO09I8PxvoSRFjNN5aQkwsy8q6Cos6jgMxZQ7TjGrve991AiJb+zumJCR9qRwaS3d1vWU6LMQmnFlWYQurtdQirKX3ckJcA7Ouc232VMYGjFbM8yrMbNeJFdURkBtDqhVrNbWqBwunUhn6XlrUKbMugVqKMIdGE6Ooyq2zlCIXA2PXs5oowE0pUkpobVjWyM3tnp99fX2y1QpBzpezDp2LjBvUgtWGcejlLSoV18n86BHQ9n0nQLKB5fvdAa0QT1EvoqQYE4d5oZbKsoRmhQW1fVas7bjfHZiXBYXMB/dDx7qG0/+tHeQ71q51jdYMfU8uhcvmtHCuc53rXOf6y9RPAqKft0F69KN69MOP4p6nSOflZp8DTG8BtNd2+uXg8vMG1PVthvGzaz46ojcZ4mcDAqd/Xu7wCVh+8tKeLv6UoHytz/7oec/B4nM8Wx9v+7nLj/py+foMeL5GQT962sunV1LKTJMow52xTMvCLib6zmOUCJSmaWEcZYXNOJyETd45mS2MkTDPxBjEwsfYBhDVqR2dS+EwzSKosYZcpB1/e7fj+uqC7VbmM49rhxgEaF54bu92dM3/cug7nHPt+AshpgfWuIqA5+hbaq3FGoPeaj7d3J9ET7UUxmEEVVnWlZjEukoBfd9DrSIiamxp3/ciDooR6xzeN+U9CMvaxhKstVjnGpuYWMOKd56ci8ycVsU0LRirm5WS4927K9YlsMxrs9ASxb41hq7zHA4zyyJK9I8fb3n37gpoc71JZmXHoW/zlwtcyudHa82aVmKUWdG+66hUwiKCKG1k3GGzGbm7351GFAA244CLlmmaGceeECL/8ttvef/umu1G2u7Hz0JY40m49e76qjHiIlBKWWzBjM5kY5q1U8+8LLif8LvjXOc617nO9dPqJwDR11viRzxRn7TTnwIl9ejWid1T+rTlH1efM4z6MYT4OUD9ZSD0tFLrhtdnTz8CznrsbT86fS9Z0cfA7K3xh2dM6Redts+fh/roP5Is9PJpRwD6YnePX0+tL3HlI7R+bKsfgeYjvvW01tGH8zV+t1LR1qKMJZbC/vbA1cWWcehZ18DhsBBjpuscyxpwxzb1GppSW2YTQQDpsgZyLlAToYrYyFlLbcpxbexpzzSxzGbsORxm7ncHvnp/TWkpRJ131Db76L3j6uqSu/sdQyfzqNJStnjvSCmeRgUEmIp4hypWQVELmP7Z1+9Y10BMkc45YsqEmBiHvrGDHSEEDoeJ7cWGrveENYol0bLinLTVU4zUIi3nWhERT0p4JyME6xrQSnN1tYVJPDytNdKW3jhCzOIt2nsO83Jq21+/u2RdV5YlAIWUC4OzXF5u2W5H5nnl9u6e/X7CO4dRilSkZX707yxMMnpRKrUK+7quYq2UshzzEUTnktkf9ry7uuLqckvOwpp771kbCO97EVJdXmzoOs+6LqQUT3OjSimql/c0l8zHT7dYI3ZdX391za5KkICMUMgnMMbI5cXmgVk/17nOda5z/dlL1S/JXwJuP33P52cz32DrfqTR/nZ9rtX+FIx9WYTeW0DzKTR6fZtne37rjKlXbz7ZtRz3l4Deh02eEsyP5iZ/7HU/HyR9WOTF+IF6PFugnrfZn9UjkHkEkKcnvrLN8ef6+FxXqCfke7rrGSMrKD/Oew6//zXf/X/+3/zHX3/Dd+qSpLtTMpJ3jhACWmtJ46kwjv2Jfawg8ZRaxFfOimF6rRW0zHz23uO8p9bKsqwnlbuzDwp6pRTzuqIRFs86y9B30s5uSve+79jtD0jUpmUNEaMVrkVbhjWePD1zaUr/ZlJfSiHESN939I1h9J1HoVjW9SS6qqWijVhHWWsF2JZKKhlQ7PcHhr4T26gm6jnOkkqspkSPLvPCsq4opfFewHdojgTD0KOU2FHJeU3CqDZ/2X4YuNiMTPPCNM/YxiLOS+DqYts8PAWslyYSWsLKL77+qp1LLWC8uQ7Yo59pLk2EJWzl4bi20czzwuXlhaRmpdQuMAoppxOovLq6IiWJFV1aclNqvqybcZA1p5n73Z6ry4vGiuuTe4F1lsNhIqfCOA5cX19SSj5HfJ7rXOc61x9RXwIxfwIQ/eFLd3tc+gu3/7F13l7riwHZk/XeAqI/ts3TY3kaY/lan/lxPQZfL/fzCKu9/lQ4if5fP57X2eoXi7T7RYP06BjUcd+Pj+uN1/MMYL5lz/Qa2H04rPoUdJ4OT1FLoeZEmvfMP/yWu1/9PXe/+o+k+x8gR6o13EfDD1xx2PySxfRUJbObx90dppmucxhtQCkxdDeacRzIuWC0AA+lNVqpRy1yL8xlTK1FLUIZmjreNiFUiGJ3FELCO8d2OwKV/UHskUoVUFOLdAmct6xrU6l7J2MCPIiphqEjpXJi9xTgvTvNWMqMphjt51SIMeK8FXuqxsw6Z1lCoO+704iC1pysn7QRv9GSZebyqPb3zhGzKNuPn88YIkorAeSNUYwpy+vSwpiGGLm6vMBaeW25yEVFzhlVYXuxIefCuq4yq2nk+I6zrH3X4Zzl081dM8svfP3uGm00azg6IRhiTixr4Ot379jvp9MIQgjhdDFqrFhVzXM4jS70fUfKudk51dOYhTMWYw0V+OHDRzbjwOV2e3pfrbUoYGnvlzGGr79+x3/9v/xfv/59+II6A9Fznetc/1brL5w1/0dAzh/Day82/pEtftIv+Le2VV+4zXMG8cee81CvsY8/hRT9kUN5ZYfPAd7Dzp4MTBwB6JtK92fLPRaEPcKjT0Hss5+fqJ2enQkFVAGfJQXSvGP9+B37b/4L+9/9Z9YP3xCng7TOnaFoS8qZC525tp+Y08ytes9HLoj6AuU9pYJzThg3oLYZzJQy87TgO9esR1UTHWU2Y0/OD/ZLXdeRchKRTUzkltyjvG+RmaImH4cHo/qu83SdI6bYGMjSUo0yOYvf5TE+0zlDLQICxTpIsWnRlUejdaAxsRJrqpuXZdc5nDPkWjBKU7XYOs1rY/9iJLeZzqYQI+fC4bBv4h2L1lpAbmNWdVUMfd9ERZI0pLVGqxYYgPiwpqY+Bzn2wySRp13nMVozN8FWSgkU9H2HaRGg2igZpQiS0HR7L/O2V5cX3O12zGllmme89zjrGpNd0Sg667m739F52Q8K+kEy4KdppgRhloeho8cT13h6L1PK1FJONlm5FOKacNbx/t01h8PEvK5YY3FOnBS8c81aS5NS4dOn29e+Zec617nOda4/Q/1JQPRt1u0z6EodJ0VfgpoXxORn1vjsofxF6mEaVgjI5wfxGUbyM8f25KydWvevPP5ES/TWvutLDPrsmNRJaPTaYb2FcuvpnxesbH3t8frshTxbUxzYSWEh7e9Yb//A8sNvmL7/FeHmO/K0p+SEKgU/iF0RRqMBU4WxUkrR1cR7f8e/Hwq3Fj7lLbtsiQpiToxdT4iRtbF98pY1tXkzMzfGULK099caCOtKCJLCI/6RYmS/BpkxNcdYUQVhkRlEFKdWdIgJoxUhwGbs6bqOpc2qHkVDx5a6PkZ+pkg5ZEp784zROGdJqbQ4TzG6R7fvTZvnTSXTOfETtaVAFVGVQrFGmf90jQnt++40clCrtPdLKZDl+yhqeNWAo/x/HHtiFMbTe4d1Dtos5RHollxYV2FiUdLSz23sIYTYnA7E6F/8TYF2PDKvKgbzx+9UCOHE8FprUM2aKWUB/LbvWNaVCozj0GZLV3IpTPOC1kospZrYq+u8xL429lscDAb2+4lS4erygsMk7f9aZCwAYJ5mcslst1tsMa9+m851rnOd61x/ev1JQPRpw/eN+5oXpToNSD7ixdSjJx1HDX+MIXyMlV7b9iexrm/XU4P8x7OPL2680mF+emBP2dPXkeLnrJU+z2y/8eCb57FBxcdiohcjA7zyop6v8exEvzgvzy5SlDCfaTmw3n8gfPqW9ePvWD7+jnD3A3k5UFs2upizW5QX8UjN0vYVU3fQxuLHDtt7/GZDvx34K6XY7XfczZXfLIUPeaDqHq0lwvM472itMGNHdbxpQK1S6bwTk/Q1kFMmRgFWx1eSc25KdmEmvXfsDxMgxvqdF+9O68R/MucscZvI7KVWkuGesoDOzdDTKU9tjFxIsUWJChOnlWIce/Qiiv7DPIn3Z0yYFuspGekOlKQ7xZyoubKuhfvpwHYzshl7vHcnNnNdA/OyiCK9qKbsrw0sN1/QlvJ0BIxHEZQC1hDbjKbGN5ZSrhU0UDANwAPUQgOkwhqDIsVw8nK11lErp9Sl2uy7csmQhFXVWsMa0E7JGkqsufb7A9vtRo67BQpM80r2+UEgFjMxZpQSIVbnPcZYhmHgMM1orRn67mQNdnRncM5REyzLSt91b32ZznWuc53rXH9i/UQg+hwoPaIwXwhYnj3trZift3bxvF5hS59AoS9lU99a9wuO4UhGqi9Cu28h5mcDoS/2/3Ru9IsP7vjsV573vHX+9MEHw3EhpeS4n+LKI0yVPnx9BWyqx5u21vcpfnNdWD5+w/SHf2H94beEu+/IhxvyOlOyzEmWlIGK6VwDMvJCtBGwlUNCO8f4fkt/dYUfO5TW1JwpYSXMC2U/McbAv9fwMz1wGw/clpF7M5KVxbXP5hrF/zKnAsSTsOl48lyzUhIhTCanQtdZSougdE78N5UWYKR4ZHJvZP7wGNF5ZAXlnMgJOrbfrdYMw4BJCW00XjlKi7csOVO1Iq3pZNekrdglhZgY7cNYwJHJzPmhXb/djk1klMlFkpYkllPT932bnSykpkCXqFNhQrXWlAYIj/ZSSkGKD6r6YwxorZJUdfz3KIw6CpUqIpKKSeJTrTGneFBJdnJtHEIiUksuLCGczOiPoQPWmmZOH+k6scWapoUYIqYZ3UscqFhqpZSkXd8POGdP8a2lRa52nYxZhBhPkZ4yQmDQxjA4S1c9u92BEMNnv3PnOte5znWuP77+jK35ds8Lf6MfJec+12n+3K7+PN34V8g9+Pz86eNEd9n2dIsHavf5Tn6EZDweSFviJQv6Ol38wtP00Tk9AdA36OrHkaFPdvf64bftH7XdHxPFxwPRBqU1JUWWT99z+PZXrN/9I8v3/0Laf6KmFUqhQEspqmgKzjvM0Ek+eLM0qrlivMOMHdr3uH7AdxZKIsVE2O9Z9xM1R6iVkhMpF3TObPNKn295j+VWbfnk3nOwWxJivo4FpVs0ZwOmupmzKw0aTakitgFFjOoEZGo1aC1gB+ppJvUEZpSi7zzTvJwAqFgdVfpO2Ml1WZnn5bT9oTGr+tFxHN+Zo/jJKEN10lZPOZ/Sn1LOLbK0StJUkvM5jBI1WnIBzQkQe+uIx/lRJYAxlxVn3SnOspbSzO4LKWV635GtMLlGG2GtlWpKd5nDTFlsmKZplmSjNitrjKJWwzwvbDbjybszNzW7s1YEZLk+yY/3XmZDh76j64Q5DSmiW1JW17lT0hNVZoMvLjbElE4ipTWsGGPRSlwKjFYsy3I61pwy2mgG11NqJcVMCEEiVI3sJ8b04nt3rnOd61zn+vPUHwlEX4KiL0kN+qL6Ka31Z93fP7q+cH8vD+1tYPg5AP54zlImFxSPQehnD6iexuk+t/Bbd7ysNnqg3tz0yIbWxz8+OxCFspaaM+vtB25+/Q/c/ervmf7wK9LhFqczzmnIhZIypYK2wjx1g8f2Dtd5tBUVeM2iYs8l4/yW4d3X+M1IDYEwHZg/3VBSBBQlRMISmiglo4HabIw6q+hqZKPu+bleuUsd34QtH9gyJ0PvHWiwrS2bcjkpp7WqeG9ZFrkqSFkiRUspJ3atVomEDDG12URpfx/Th47q/M57htbiVg0Qmsa85ZxP9k1HlbdvsaUxCRvqfLOnQjMMvQBLxBD/9HFTovSOMRNi4MpciE+oUVhtT52KFHMbESh4bylFGEdTFPOynI7XGvsQUYoipMTQdVSEURSPVo21zYbKWKi1Afd6YjKhnkCltRKXOgy9sJshnWZxj1GrWkvAwDTNYte03VLbesYYDtNMipmul9nhGBOHaUKhxDGgzd4qKw4DpRTWVVwUvBPbrt3+wOXlhpSSKPSBrNWpG5BLxeSC8f4Eis91rnOd61x/mfqJQPQ5FHtAQ4/nPj9HaL6JF/8UIPl8Z59b/08EyurFrbdf2eNHPmvL+eLGG9u9sohcADxx6Hy51hMm9OGojnO7T+ZD32Ken7wYhE5UGlQl7m/49F/+npt//B/YffMPxPsbKFkyCzRoZzE4Yf+8w3cON/T47YCWGB9KzOQQyTET10hOAu5yuqHUxHi5Zb3fU3KmxEKKkbhG0izznFSFsmA6i+vEsogi/y8pU3f3uCnyi1C48Ffcj1+x+l9wiJppPtB5R+dF2HI0du+0Z7sZmOf11PqmtZeFqRSLoZIlrWfJK12zXTq2tI9nUJ7ffE1b1nrKGa2VsJvN6D4GAbrOO8i0VCJh5HIp5JRxzrLfTzgvWffrujIOHaDw1pJLJseE0ZppWnAuc9HslEqVfVtnGmDWVCpd3+E7RwiSGHUE2jkXrBMv1WxzYzgFLMosbTmxotZZVBtfeJj3bJ/RWk6G9sZoYhSQOC+LjEmUwm4/Ya3hYjvS9577+wM5Z8axlxa+Unj/AEBNa+n3fUcIkpo0TXOb9TVUXRrbm1lWmQHuuk4EXUpRiyQzHUVk8nozfeeb8CwwjD3DMHz+i3muc53rXOf6o+uPYETfaj+/tuUX0pt/lh77o+WaF+MT2vBNtlA9u6c+u5cX2x23frrCs9Sl+nK7zxzx5x99BV2+dFxq+3lsTA/UFsWpan2GJZ8uUNsa6rXjfTT8qaSfTV4OHP7wKz79w3/g0z/8d0w//IGaEsY7rNMY7bCdxRmN1gqlDXbs6a62OG+hMaM5V+IciPMqTKbS4nnpHW7ssV5DqUzffxIgFjPrbmFdAtTa2tMy36idQVlh++KaUKUyH1bWJQlrp2Dwhit/4N8PhexWvvVf8087y81dYLsRcBNTolcd8TA3IYtEQGqlMFphmwfnkbk9so2Hw8w8zbx7d8Uw9EzTLBZMWklmfDuNtVbGYSDnzN3dnmEQttTWepotTTGx309opbi02yaeSqxL4GK7oe/kOcZKLjrIGPaxZR9SYhwHfMlM0wxA13UYbRo4FbuizWY4JRrJfTLTaY0hRGlx55TwXgBu572MphRhkVGcQOduP3F1sRFPVx7GW2oV0c9uN+GcZRg6Ou+JPpFS4uPNLdvthl/8/D3zvEorXMHV5ZZ5Xk4iM9d1uMbUKgSYmyLAOKYktlpasZ/Eb/TiYiMgU4mNFlTud/uTIb53jpQqFxdbQOZ8tTFQyymBK0ZR9p/rXOc617n+MvVHGNo/sG+fWfaPPJzXwOHT6NCnWz8GjerJvQ/3vcVYPgNizxjE1/f4FFi/ZDyf7+uN+cxX1np+ZE/41hfir0fzpM/38yrMfGMvjwFrfXTeTjs/gluxvilpZfn4e27+6b/j5j//t+y/+y3rYUYpg+0tVmmcNfjeo7TGOIN2Fr8Z8JsB42QwM6+BtARiSMQlULK01LWXFr3r7AncQGHdTcy7hTCvxFgwgHUCVm3vsFajraVUiIeJMC2EVMlJ2uoowCjs4Ok3ndgC1QIpkULkPnr+UK/4Vl8T/ZYQAleXWwGPza5IGxHLaKWE+UM1tbgiNB/RECLLsjAvK33vmyempZT60I6OMldqjMU5yzTPLEug8zJnqrR4dBqjqQU+fLqV1rkWBfuxxDi/WTChsNaSc+IwzVxdbvnw4ZZx7MW2aV2bOb3m8mJDLg/pXAJAxTPz8cTw8XU/Zh+V1ixNPS/sqXiCOiugFgVWi9XRNEssZiml+YlK5OoxJ/4YJJBTJpVMrbDdjM3zNZ38SMdhwNg2h1rryQd1v5/w3pFL4erqAqMN8zSjtKRETdNCRYRnMYqnqIx7iACqlsIw9KcQAe+ceKmmdLqQPbKpQ9/zv/pv/rc/+o16q86G9uc617n+rdZfJFnpKfh7euu5GObtvb71+HOW8TGOe631/bDIk/b3oye/bTz/CruoZD9PRDxvznw+AnxvnsLnnPDz/vZb6/HK449WqEc/0Jfrvpl09OjmC5haH7+v6gGN1kpJgXD7Lbvf/I/c//rv2X3zzyz3dxhrME7scajgOy9ze9pgekc3DrjOoUyzY1KaFDPrYSGvgRyiJA9pjbaafjvixx5KIYdEroWaC8tuIq+RUsTHU2uD6y3aHEVRIkrJKbFMKyVmXN+ALCL+6TY9tu+oCtIaSfNCipG0rtR8PBea4DZ8Gn7BH7hgrh7XCRt6mGa8cwL+SjlZPzlrT76iprXotRHPzBgCpdRTez6XQt95rLOnGU9rDd577ncH5nnBN4BnW3SlzHDKzKJCbIVQir6NEBhr6BozOh3EXF5p1WYtFbUJeRSKnHNLhBK1/zj0MhcbM8sasFafUpKE6VQn54AYI0aLIb/SAiBTlMx7abuL12qMkc1moKRCVZBjprZEqKHv0UaAbMqJzSj574fDxDQtrGGl7zuGvqdWTkr3nAtXl1vWVQBjqZXtdsO6Bj7d3Mo5c46+63j37pIPH28IIfH+3RVaa+ZlIZdyArBH8dkyr8Lwdp6+801MBn3vSSnjmxDqU8uk/z/9n/8vr34fv6TOQPRc5zrXv9X6Mycrtdbs59jOxzjrxUxmPa3w2ac/o1vV4wcUHPXqqt16A8++ckivw8HTjTZt8MLj9LXjO/70o39fnkPlVw7w+X1vvWevuBG8fJ31tN1rrPXj0YPTBvXhfZUc+0wJgXi45fC7/8ztP/13HH7/z5Q4I86Slq/+9q/ZXF2gjWG+uyctC8pY7OAxzqKtRZVKDYlUoSpNCgIAS8igNX7ToY2i2wxY76AU4jQRl0iBk2UTWRg/13VYp7HeorQihcy6n8mt9a2UFhB3MWKcgWYgbzqHVpDXKEzpspBjoqIoCbRzGC/HPHrDO/WRf6cOfDTXfBNGgh4xRnN3v8dcX6C1zFbWltsOUGolNzFNbd6k3rsG4lKLpXRtJlRY1FwKh8NMKZVxHGRWNDXj+iofxsM0Mw4DWoE19qHtHiUBqW8Z8NM0S+RlLWw2IwpIMYn/ZYu+Oirqa1WgKs6KIEpp1Yzrkwi+AKWl3X90ATBGk0oW1bnSbcYVDoeJzvt2/MJYjv0g2fLThOsakE6SNX9MlzqyuVDFJ9VouuDQxkj8Ziks68o4DCzrwm5/YGhCpGVZubvbMQ4dfWOhS6kSUYr4kXa958OnT2w3W1DqdBHU9wbnPDFGLi5GpnkRVjcVNpuBu/sdIEB9nguXl1v+9m9+ycePN298Kc91rnOd61x/an05EP3xfvzr2zbAVJ8/frz52Dj+C7hZ9Wyjx235Izvz5MGGHutpJ88O9fWByJeA+cWG6rN48iUKfBu4Ptg6PQXXp3PzdK9tJvHxzp4ewOn5zzdRj+88Hr+ilkwJM2F/w/z977j/7X/i8O0/sd5+QKmKHwc2V1/hh4FhM+IHAQ+lVrqLkXWaoBaUMeQlkqKAyJKaAj4Li2i9w11u8dsB4w01ZUrMxGkhTIFwmKm5oDsram/fFNAFjDdo27LS10SJqRnfi9DEWg1G44YO48Tqp6REWlbSuhLnlXwEVq6tO8jcqm5eoNpojDZc956/HhT/VVj41e3Cd8Ggvdj+aOsYOkkRSi1BCJScj1Ik//14hhVorbBGWu1rEMN6UZsblJfZya6976b5c+Yia8oMY8Jay7wszXBdGLYjy2mSZhx6vBOj++N8pbXHOU3IRVraxopZv2pzsMZYjBE7K60Vznl2+0mSlJw7xXZqrVqsKTjryKmQUmzWRpF1le1yydxrxdXVJX3XySexguo0MQRSzmJTpUQkZJrPqTUW0xtCEPeDznu0FoHUdjOyrIH9Yeb9uyuZFXW2+bk6xrGXsYSUMdagopZ2vHWs64qzwp7HnLi7WxjHoVlNyTHEGPl4c0ethaGXY7bWsswrNzd3OGsZz2Klc53rXOf6i9WXA9EjiHtt7PKtjvMTTPjjIFC9ge2eDS4+fa56Ck4bAfT5OrGGz5rtjxjXz3THHx3HW+MCT1/tCWg+espLIPl8vy8Z3Ic7Cq8j/EdU9Gsn4bR/Rc2ZvOxZ7z+yfPw9h9//E/tvf8Vy8wOqJlznufz6HcPFhn7ssd6JvVKFnBJxXai1gNZoY8kpkZbIej8LCM0CDKwz+KHDdg7b+9bCLoTbA+uyktZMCUnGDbTGDDLzeTLWL5WcE2nJ1FKpKYMS0Kia0bvzFtvZEzhb9hN5Xam1kGNCIWbrYsauUUZjB3lNKIX2Hm0szgtoyTGxzIE0Tby7u6d+OHDRXTFf/RX3ekMqBmMcykjkZ4xRhEz2aPUjIiqUEqGSFXB0fM+ds9Qi0ZhKSWqStOJdm2WsTVmeTnOa1tqT4h4lhvklF1JOGB4Sg2oLKND6eImmToCyQ1TxkvjU03ee2IztS4v89M4SQhC2s/PND1TmYK0TNrrvJUxgXla0EVCbS8Z7mRudprl5m4ogyCIjDLnNi5ZaWENkM/aoIq/vGHuKgtDOp1g2yfF7Z0/nq5TaxhvqyQaq7zpijCeWtPNyMZJbilXfee5DZF5Whr7jMC0UJzOjlxdbaqlM84J3DmcVw9CzLAvLsp5b6+c617nO9ResnyYHfa3X+2ob/vHtt6lU9Yp55WOG8616g8R8ysKe9vH0jlfnFdSzedAXi75CKx7b+I9GNR9iM9848M++rMdM5hNOk+fg8vF/Fa/d9+iIH73+WhJp2rF++o7Dd//C9MNvmH/4hnD/kZqCgM/3l/TbkW4z0o29pBcVafmXUsk5NpslEZrENVFWAZ45ZWou2M7RbXucty0lCUpMpDmwxkSYFuIcoXk32s5inMU20FPbWsthIa0BSkUZ8To1zmB7h/YCajVi2J6WQAqRuK6ULO+LsQZjJbNctwxxbS3aOdw44MYO4/yJQY3zxOF2x/7TPcs0yQxpKWxGz8+vDcPPC7OtfJwD3+4Su2QlN33oCeuD6CXm3JJ9RJRznG9USjWngCx57S3d53jZklLGe01uCn2lhflMMaG0ADBtZD61Vmkhp5RbFr1qSUbCyjrrxPg+JbSRTPt5WVHIhcSyrGIXFRPGWvrekVKWeEsvVknTtND3ns1mhPZ+i/pfwLSwwkmSp7xHKVgfeXOaJlyS19s+RwbGoafkSozpZJ10DAvw1lKzWDst63ryGD0mQSl9VMCrxvYKED3OR4+d5zDPhENsAjAZ0VAotuPAMelJP+qeWGMoSs7husqxe++acCrzym+cc53rXOc615+pfhoQfasV/SXDmq/WayDvc/t/1pZv7OcToc2LVd7ex2MT/reP9PnM5QPYfPtl19MGryUfPZnVfLarV/Xur44byP3HFvCTNVQTSChNrZk837N8/IbDt//M4Q//wvTh9yw3H6kl0fWe7eWW4eLndJsB571Y2GhFKZk4B6Fya5Xc8HVlnVbStJLmlRwT2hq6zUh/Kbng3XbAeivq+DUTpok0i3inJImutEOH6127jqmiqKfKHOe0koIo2qFivcV3Hjt4rBMmkgolRsK6EhZRY2sEXBirUVqhjW2spMF4j+073NBjnMOPA7rz5FSY73ccbu6Ybu9YD2KY7jvP5c+/Zri+oht6bNdhO89VClyke8Zy4ENwfIpb9noDtqOUB3P6XAopZox5AJ/e++YnKgIrreUTG9p8o1JtNjYXyUY/muMbaWErRKx1BG3ydottWC6ZXItcMORCVkm8NKmEINZMWsvcJ1XSmuLREipEivcCQI0mhsg4SjSmRJQuKKCo2sYRoJQss7CDtLdDA5XaZBk3aK+1lnpKqxLvzsKyBGwTLgnQtByBpajePaUWfPJNoFTo+o4YIlorShFweUzFUgrmZWHoO0IIdJ0X4VU7jlxkRtUag++EdTZ6kPOshUVXWjOOPfOynOys+r6j73sO8/zat/xc5zrXuc71Z6g/MWv+ePdbg5GfAZYnQPWFba9XmMyHuz63xpuw78U2L9Z+TpO+0qJ7Mr/5bHazPj4vz0HmcbuT1+LzY3iK8E/DBPVHhmm1KNTzumf58FsO3/wX9t/9ivnjd4S7G0qO2M5x9dUlw8WWbrvBdV3LD5e89EyBlMkxU3IlrSvrvFKWxLSbKG2m0HrL5t0FbujwQ4d2lryukDLTfmbdz6Q1nGY5jbd0Vxu0s6hcKDlBLdSUmaeFuARylJlSpRV+sPihwx/b6LWS1kBaEhhFPYI2ozDGompFI2p6hUIZYT/9ZqTbDrhe5kfRIp66+c133H//iXCYQBW0qvTbDeP79wJAx0FmPkshLAv7D5+Iuz3rYcIvgZ9XGOMfuIme/favyBc/45BEuCT2lSJKqqWC1uSc0NqJFRFIex+ELawifErHDPhUAZkJddqii6jVj5GW4o8J/ih+OrKiJXO/27PdjCidT3OlYY3UNjJgrCHM6WS9dExxUlrReUfJmcM0ncYJ1nVtXqWV/X7CGH0y7T+a3hstqvsQAt57cs5MKVGqWFcNzT8059KAbD0BTrFlMpTyIKyyxnC53YhFVc6s63ry9uy8w3svYxVaU0pmWaO00bUmhMDlxfY0GpKDmPgr3YBr+z567xjH4eQtqhRsxrHZR4nlE7VK6MK5znWuc53rL1J/QsQnfAkAfFuh8xOf87jdjnoQQjx5rM0VPl/qBS35VLcj/z4/INVw4nN51GfqMQh9NqfwZUC4/Vsf6NMnx/YGzq9KgF6NkfXu9xx+95+4/5e/Z//db4mHHZDR1jBcbNheX9FfNPBpFEcz9nJkV5vHZgyZ6XbHcj+LACmsVMRDc/P+gm4rvqCqPYdSWW73TDd7mWPMhVwr2mn80NFdDOgGitJ+oiLsXs6VZQrkJVCKzPP5bc94MWK7Dm00tWTyGlnnhZJam9cojFXY3guwUIoa02lu1Q0D/dUlfhxxQ48ymhwih0933P/wif3HW2IzxXe9Y/vVNZv31wzX15iuRztLjYlwmFnv7wn7AzkE0rySQmQNibhGdCr83Fm+PsxM87fsxp+x2/wS/MAaVjTSek4pE4Io6L33J19LYwzOGSqa1FhF72XWNOfjHCltftSzhsC6yjymaYbyMUYR/GiNczKOENq5EPso1Qz9haHs+66NCRTxVzUiDJJZzyKCICVscs7h9HGz1rLdiPdprZUY82kc4dg+T0lsnXRLWdofJkopTPNC13w/tdZYJ8zk4TCd4kCVUqRcKFRilnM19B1Vi5dpLU3tn0tzLJD5UdNM63WLTgW43+1ZlkC92DTGU4F3DP0AtbLfH/j2dz/wd3/zy/YeSJBACIEK7Xig1OO+znWuc53rXH+J+on2TW/Va8Ojf+xax8efi6M+D07lWZ/tsb88gvoKQFQv2/tHLFt5gXkf1vpiuPoIFNfXZ1Yrz7KtG9p+GIEV4IXS1JIIN9+x/+1/4vbX/wPzh9+S5/0JsA3bkYt3l/QXW4wX0Kao1ByJMaO7HhmYk9e47mbmmzuW+wNhWak5YzvP+PU7uk2PdxrbeZQRFi7OgXQ/kdaWjlRBGYu/7PCjkzjMWqlZhEM5F3KMIn5q7fO67ZlyIu1XASKqqeSdJUwzy+FAyUdVu0VZ3cCDpDahBIwXY7De019u8cOA6TuUc4Q1cP/N99x/9z3LzR1plVa4tppu03H1t3/F9V//Ndb7k9p+ubllvbslzQs1V2m1h8g8L6xzFK/M9lqNt2wuO65tResbFhf5gffcdtfcrgVrNLpKXjpJ3u+u8zLDWSsxpQcVeWN5jTbkWnBOQGnJ0kr31kpLPQhzbFqmeopry1o3sj8lM6LH2UljTWP2FCEEEVMVCE0ANI49MUnWvTbSKnfO4qxlmmbWEEhZ03ddYy/L6aN5bI9XEPsoJSIupRRDL+3uvinSj6b22814CgaY5om+74gpU3I5mf/XWlnWQN91bJrZ/TwvJ5ZW6wcRl/iaugbqPePQ86nccZhmsbFCSUpTSPR9x8V2g3NOrLBOcaHdyV5rjomSK9uLDdO8fuF3+1znOte5zvVT6yeKldQX4K3PMaH15U+PNlcvHlXtj+lj0dFnDuAVUvMJ01lf2fjR4yd17BNw+PTA6hP0+ZpK6/Euns+XPt7y2f6fbPDydSoqbdAOaiUebtj97h+4/Yf/lum7fyYcbqVVaS3WdVz94orN5SXd2KObv2VOIgLStim6jbRhw35lvt0x39yLiKi1u/uxY3x/Qbcd0QpcP5BTYP50RzgsxFigVLRRaGfpr7b4scdohXZGREerzHqWGEXMhNgn5VSI84HlMBODANiqZC2jlTCgZaKWgm1zq0obtG/q9lopKUEpKGvptxv8OGI6mQEtWjPf77n95lfsf/hEmBasM2ig23S4zqGtwShFut+x098yvHsvava7W+J+Or016xpYDzIbixIrI9uLUr/bDvi2Xknyerv5jqubb7Crxm9/yf3FX6O6LcZYUWKvYtR+BIelFO7vpZ1+bE2v68ow9IRSMFqxhtBYTo+zhqrFvzSEiHOGEFJTmUv8qDWGWCXFqdZ6EhnppsCPWcDXeHUhzgJKo1URdl2J6j6HRIETe5tiIhkrLfWmtD/6d6IU0zSf2vnG2nahJwzwsawx6MbSKqVw3tCVDmMsQz+QcmKe18a0WjonNkwxJTZFcuGPYwnHlCYQlfu6BsbRoFNmGDou04aYUhNuSUqS0krSrGbFxeWWnBLOWm5u7vFOjksspJyMOdzv+Ktffv369/tc5zrXuc71J9dPs296EwM+nWeUe56yk2+OWX2uc1+fg9CXG72Eto9R42tzl8e7X0Otj29LuOjr6zxd7+ldr29bHz3+7ChfPu2x56j0sKlU8rRj//t/5PYf/wO3//z3LLcf0Aq08/ihZ7zcsrl+R38xYr07KaTneU+OCdt10s7Virhmlt3M/vtPxGlBVYXW4DrDcHXJcLXFe4vSlrDbkZUiTAvTzZ4cRKBkOyeq9N7hhmYflBJpXshBRDphXslLONkQVVXY394RV2lxp1TEq7TzdEOH73u0cahahVkbHBhJBxIRUlNZN6GM6ztc58FoKpqwRg7f/cDdDzdMn24xluaRaXC9w9kGhLRCVxkrMJ2HWpg/fniY5dWK+W7PcgjUAjFEFLSZVUd3ucGNYkullCbHSJxnDrcTYQ7knLgaHVf19+xvf+Deved+/CWqv5AM95IhQchZPCyHgTXIefLe0Xl/shqSF6zwcAJ+Aiq1gKzmgRliYl1XMXB/9PmJKXHEi9YajsKgUET8o5SipISqsv79fuXyYsNmHEixsK4rm82IMYZpXhibV6qzprkB0KyeOpZlJcTIzc0dF1sB1kdRllYiIqPCDx8/8bd/81d0nWUNUay2csYawzD0HKaJNQR85/FOWvq7/QGtDdfXlyzLQq2V/bzSd2KqH1Piw4cb8QcNkRAid7s9fSfm9+u6tjQoAZvLsnA4LFxdbbm+vjyeZrx3DEPXIkwL33734Y3v/7nOda5znetPrZ9maP/THnh7qWek6UuP0QeE+UBSPmYuX+MM6wlgvg56H0nYHyPY10CuglpfW+RLZmNfbv3ivkdq96dg98igKlTzjMzLnuWHb/j4X/4D97/+j8wfv4WSMc4zXm7pt1uGyy2byy3Gysxm1Yp1tyM25q2WAiULM5kK892OZbc2RjGLiGjbM15vGLYj2oiFUkUT5oUwRZadsJMyf9ljB4frLFoZOeyYWfaS711zISeZ6YshirVTzuSYiCEQV2l1lgrWOcZNz7gZMU04g5LceWO1GNWXQs3yBO0NfrvFD6NYMtVKyYl5v3D//Semj5+Iy0wp4JzDDe4k0NFIyo7I6xFWtBe2NYeExM8X1v3EOi/kWHDGoRy43jF+dc3Fz645iqaUljlX7Rzz3YF1knZxv+1AOxkziImuTLzf7xj337K/+jt227/idsqEkthuBmIWI/rOi5Bpt1vZbDYYoyVdaewB6Lyn84gNk1KsObCUlU2zJVrDijVGgL2XWcrS7KGUFoBFbRnvJ8W4bGONQSvNxWbDZjO2drdEilrnuLvf8dX7K6wRNvJosi8WVZrbux3GiFG/s4bsHIdpJuciAqijVZKVSM4h9PzjP/0L799d4Z1tIq0KUb7HV5cX5JIJIXKYZpkVrZVKYZlnbLPlApjnlWVdubrcklNmDQFjLVeXkv4VQyTGyNAPWGvYTwdJx5oqm42wrMu6YrSwwcsqowvztLTxBPNF3/dznetc5zrXT68/Uax0LHW69zhhqZBW6x+BU2WFRsC+Sl4+3u3niM3j0Z4WqZ/d7tmzni/w9Dkv0fTzZz1pzb98Xrv5yEu1AjVF8rIj3H7H9M0/8vEf/3vuf/cvhMOM33iG7ZZuHBkvN2yuLzFdRy2ZmjMxxgYAS1Nui6o4hshyvydOQeIZa5U4zMst3dWWfuwx4n1Ezi03/DCz7mZqyo2NtAI+hx43eMkpD5E4L9Tc1NOlUJOYjNckDFeKgbgGShYFtbRtxaPR9x3eOVG9txxzq6ykADkBmdJ699iLAb/dYIcB7b2kJoXI4eae++++Z765I6+BbuzotwPaGFHJNwsh+X9BO4sberSS1nYJmbDMxJQJSyStGVXBestw6bBDz/j+kuH6EtP59h6lk2m/NmJk3/1dz/5yy92335OiXADkJK4DtWrcxYavf/EVlz9/R9aJH3bwH7+N3OwS3XZDKVVM462hAvO8YFpaU4gRq60YrrfZ2hAiSisqhXlZxJlAqabCl3EC7z3OWjGI17rFkxa0VqxrlOx4pcgpk2Km1ELfGEPf+9NH07S5yfv7A7VW5mXh6nKL1UbU9krYUWNEPKW1pD3lIlZOWms6Z8X6qVQ0isuLjfi9IvOrquim8K+n1+GsPY0uHBl1jQiXQowCRo1hGDpKFV9S5yxdJ3nxhxDoe4/RbQ3EW1ahGIaOeV65ub3j3fUltWTWGPHOyvkJAesspUqC07nOda5znesvU3+UfdNnp0BPrKR6eX9jMh93+R+2qo8wWnv+yUPptTo+/pQpfbHNcwD65LHjJo9b9k9eyLNFX7bqTx6mT3Dr6yMBr1lB1VohJ/J6INx9z/LdPzJ/90+sn/5ATSuqFPrLDRdfX7N9d8mw3QqTpxW1SjxjjjKDWat4TmpjMFvfVOeG5W7Pcj+DVmJUfzFivaEbepSCFCMpVklGOizt8IRFNGOHHXvxmLTCGNUWy5lbjnop4vVYciUuq8Q5hkhNmdpGHIx1uNZal5Qj11r7Gqw9qaiVMS0VqKKsxfU9ftyIf2Qt5FKZb++YPnxi/+GGsN+jNVin8d3Qzo2wcmix01JaC/PpjrZHmhITYQkstzsKWpjBlLHO0409w9WG/voCN/btmDQlhOb/aWT0QXuZk1xXpvs9y25PiuKt6npPv+nR3cDmZz9j/OoaZw0lRta7HZfTHf+z9Zbf3hTW8lekzTVzsYR2PlNcsdY2b1GN64XtFoDajOJTbvnxlbBGtBGNfuc8sSYOhxnvbRP+CKAERWnxmLVy8vKU9KXAPC8i1lkWhr5vvp2VzThKelaz3QqhWXg1tfuDMb1YUJljG761wWupxJQftq8a78XuaZqFOb2+vGizq4YEGAxaGzrvSDnTdeLVqpQ6qdxzA6mlFLQxp3a6UpyArda6mf3LRZK04SVs4OPHG/aHmXHo6JolVKc1xopwTCnzx15Ln+tc5zrXub6gvhiIPpjGn+545YfHFOUReVYeE6NvTG0+UJ/taY9B6QsZ02sM5+no6pPbsq06deAfZk+P4PC4Zn2yypv19GnP727rvPGnqwkrqJUSV9J0T7z/QLr/juXDN6wfvyFPtyhV2+zjO1zfY5wXkKEEROScyLmSUzpZy2hnMUYAnet6dOeEMUtF1NI1tznRZh2UkiivVzGPV+3YldUYK0lHrkVzaq0pMRLXSAmRkjIlPghhUkisy8IyL6Q1iVjJaHnntMF5h222QsYKM6eNJCTZ3lGLErBoLabrsH0v+7UOSiYvK+s8Mx8mpts7lvs9eQ3CmjknxvhGWsTqKLYxBuUMGIuyThwDNOQ1isJ/WZnuDqQ1YbueftNh+47+cstwscGN/eliQYKlqsSZCpVKipF1Xplud+w/fmK63aE1+LGju7jg4mfv6MaB7uoaOwzEZWH3ww2Hjzfcf/eB/cc7akm8Vwq3rqjLv2Ief87HUNknw1Ilm77vfJv1fUj4OebXp2ZhZI3BmMphmqnO4n2h1kLnLUsz+zfGMM8LvvNyMUCl7zr200wpBWctfe9PyUJaK2KKDejK7Kj3jkrCmGY0X8QPFECrQj/0p9SoXDLOOYyOIHacrOuK0T0pZ5zWrdUO5RGjrhBQmbO05b13OO9Js1wgOedOMZ+1Hr1TxcdUt7GB4+8M3YB3yolSZZsYE6UUxrHn6uqSmHJLaKpYK7Oz07IIo5uLJEi9OSN+rnOd61zn+lPrJ8yI1kcDm8c71QmgPpm/5JXgybfQ3asK9edg7vlM52v1AEJPrOyLXb3+B+UJUQkvqNX6YsNHB/MKO/qC+VS6gc+FuPtE+PQt683vibffkXYfKGGiloy2lv7yEr8ZsC3CEqXIMZPWQE5RzNCLJMFIProAN9N5AWJHdjcX8hrJIVBCkMxu01EqMju6hsYugXFWgJoxkCJUad/qmon7SIqJEjOpgc+SKzlG8fdMiXVaWOYVFGI23nlMi1e01gj4bTGbWikoRRTr3mGsRzmPdk4AaN+L32hOhP3E9PETy/29zKq2JCcA5yy+cxhn0VrLu63ENF9rLSIi70FrSsqkZZVo0jXKeAKFbuzpNxv8ZmS4GHHj0MRcApJo9kdKtY+EsaQQWHYHpptbptt71sNEyQU/dGy/es/2Z+/FPaCXeNQYIje//Ya77z5w+HhLXFdqylijGL7+mu1X14wXA/3YU3Tidg58c5P4UDo+FSeWSqWwaWpx/WjcIxexdSrGMI79adYxpofozHHsm4l8BfXAqJYG3oa+E1a9+Xt2nTClxuiWZV/wzhFCIEa58BHGWjfmUZ2iN9dFUrisMcwxYYxhHEdylnlhc3UBtLnaZr0UU8Q7xzyvxBDpm+l9iqm126OATipU8S49zpsaLVZVSkGIcp6sMS1FSrfIVId3nkg82T+FsMp75j2/+PnX7PZ7Ss4nFtVlGWeoFWp48FE917nOda5z/fnrJ7Tm1QNh+RioPR2AfHlnfQZeHz31OE/6Ft/wHAC+FDW93PpxmtHplnqyyYt6VZX/Yr6zvvJ8Acz16YayVkMvJQbS7iPLx9+x/PAb4qffkw+fKGEWwOecJAd1nYDPZuKeQmDeT+QQKWtsc3IFZQy26yUrvetEoGQ0VMgxkEOQIzJWDrkWSq3kVMgpUmOmpAhaC4D1Fl2qmMmHQG6xmgC1FNKapLmuNaUW0ipMYFpDu26QVnI3DvRjh9Ua13coYyg5Y5wYr2trJW2oVnAW08lrdX2P8R5jHbTXffi4Y727Y7nbEaZFFOY0JnDopBVvNMY6qtJgDNYJu6qMkVhJo6lVkedA2E2UBmxolkG2l5lT4+Ucamc5WmNJ+74lTTU2NMwr827HfHfPut8TpgWlNOO7KzY//xnj9TVd32GaIn/dH9j98Ind9x9ZdnvyupJiplJwzuOd4eJqZPv+km4zknNmud9R7u64uJ/QUTNwwc5ecKe3HJTCG0vKCedqSzqCOS0s6yJznK1VHkPEOscaVvpO5nArAi6naSHlTO+F/TRWk0slp4y1ts2aCtNpnaU0oY+1lpQSKck4RkqZYejFJiql1vaWOcvNIC39ECNGy7pVVbwRJlNsnwTU5lywg8FYw/4woZTM3BprqLlApc1sJrxzLXY0EZMA3YrMpForbXnI9G2W92iLZYzEhiql6fue3W7PsgYRJVlF10kS1LoGYkqMw/DkW35kic91rnOd61x//vpiIKqekH/19Af6+NizrY+bPasjmFOvP/z23mXrLxOrP+yrPfehHf9l2z+952Uv/oUN/mPEq0RxHu8/Mv3h1yzf/zPp9lvyfE+NKzVLe3y42oo/phPgqZv/Y1xWYe+y+G6SxPvQdR3+YovtvLTqdWsbp0RaZkrJnIyhlKIGeX4Jwn7mlOSPvPe4zYB2BoqwpnFZT2xrySLsETAms59KwTovxGZwn2NGa+iGDtd7MBbrHa731FzljGsNHFvZpZ0ag9v0uM0G43xjY8V+aD3sOXy6Zb69l/nTlKkKjAbnPVo9XLgohQDbzqO9F1a0jQKUEFtWfYRapdWbMyiN2/R0241Ed/adMNUoqqoo56SdT4VcKDm3XPSF+dMty9098/5AnAO269h+/XMufvkzxvfvWnKToYaV+X7Pze//wO233xMOE7pKrKY1Gm/NSWlvvSWvgd0ffuBeG9YlcNjtMYjrw1AVLi9cpxt+2V/yKV6zV+9Zi2bZTyzN2mnoO/aHTAhB7I68ayMKYI2VRKIqoKzvPH3niSmScmrMaMVZR4oyWxlTAkUT7YioLGdp7VNhmkVdHkJkDZHNOOCdbeSxou9FOKS1JqZ8eg9UEwwBpPZZvLjYcDiIDdPQd+SUWdaVQfWn5kiulb4ByZoLoBjHgfXovNDa+OKfKnGg+8Mk86TtO78/zAyl4qyh6zzeO+7u9gxjxw8fPrEZR4ZxEHuqaaHkQ2v1iwDr8mL7I787znWuc53rXH9s/SRGVJ3a5u0e9RqYVC8B44mRfNEsf7bB04dOROVrjOXjTV9Skk8Xemug8ynf+eLW4+fWN49VCftWCulwx/T9r5i++c8sf/g1ZbqHU0qSZI5XoB9HxusraWsCaQ0sk7R4FTIzpxR0Y4/tB5wXv07TD41ljcR5IgfJZldaob2lpiyAIiaJu8wNmGqNv7jAjwJ687yw3N9TQkZpSy6JHBvraAyYSq1ZZvtyIUyrzIWmJGKOTU83dgJ6nEVZK4xpKZgmCFIFAYC1opzFbUe6y0sB30pTtSFNE9PtLdOnG+a7e8IsQFc3uyVjTTNaV9J6L1VM78eOfruR854L1EIOibwm1v1ETsKkKaVQ1uC3G/p3l3QXWwFUJQlQNjIyoJRCGQU5k0MgTjPzdGC53zHf70khkGPBWMf7f/c3XPzVLxguL7BdL238UonzyvzpA3e/+5YP3/yBdQkYrekHL64ERmyolFagDTklpts9BQH+a/NarZ0Aeqc03smsLXriKh8I8YZbc80P/TX7rEm5YC30vSRCbdzIfn/AWkeeZpwTCycQoVJMUeaIrcRvohTLvKJUwjmxjooxEmIidZIlb62kLHkvMZ6llqa816xr4Obmjs57NpsB3znGYRBbJyWCqpSllW7RJ/ZU5koLy7JydbnhMC2knE42VfIrRIznvXesa6DvewGwKLQ+gtEgLGgDvn3nSTGTcpbEKC3A2FhDjJFllVloY0ybKzW4XsRe33//Ea0V79+/E4uqWlnWSIjLCfSe61znOte5/vz1kyM+n4I+1fjGxyIhnuLLNu75SKfD26DxWb2GT9tT3zTI/wn1xsToK/c8vU+1eUSUIq8T07f/xP43f8/yw6/J95+oJUEWUKa8bRY+DexUmG5uJTqzH0jLJHGcRgtz5Bzd5ZZuGDDeodtJKECYF/K6UNZVrIO0PrXMw+2OOC3UUgS8tQQbvxmxQ4+2ljzPhN1BxCFtvrfmIKCvEyCSixisK9122tqj1IoyhmHTM4wDqs0Q5pBRVWM7AY01RKpWVOsw4wZ/sZF0J9fmNWtl2e85/PCB+e6OuKxyJKWgqBhncJ1ryvDGcpbaYiyFtTWS94l3hjxNpNRYNzRaafQgKnB/saG7vsSNg8y/1oqqmWol+lMhfq3UQgmZdXfPdHfLepiJSyBNCyklTD/w7t/9kqu/+1tc50AplHXUVFjv7gh3n0iLzB2O24Gf/dXX7O52eGdxTkD68QMrAQMraQnkImbvS0goremGnm7osC15qCQR1mil6QfNtodfmD1/VxZ+M/d8rNekLCKww36i6zw///lX3N3tseaYVy/57845OnNMREJy2Zt4DJD3HWlza6WkVR0k/tJZxy7u6Tqx7dLaEWNqOfac7JRCjKeW/boGJNHJMK8LnXN0nRcQmGWeeJpkpOCk/A+xCc0Km3GDacA1pcz9rrXYnaOGcnIOsNY28Z54nhZqmxmWi8icEmENlMpJgNQPTmZhqWy3G1LKOO/Y7Q7s9wf6ztH1XWvxe7rubN90rnOd61x/qVL1LQXPs7r99D0Az3AoPP75zfoSsdHzB+uLf56OBzzb7vhTfRCYvDzgV8jR0/zpayvWJ4+oJjyqKbLcfMfhm/+Rw2//R+Ltd5R1aWCjkpPAPNtZbO8Biaw01qCsEWa4LX0Ega7vcP2A7XuJskRmNHMurPf3pGYerqxptjiaWkVRLqBGAKhCYXqPH0V5Xkslr03pXiGHVYzhVRVVeS7NvF3SgJRSwt5ViPNCWBPGehEGNRNxdZxBVUriPbXMY1LF8L67uqR7d3V6LVTIayDsd9z/8IHdx0/kaaG0+T/b1OjWanRrkVMRBlkrqtPUXAlLbHZXGWMNzjk0WkB8SwcyVpKhuqsLzDhwuvrR0h5WyKgAqoH4lFnub5j3e9bDgRRWATVF4zcXXP7NXzN+9Q7bj+KpqsSsf727J9zfkxcB/zKSkcgpUVoKk7SrK8Zb1iWy7A7ENcoMa2OQw5rpBs9wMZ4ETjnJOsoorO+wvVwvlpAoMZ1SqeZi+Kje8737GWyuWZaVi3FAGcWyhDbrWUhJLlqcs5QiZvcKxe39nnfXF2JJpeSC5hihmWJuCngoVKyxjENPRZTrIYQGHCWTPqVMKYUYI33XEXOGysmUv+88fd8xDiNKy3HtdgdhPEMU66QKMUXWEE7q+3fXVwDs91Pbj3itCqur6Tr/4I0aImEVUdKxVS8K/kpKic04yvczF/Z7MbW/urpgXhaoYJ2BUnHO8fHmjhAiv/jZe3Ip/O/+D//HF7+tvrSeW9md61znOte/lfoSiPnTxEq0icvGdD6wmz8uInp9vZc98yfe8afW/5GNfYZ8H9Ojj5Z6AKH1Kah8Nu75eFL1FV736YIlEe4/Mf3+H9n95u9ZP/4W1lnAjVKSztNmC42zGK0xvUPVJvzwHg3NCwiU77C9o7vY4rYjVotVUamFGgLLspBjlFnHUkXVrhRFidgjrwuqZGm/G8k9t97jhw5NJYeVcH8gV2n1lxRRpbS2tyTqzLcHwmERAGdkfrECMWVqESui66trVBWFttKa2qyZjgbpKAFVth9wmxE3jCjrpG2uFHEKxGlPmg6UJIbjm8sLlqqI84rvHN7ZJjCysv8gIAgtxvIqg9v0YBQ1FKzpJSGpIiBUa/HtvNzi+h6lrQDYUlFKmFylNaqZmlfnSDEw//CB6dNHlsOhjR0YjHNs3r9n+/V7hstrdDdQc6KuC2ldSdOeOM8yexsjZJmHLTFQwkrNIihDKYwStvDwwx3rsopv55rQKKwF7xz9+wvGbY8fPZVKioVaNd1m09hXEXDFOZJCOPm1qgJdXPlZ/C1u+Q374ef4d3/H/b5wcbGh7wXYCSMq57NWyZpf5sLl5Za+8/zh+4/8zV/9XIBxLk1gpOl7L4r9lHDWMLdITe/lV4YY62v2hwljTMuYF+DnvMPhmKYZ7xzmwrAsC+sasMbI/GYux2aJtPxLJjRrpYvtBoBPN/fs9gfev7sSNtVqUdrH2GZfxcKs7zuc81hrcdY1Zb9mDRLPWmphmmZSyozjQN95rq4u+MP3H/n1b37P9dVGjP9D+9w7z/XVBWtr72/H8Y3fYec617nOda4/tX4CI/oDz9vvr89Nfgld+vSxp56hb9QjUPkqw9BA8fOpgMfo84XIiAd4fdzowaGpUnIg7m/Z//6fWb79B8LH31DmXTsGmQ2UGdbGVJaK6S3aaihH9lTshlSV2VnT9XTvrumvrkRFrgQwlRAIhwNpnqkt7lBphe06ipa50BoSqArGCGgNSXw6NyPWCsNWksRKlpzJbV7UNLV4zpW4LqyztJ5rrlhv0UahqsRA5rbfYTvih06sc3LBNqU7qrHNtaJ9h9uM+K5He99Oo7TT07qy7vaUdRZAiFwZ5SDiqFoyWqmTur2UpqKOuYlaalPcW5kZ1AaFCH3a7tHG0G039O+useMggqWUxZZKm6bbaoxoTtRaiNPE/vaWw80N6+1EzQmqwgwDF3/7Sy5//jO6cZB9KA3GkkNg+fiBsgZKFeFTjUlmdFMSoB+jiFucoZZCDIl5PxPmFWol10IIYrt1cblhe3WBcRa0wfjGbscsQQKdxziZI01rJK3i4VpjAi2Me27zwOsiDgY1ZpL27C/+mv27v0VfvCcjs7WxJSsZrWV+MkQ2m4HOd+x3EzEnyYUHGSNonp5imO9kTpXKPAdAGMNjWz6XQggBZyylVozWWGdPmfLHDsUxrtO3UYXOe9YQBBwOPdbaNvMpiVB911GpfPh4Q995TLvo6ftePjdaYbTMesYkVkveeWKMp98ROeeTh6p1lmVZpTXfea6vL9nt9uwPE9O08O76Emct+4Mwr8477m53pJT5+c/f89/8b/73b/9u+pE6M6LnOte5/q3Wn5kRfQNQnhDfS3bzR9erj7f68YMVlvSNX+rq4Z96XPcLjaiPgLXmRAkL8XDH8uG3zN/9M/P3vyEebtosoXhoUivaFGwT62jbUmRyA7tJ2upKyx924zx+3OIuNrjNgLEiBKkxE+cDYb8jTjNpjRirMV2HsuL1KG1zMYk3zlCrRmsRCPlhQGuFMkYiGmOmrJFMoZ4Uy5WYE2kJ4sMZ1mYJq9BOQKN2BmsEcKimFDbOAArrm/+n0Q1za3TnscOAGwZRvee275xJ60KcDuR5ltOv26xiaPtOBW0tFEhVWK2qFKUpvTEKYxpDqiVZp6aCrlWERUbjug43DOIiMI5oYyXmtCCm80aiIKm1WVclwm7HfHvDfHfLeljIIVNzkTlc6+gvLujGLcYJC1lyJoepsZEzNUUBaQlyCKR5kX3CKcazpMIyLUz7CYqo37UzMs5gNFd9x7AdxXZI6dMnTxtNqRrXjOKplXCYifPa5oLTCZCnUMgxEdfQvDZlXlZ3jtEbfvE+MPz8QNh0fL923ISemwhrCPRdJ0x9YzLFW1SOM6YkefNAVUrsoKwi5kxcFi624ynhKKVECIHtdoO3otIvJUOuDwlItVKqxMNao0957TFEnHMs68o8r2w3AoBrcxfwjflXSlFr5fJiK0b4VsYvcsrs5pWuczL32jmM7TnsJ6Y4nWJLtZIY1GOq1BHgjkNPKaWlTjm2jKSUubvfMY4D261YaeWU2WwGQkwsZ/umc53rXOf6i9VPivh8jDfVYwz6peKjpyu9ylC+WW+YzKv6GgvKy1svXesBKDmRlgPx8Inw6TuW7/+F5YffkPa3KH0ECqblp4uyHGswnRUQpiDnikoFVZutkHOYo0H70OOGAd2UyjlnlsOOcNiTD7MwnUVmK3XzoMwpiVAlZZkRNBblDNqZk3VTLbnlrecWCZnQtYqAqFQoYmaf1iAsUWpZ296JalnpkzrdO0ejZ7FOYje11aCFnVPGigVRL36n2kk6T4mJOM3kZZF2dYziUdrYtFqK+E4e059QYIzMquZErpkcJQVIwK5BKYM2FuOb+b1S4HTLuu/pLi/EfsoImyiiHjHhf+zskCvEJbDc3xF298RpT0kyt+icR6tCrQo/dMLKhsD+N78l3l8wvLsWBr75l6qj8GU+kGMmxoxRCm0NcY3EObKu0jqvpZzCCdzgsH2H7zp87+XzUkR0ZZyjH3pM1wlYj4k4TyfT/hQjaV2lVTx4ShNrxZgbC5qQqQzDcDFw+bNrrn/xnuHdlXwPcuQrv/LD/T2/UZU73VG0JyE2YbXIrOSR+cxWZjJLrS2C1VJSxFuL0RLTadt8cgyJkAL7/YHNOKKNxrmuqe4Tawho1VT6LYO+NGN80xht4wxaiQl+7Vxr+3uMKSzzwoKEI4DMpGqlxXRfgbX6BDJTG/fo+551XQlBFPYo0EaRcvteGkNoYjdrDesaGQZp5//i519xd78nxiQq/1KIsYn2lKj9z3Wuc53rXH+Z+vKIz/rWz48f+Lx66SlF+wXtqtck8s86/4/hZm0s2AkcP50kODGqtRTyuiPc/IH19jvCp9+z3nxLvP9EXmcR8xjJJKdKPrW2Bu08VusmOGpilCxCD9M5XCf57sb32L7DeS/AMgTW21tp5S4LsSmKtdJgDaqqBmASJYoCnFoxTjw/j6AfFDUm1hDJMVCigDzVRgpCkbz0sIhf6VGJDsKmCvOGgD3nWtSmAMRjnro2AjaU0WK7NG5wQzOdN5JglFMizzNpmsjLQkmxWUVJ5GethdIEN2iN8V7GD5r4Cl3Rg6euAXIlV4NCY40AeN0uKbSzuHHAjwN26E6gWCnz8Flqn40jY51zYT0cmG7uBOyHFW1kPVHOG5xVmCizliVLBKrxVt4/o8nzhLYN5MY2m5lSA9hyQZIVlFhYp5UwB8lgP86gakO/GRk2vZx3K0k/NH/WYTviuk4iTJUir4k0T6z7A2EW8ZO2Guf9SfkeY2wiJgHTftPTbUe27y65+OqKYbsRFr0qwiRrxcOEm2b+NmTe07Or77m376jKNiGZxjl1el+Uyi1bvpzM/FNObDajRIVmGUWxznDZbcltpjROqaUZqWa3FIk1tThaOb8iJpOxD2cth8PEdrN5YjFFFa/P1Fr7yxrQWsRzxhq8cczTgnOOzWjJRRKj5mlBaUXnvVh9tQAH7xzl6IGqxL+0tGx650wDswFrLZ13jEPPGiJaG/reSBxoO/fnOte5znWuv0z9JEb0WMexuxf584/qi+Y+n3CYb0qFTgs+efTR+g8Cp2MUYLu/3StzgoW0TMT7HyRe8+b3rLffkvZ31BwoQYCbNhrlJbNaI7Nous0rUsTeRlk5bba13W0/YMcBN/aoCpRCjbEBIWntpnlBA9qbpmaXeEZyPkJomTtVtflaapTVULOAv1xFHR+itMBjlHa9MWgvauLD/V7skypQG5hxTuZArQiMSlXSmtfi06kN4oWZ6ynu0/Y9ppfsddN1ogAvhXCYxTw/SIJTyTLzWBHAUlMSXNgAi4wXVNIqaveCCJtMJ2ImcsG6DqUtqgmL0GK6748AdBybtVUVd/vGkkrKpNxfciEuK3E5tOSjA3EN8l4pBVWfsuzJ5QSIrJd5RTtIupJx9jTbkUOLR43C7GqnKUrYwLQ25hMIiyRM9aOnFDDG4keP77vTBYTWYtwvUactkrQkSgrCLt4fiCEIyCxVXANAojnbrG9KosS33rL5+h2XP/+a8XKD7cSVQWkRNS1396z3O+KyUmIUT9WcGcqKX/dszEcuas+du+LQXZO0wzon57EUcq6neMxahWk/Ku1rRUyytBZwaIRZ1Fp+IcQgbOPRBB9bT618reQ7tUwRf3WBQrHb7YVpdRbfFPHj2GOtJCZNccYaizXCrlo74L3EnhYq3jtS89GttbLbH/jZz96fhEylAdUYExcXG6ichFvLEoQxjTL20HfC8lsjANRagzVW3vMWK3uuc53rXOf689dPS1aCJkBoN17Uj82JqgY369PHjus9R7TqseCBF8+R+xvXeWJNW3u2sZk5zITb71k+/IZw8w15+kRZDtS4kFOkRPljpbTCOEtVMtep27GWWjEoxHKpAho7bvDbLdbZ1kbuUNZScyTud5R1FaawpdWgFMpZMYhv4qSaC7pmQFGVgVrEnsmLwvso7Fl3EymKsOfIfiqtJclo6FvSksHmgrKW+eONpPk4aYla74QRbOfEtLasgLnGyhoLnaMbetzQyesxYo+TayUts6jeYxTRD4iP52aL6byo4lOUJJsGYFBIyzeX1jVXgMzuqWpRBWw3oEobfzgyykOPHQYZQTCaqmWWUmkDDfAoBKynGFgPe9b7e8JhT1lWASC1nmI7tZK5zpprA5QGN2g5P53HeC8zoSlLBGqK1CTzo8f8daW1sJJrZJ1mchBhkta6ib3EJF5r1RKpoKaEHQf80GP6XlwJEPCaQ2Ld76FWUpB2+3FcAlUI6yqfkZYUVEpurKAwxsPVlv5igxs3oBRpWYnrRNgfiAe5UBA2spJypWTIGRSZId/j8h3v6j3lInDn3/NhdczFCqubs3ifNlGaAL9AKRnvHKmJf0w7J8YotHbyfuSV1AIGUkpsN9K2z0kYz5yazdK6stkMzPMqs6LLwmYcSFE8VvtemGBnLVC5vb3Hey+t/WbddL/b47zFO/Em1UoRosyuGm2wzlArDENPjElspZqTQMoZRcAYLaJApWRmtM3JxhjJ2bRfQc3O7FznOte5zvUXqZ/GiD4DoE+08i/AqXrl9k+YCm2A4sEw//Ey9Rkje6REJSUnh5n15nvWD//C8sOvifcfqHGi5kjJqdG5wpxqA8q4RrRVAU1wapdTFTiHG0ZM5/DbiwaUHKoWSlyJ+3vivAgAiAllGu7SoNBtHTF+r+2P/fF11QqkpvR14oWZ1thmBYXdLLnIH92+w/QOM3QSb9kEPiUmVKkMY48tl5ASGC12Ue2PqACLZl6ehGVVQ0d3cYEberRxIroy8ge8xERcDgLWU5E2v7Uo53HDRs6HMyht6K7eY/pP3P72N6RlBaXaCIASACkHgNEy3qBQYqVkNcZb/HaDG3s5p1qM54X+syLMUvJ+Ka1aetTCetiz3N+z7g6kGKhJkquMs2jarGkVsJirxKSaTlr9xrb0JydvVJhmUkt1KkkENmjh10MMqFxJMXLY7QlTwHaOzbtrus2GvMzUNaKPn8Ra6TZb+mbLpZuVUy2ZNB1YDzPrtEBO7TyJAE7GIiApg0qGmNaTHZL13QmEKhQ1JPYfPrAcJqw2lLCSs/iXaqXAGcqaKEWhtaFk+RhrY3DOcnkxMFz0KJ1J+papd/z+YPld7rlJlZgy1hjxddUa3+aKj9+3mBKmzRQrpM29rkF8SrOATaUbk9jEUAC+cy1rXsYYhqGn6zyfbu7QRtOZjlqqCO+a04KkIFV2+0msnS629F1H5z3zupzAaqmV66tLoJBLfnBLaL93QvMmpQmZXPPY7ZwVNnzomeaFTKHrOnIupBTp+04uLs51rnOd61x/kfqJM6Kfmf18Nrv5JQKmp1n16sl9R7BYEYAoNNNTKHsEDMJoRcLNtxx+/4/M3/0T+fAR8oqqCVDkEEnLAii0s9jeoZ2o10/sZ5ZEpJorBTBdx/DuHd3lJc53DVjJH7g8T4T725YLL4ptZWiKaCglN/FORiOANldRSOvjaz6OG9QmRNnviWsiNVCllRiCO28ZrkbsMGA7f4oUzctEmhdUrShr0YChkK0+pfmc2tMiSUcpsNsLuostdhjkNTWaO6dM3C+UHFA8zO1hFMYN+M0G2/cCNNqacVklJen2g4ChUolLACdsrDUG3/uWOS/zo9oYussr3MUFruvbzK20kGUI0bYZTZp5v/iLlrgS55llf8+6E/Bfc8VoRzUZ7UTkpIyB0gzgq1hUuY0AXd3siUThH8WEPgRqa4PXIqx1jhGMeN+vu4lpP2OcRHxe/81fMX71NabviWtg/933hI8f8OPAcH2BG8eTeKrmTJhm1t09aZVEIWUqKVRSThI8YAt5XkhJ/Ggvf3ZNypnlMENRGKXkosYI8D/GkrIsZITdVs2iKzYRjwA5uWAzTtN1HeN2Q7cZhflPclFmc6Bf9/zVMnNZHX/QI79PF5TuSmZEU25solgs1VJZ1kCIYsUEgqm7rmNZFlLO5FW8PUNK2MY6ppwxJrMZR2KMwmgaC1pxebmVCNIQWXMQKzEjQiyAvvP4C0/Omfv7PYtf6LoO7zwg6Ur7w8R+P3F9ddFmX61YN2kZD9HtgmhprPnQ4kSnZeXiQkIUNptRIkhrJcaIPyVBffHl87nOda5znesn1k+yb/rxlvxbAqR6+uclJ/rIuxNeqqKOd6n6AFyb+rrmTLj5gel3/4XDN/+JePsNNQdhoTRQKjmmlj3eRAqdw3Re7HNqRVeFrogYSWtSibiLkeFnX9FtL7Fdh6qipC3LQtxPpHmSSMeWkKOMRXtDyYH5sBfjeN3sjoqAWrFykvZ0rSIiSjGzHBbSKn98AWm/lyoM6HbEX2zaCICYyZcUqEuBkqlJPEKPPqS1tfRN5zBdj1L2NPunncf2Pb4XpbY2RkRFpbDu96T9rrGYLanIOXTX4fyI9h4DDfQL67fs9hy+/wPr7R3xcKDRV6AUfuwwTmI0rXeQJBFIO9tM73uG6/fofoAcmzl8QvcCkqDKcWiopRDmAzmspHmC5j/abS9BOXLz6VTaSoRqAy8Y6K8vROCkpTVPKaQwk2OiNnV9SRVlhLktVFIK5BTbHKdi2U/M88LX/+6veffv/icM799LXKlSoDXedVz9rSFddmjVlP9Gnrvu9xw+fCLc74XdNJqjcMwMHV4rnBefUj30AjSdk1TVLP6acgGWT2mr2hls70Qpd0xoSol5N7Pug0SzNtGY2HBZxncXdJcXGO9kJjmsJAWZQjgshHWlaM1GR/6n5hO/5I4/xD3fm6/ZFxETHT7dcrEZGTeD+LFGcRSQpK2CKpnLyy1393uM1i1PnvZvPTlDhBDY7SeMVnRjx25/oOQsQNeJO0OICWttA76FzWZkmhc2m4GN0qdUpwpisH+0eQqBu7sdISX6zvPV+3cMQy8RuGtgGAfGsef+/oDRmjmsjOMgKn2luLzYcn15QS6Zmyz2Z/O8MM3nrPlznetc5/pL1Rcb2n/68B2vCopeU7Yf73/SHlNvzIY+//ERu/q81a9kjXS4Y/7Drzj8+n9g+e6fKeEgLJ11Ivsp4gPY/hZKfKS34o1prIhUlBYWCWnBG+fwF1vc5gLTDQLggjBYeV0I+5l02As72Hlp4+ZKzpWakjBoJaNqEe9LQBnJPq9VPEprldzwuCbW/YF1DmhtMfbohSW+lv3VBX4zopwThjaJQGmdF2qMLe+7wf6MtN+NQluH7jtM7yXRKQtT6scRNwwnU/iKvKY4HYTFXMMpdtJ0HtMP2M0ltutRKVJybKlOmuX2jv0P37Pc3kCKqDaHkIKopPuLEdt7FKISPwI22zv8dsQNXZuRrWhjWe/u2X26o5ZKf33F5qv3+HEQxjcFaorksFBQzaagkGImzascdxbAVWshxdSYT4M2Dj/2aNuM4Q8HYVCbjdVx6kIYV2RWc17EBqulTNm+p9tsGd9ds/nFL1CuE0DVWNu6zuRpT82SFX/8jGprufn9H7j5zW/RpUiqljHNhWDAeEueFjQZZSwlZVKRedqSMrrqU9AAVozciRFlPRWNqgWlDVULI73cT8QlyviDki6B6zvGdxf0V1u0cwLWlaLElTAdWA8TqVSss1ALcQ5yTkqVqNdaSXbkQ93wm3TFTbTM88r1pSjd1yDemn3fyYym1mw2IwrFNC/YdkFwVKmXWnHWkVIS1rYJ9LrOn+I8rbNYY04eojFlNsNAiJHDYSLEyNXVhcxxhsT9/oBtKV/OO4a+k98wzc4Mpbi63GKMYW5m9l3nSSnhvbCph2mW55VKTJLYZIzh4mKkotjtD3z8cMP/9f/2f//s78fP1dnQ/lznOte/1fozG9rDq2zoCwDKSQX+VOn+jDWtDwr3x0Kol3OmikqhhJnpw7fc/ON/4O6f/3tY7xkGj7EW1XwKy7xQq0JZjSoSZ6itFv/J7aa1JFM7Ppk3rNYyXr/HjSOml+jImiLpsCfc74SBrJJYJGb1mXhUMzdRCLXiOi+CpNyAipHjqiWL3U+pAmaXQApNRV5A6YxSBr8Z6C822L5rqU2ZPC+UnKklo0rC1CzRlTlQqhG21omdlB58i9w0GCOzlXbcoL0XBq9WalyJMbLudqRlPs2+1ZRR1uGv3+G32+Z5CkpXatcR7hbm7//Aen9DnCbxVrSaiiUnYWSNdnirMcY2Y/8ilkgXG+zQCxhSirSK4j7c7Vhud9J+1pp+M5IPO6YayVfXAhZJAkpQkAtxjSz3B/K8yoUH8iGvttBtB/rrLdoZmt8BNRfWeSbPS3MbkHnFkjMpFWEorczlliWcRGv+cmTz/h39Zku/vRAhWi3UGEAZSgqUaSesdMlQsmTZOy/xommlv77kov4NabenrhG76eg2g1yYpIT2BqUcpQmbcouT9I39VkpRjYQHGKUo1lNjktesNGEJxMPcrJ1EEGe9pRs7+osLhqsNxrvjKLQw34cD634vEZhKYaw+WW3RkpAUGee8jDeEwM/zxLv0AzfuK36dew5Jgg8k1ShLkpI1HA7zyUjeWcsSAp0X+6RcC5331FowRpMUbIahWX0J+330Nl1SxFnDMPRonVnXIGr6vsc5RwwRnMybfuWvmaYFrREzfi3euPvdJNZkSjFNC8PQo5C2fIyR3PxHx2Gg5MxutwelcNbQ9579YSLfZrQRFf0vf/H1T/s1ea5znetc5/ri+qPsm55XrfWRHOnxv0ehUX0Vw/Jk22NJ67qWTF5n5k9/4P43/5nbf/6PLB9+B2VFG4u2ljUVPJLqU3OhgLT3vMVYh+u9MD5tL2VdRR3dgEjNTcTSb7HbC/KySNt9kj/YtNx4lCbnQjzMYkWjFc5J1rqMSorCWFVEgd48e0qS+cBlmolzgFyaRZFY3zhvGLcDbhTDe2hALUYBjjmJwl1rdBWrJN05dC8tZ93GE4yxaO9R1mJ9jzFWIketpB6lZRHrqukg65aCMlaYSuux7wQsGi0gvBxWYWCXhf2nG+YfPqBqEnESGmVdi5/MaGRm0Wh1ejM14LcDZjOKSX+FtJtIiwCnHCTpCWC4EAsi452kTnmHKkky1VNu7GUl3jcAhQiqoFIb8Oi2A67v0E3UVHMihkBcgqyhlajodaXUQq6ZRCLPESrNQxMuvr6mu7xiuLzEjyM0v9JaZb625AzhQEmrMKBavGaV69C+O82fVu8ZO08/Dhxuboi7fTODb48rqNZLpOVhj05y8SIXJvXkxqCMatZa4l1aW4KRXNAkYYi1wvceP3SMX13SX1/h+o6ai4yPpESKibjMxLBgvMFZTymVvEQB0srJuQmhjTAkCVqoYjFWc+IrvuNno2fuv+I7vuK29NzuA9OycGG3DEMHtbBGsSOTfPpVGE4gpySfS60Yx4EQgzCU3lO1JsXENAVCTCc7KOcczltiThQqfd8BEEIEFEpV2RZw1hJjQmfNOA7c3t1zdbmllMo0zW17mgm+APHcychNypmh70UcqTRDPwDgvSen9OUCy3Od61znOtdPrp+WrNTae8/vO91+FXjWFwKmB25U2qL1KNzJgTTvmX74lt3v/5n9N//I/MPvSNNOfC+dBSPCF2s1phTICusMZuxkzrPrpK3d+q81ZpkJpKUOhUhOkumtW2zg+ukHVA4tvz2exFclV+I6yx/jKK1T3eYk0boJauQUquYLWmompyJga35QPnedtAKVUfhOUpeMNY1QLmJ2HyN5FZZVO4tBLH1Mm0O1fScgzErEp7YGM26wXYf1Hcq603hCCStxd086TKT5QEmpAdke0w+YQdT/znl555o36DodmG9uOXz4xHq/R+s2P2ucjCXGRJ6EqTRWkm+UAmU1ru/w20HYT62hQtxNjQVt6UdKCVutFWoYMJ3HDZ3Mkir5PJVm3l7WQA6JkgqUgvYO5RxqUGJLZUXscmR2SwwybrBGSszAQ/iAgLGVsAjIrlYELdZoTD8wvLtic32FsRIRWUulaqQFHxMl7FElI1wvba7YYZxHlXpyRihAWSNhd0fYH1BK46wWxhElrek1kpdVmNFSqOooKrLYrgPjwEhsbM1VQGNMIgJrEbPWGdAaN3Z0lxcM766wXWMgYz612MPunpwCymn82EY2Qmq+sS3iVStqSWgFWas2P6swmNZVULihQ6Ho8h1bNbHTWz5ebPiYNCGsKCW+tDFEQoh0XSeJRMfpHKVIJaEyJKUYhk70ac08f7sdKaWwby34wzRjXWQ7jlhj5OIxJnKRi4aUIkqJn6m4hmWO0aDrutJ3nhiOs8DigtF1XuZKnfxOWtfAOA7sdocWI2oJMZ3Y21oLtW13rnOd61zn+svUT1DNP5/tPAqHXmz4ypOPN44TikeT+dqU0Pest98zff8bDt/+iv03v2bd3Uucn7P4UYQ31iuMVq2taBuwakCml1QVynEGMkl2fJQ/YLXNqoHGeoPxTp5jFKpCng6nVmFeEinEFrWYcd6Ij2MnLJW0TiVb/BhfmUMgr1HMtpOAT5lNdei2L+Ndm+1sKv0YiWuUVnupjTWSlru2RqI2texHH22YmjG77XsBs12Ptq55ThbqehD26+5G8t6b7ZLtR+xmK+36cYPtBjFVn2fiurDe3bPc3rDc35PXlbQGaff2ncx7VoVqCu6qM7kWjBKfST90+O2I7n2bh82kw0yJElNaj/PCugmhUBjv5Hz0ol7OWVg4SgPxa5Txh9TiMjsRT5m+a/ZLckFQcvP/zNJej4vk2SulT4/HEAnzwtIuDIy1OOcZr68Zr6/oLy6wncRClmZtVRs4q9MijCSlvQaHdhLXqcVqoc0Ly5zwutsTdntyijI72UYSaBcqeQ3UnNEaihHHB+ddi1G1zfZLxktyiKRJ4jxLKmDFgkqhsF2HG3v8doMfe6CSl0Cp8jnK00RcZSRBW/lelJTkAqvKPLEyipKyHFeSL6nxVsRWSoR2qtZ2Lpq1WQVbE+/tjvdd4G/cFZ+U4Q/3K6EOOO+53+2Y5oWvrq+EbUaRqawxYrW00NdF4ZxjXVf5OYaTXdNoDSll5nlhXSW4QVr1IlTSraNwNN4/GteLCb1prg6a+/ud2Gl1HSknjNHEJEKoGMUzNKyBy8uttONzIaUVazXOOGISBwJr/yyNo3Od61znOtcr9RMM7V8O3D8Z6TxZMD1nSBvzKYsAippWwv6G5eM3TN9/w/TDbzj88C3h/paaE0bLvJZ10vbVtv3hMUqMw51DezEsdy2qsKRETaVlcBdKzA3YVDBiAG+cFSNyo05zkHmRiMa4xsYmJZmZRLLEXSdJSKbNmypjBSzFRFrXZjgOtXkfVqVE6OLtg+G8d9LWVog3aIrildjy5EsShtGaBra8eHqiFCoXtNfYYcR0PW4zYpq3oWqt2rjMpHmWmdV5JS+TuARYi91sMOMGN17ixhHVddQK8bBjubtl+fSJ5f6OdJhatKSMNRilmrG+wvmuibcrqIrzA8oarPdYq9DKoKwlHmbW/QSlUmKWNKdmNaSsiHWMc5jOQZvTzSGf5kZLiM2bteV8G4sdOtzQy8WIFYW0EMUGrKHEQGojB5QmXFKauEZSFG/QuEZyjFhnGa8v2Xz1nuH6Cr/ZCKNWaFPNWkIHinyWoF28WEmC0lass5QMmrbIz0iaZ+J+T1pX4rxSsyjEJXWqzSLnhFYKaw1FN7FTEocEiSDlNGtacyWFQF5iGyURFwbJr+/othv8ZsQ6J1ZhQTxsc4GwiMUVpcjssBGRV6mVikS4mmPAQUUAfEsVM71Ht7nRWkrzoFUSw5pSi17VVKX4/7L3n0uSZVmWJvYdeokSM3MWEUm6RmowD4DXGhkRvA3eBC+CGUCkZ9DVVUmCuLsRZZccih/7qHpWo6clqivjF3S3ZGV2hJu5kqt699l7rW+ZbqB/euD9duQPSnF4UHw+L7ysDpUcl1C5LAumcUhrqRilWza8kwNE+06ptRBCaUYlaUb7vsOtlpgk2SrnQinhZmRa1yB/xsnneL2md5XSjFGKvu+4TDO5iN6zIgEVKYur3lrDNC0t+UlMVsYa+WxmQY2llFnvEZ/3ute97vWb1b8ZaH9zvv//DD7/a87QdsNDU9NKPL8wf/0zl1/+hfnLX1hfP5OmC3FdyUlu+sZpnLUYrW9GJOOF+ynTQieNWNMJllyJ0yKMxlLJIYuuq1RsZ3Gboa2WW1qSlZ+T+MYoqTRzuJlutFbYrjVjnZOIz4b3qbUSpoZbQowtSltBCllx5Wtv8Z3DeDEM0VaPeVolk12EgHKjA5S1gtmxVvSRzrXfq2RKZuX52qHHdKPoBnMWPevSIjevDW2I0kD7DjuOuN0e04/orjXrYWX9+sz88sL6+kJaLqRlFTNUa7ZUU1IYJyvqkosA+o0FrzG9ZLJLQ1AoMRHCCnkWMHxIuN5hend774z36Ja5TlsH57ASLwtpbprYJJpH7Qx2kIQl7Z00so0hS61o67HDIEB/Z/G7PcvbC+vzi8R8roKCKilJ89ZSqIanBzbffWR894jzfdN4muYUF3e+auSCes0+NxrVCZYJ32OaUaymRFpm4uVCmifRoTZZh1YK1XffPHkxkkOU62joJVspVGnqtEYhryEgeK4smtgaczNPaaxWuM1It93iN4O8ntfrf11ZDkeZyF7DEkqh5EoKCWU11vtboIEymhqjHKIKUIW/6rpemnHVZCalTU+zMG0plWo0br+n3+1Ef91iMamFd31iWI/sLhN7ZXnpBr7mgTk7UspysLxFl2Y671jWwBIC+91GAhQaEULBbZLqnaEUaYFjiJTakp2MTEf7zlMrt1Qrcb5n1KAYhoFaYQ0rIQSGQdb/rm0QQhRMVymVzWYkhMi6Bqw1rMuKtYau79D/ta+2e93rXve619+l/g2r+fKv/8F1QnqVhf6X/04JZibNR+bP/8Llx/+d6fOfWV6+sJyPqJywXpo4pcA5acZc51qcocGOPa7vpRFsDa0YZhQ5pNaAhrYabek/2mCdNIJ+M4hTPn+LbKRN4OJlaXghmYYZK7/betN4j7ol7VREPjqTo6wBjREW5BXXYzqH63vc0CZKpVBjIq8zKUpkpEC1aRnlTfPZohRRShora741n0MvK3rfYZpmsLRJZjoeyC3z/Tq5qspiN1u6/QO2H8RA03VghFM5//wz0y8/EU4naZiswhqNcmLIoFSMbklIVbUY0IrtXWsKveCftELlRA6RuEoW+xXTZLxMMJW32M1wy1W/XSpZtLBpCeRlaZNCyZjXTfN6bUKN940QUCkpYbsBN25kNd93Mi1WilQXKBL3GdaFdVqBilEG0/WMTw/07x7xu11ryERbWdGiB15nILcGX6JXq7borhP2q+/bmh8x0MVEeH0hHI+yZm/pBMZY9CCpUCVnqIWyNoatAtv12HGklkzMM+RCiqJLru1sVwCufxeImWzs6DZbuv1WwgSayazEQDyfWQ8HcggoK1GoGshFNKfaGGlarW0D0CIms2khLSvaKNzYJBXt/aFWMaQpI83tGkAb9Diw/fQd49MjRokmVmQYgr1aDgfWw4leK77rIk9l4Ydu5ue142vsSWorKUZIIwrymV8DTNPMOA6UIrqamJJoqpu+VGvdmKGSzKRNazpjYlkD3rWI0RTpfEdWhePxzGYzMA491uiGb8q3Zlgp1T6TinlZGIaOh4ctMWW00uiGnNJKsyx3jei97nWve/1W9d8pflK3/1v/tgltN9GyXli+/pnTn/8j00//iXB+aevjFa1hs+0Zdlu6zcj5yzPhcm7Z4rZpKU1rYgyaKg0LwsoMs9z4coiSnJOLrNytwW07/DhgWsNUUyadz5SGhkkh3aaHNdfG+QTXCVvUWGkkUpC1e24rc20stcoN0HXSbGIMGmlCdWt8S4zkJcjPxpUaU4vobN26NSjb4fpO4i0bdgrAdB47jGI86jzaSX492pLWQHj+hTTP1LBCTsL21AYzDMI+3WwxvkNbB9pQqcT5wvz8leXlK/Fyaave2Nb2I2FOoldUSJZ9KhSVpLEee5k+O9EuVqMpUZqruCzkeW3TXcAabDMcGdekE10nr3WLVC0xktoEVHSjAFXwWr2jxEQiY5S+xYKqAqYbsPv+m7628SnTPHH55TPnX74Qzheg3DSQbhjYPD2y+/QBv9vfZCVKe3COsi6k81t77uoGoEdblG/XXaMloLVMoMMi8P7zidoOANpalLNyfdUqMPlcUfWqHa5tku1aXrkclqz3skJeF3JsxjklUhBRGFTsdqDbCuBfCZ8I1Q+AYn17Y37+QklyoFDeQKqUhqjS+nqgkgMhJZOzNMUpyPthOicpVLpK2EDLaxdxKLjeUKtDe49/eGB4/170ziDyCa3Jl4n59ZUU1mYms9I4ohi8pasBv7zyPsFbeeLnZU8dHzFWMuuHvmOvNSFEUosVRUGIqTWrV3OkcEFLqXjvGYe+Qe8lNanWq4ZdOMPOWVIphBAxVkxUfd8R1tiwTRtC05ZSK7vdhtPpItNzK5/1cRiY5kWiSJtb/173ute97vX3r39DI/q3bvjmfm9TSlCUOLO8/JXLj/+R85/+I+fPP5Hjim6IFW0M+w+PbJ8e6Mce1VAu/W7L8adfKHGVyZu1bfrUTC8FaShzFuxNMwjlKOvw/mFLt+mlmTJyQ0dr4rSwHM6kJcqk0bW8RiUrdUrFdxY/NDe70hRkspZWiQW1nZdpGOJc1lZiK42XtbPEY0JNiTBdZNLakDky3ZTGVhmNHXvMMDSji5F1rlJYpXDjBue9EFNrBW0BLY3PNFFiIM8XCFGMLMaghy3d/lH4p9aB8/I+hIVwuUjjGVbSfGE9nSkpiwRijRhtBIOlr/zGQmmP0Y2jNBzOSHpVijJtPEXitDYEVVvhOisrd2cxfS/O98ajLOtKrhCnhTzNkCTHPafm2O4cymqKVqTpIpreRjUw3tM9vRMQPDKNV1Ya1BxWpuefePvLj1waCF98SxrTe54+fuDhh4/YbqCxn8SFbj0lBMr5ACVBc1lXxIBkNhvhsJbWqJdMpZDmQDgdyNNFVuxtalitw4yjTM2XpYUj1MYWVdB1+H2HabSEmjI1JEps+uJ5pkSZ4GsjGCp5bx39fhRzltaCA0PW9svhlfX5hfVwaJgyCTwQs5G8L9bK+p1am841i445S+wnja+rmv7a+F6kGw2ZphANJrlghp6Hp3fYoaGsSqYsEyUn4nRhfjsQF5E02M5iseRaSakSzhdyCJhSeLDwqL7wMb3wuj7xykdeoiWXgrcG66wEUJSCc5ZOOdb1my5zMw4oNKVmas2iAXXmNlnNOeE7MSsuS2RdV5YQedhvRDPbDEq+s+QkE05rLWuI0rTGBIpmaDLCGs2ZzWa4Oevvda973etev039+kb0bxOU2uq9pkB4+5HTn/5fvP3T/8r69UdSWKDKdKcfPf1mw7Db4LvuNl3DNJB2FIPQ8G7PNYKzRGlWYkzkkCFLA1NTWxt6gxt7ti2l55pJXnOhLIH5MhHnINzOUtBO+I3XLG5jLHZwks+uZUpZikyT0hrEqe8NKRTiEgXv01m63mAb9B6Q6NA1UFKkhJU0TVSlG55p+MYo9a0B9bL+pGRKFEaiHUZs36GdQ7WGMK2B8PZGXldYF5RWlBgoS8D4DrvbyZq572WKaSzVedKyEl6+Eg8HSopilCkFSsX5jjVMaGVwvRODTdMlGm/pdju67Yhu08xaKiUn0nwhzQs5FFKMGOdwvWuufUE3UWjMSwNppaRCLoiMoek15feJftF0Dt23RvZKAlAaRaZ72LL97jvGhyes70S/aC1oR5jOnL9+4fzzL1zeToJhShljLePDnqfff8f2wxPWXVe6BWU70J4cI+V8QNUsE2MkIrMoje0GiUOthbrMDTtVScvCej4RLhcxbDlLjYWqROtJqSJzaEYWfTPkFdxuix0GCU9o0oVaKso6+t2W6e1ImS5iwuvEeId1uHHEDR6qNOQVca7nWomvX4nHI0ohLvkKaQmENbAGiYh1fU+36cWAlYQ4kFMU6kJzfmuURJpaS//uHcZ6clwoi1yvtYpRyu0f6T98EJkHSppUo4jrwvTlGbLoT/2mIy3CbM1AXgJ5Xtthr2CsxnaWkgp7DXte+IOa+Klu+OfjjpPfYBsCK+eM85ahH3DOEkKQbPhSMVY3w1Kh1Ilx6NufiWLEKhXtLc4VjB1ResZag2mxs+sascbinMV5x+U8sdmM1FpY13iD1yuFuOxTbFGigWW9k0Tvda973eu3ql8d8fn1y0/thpSIx69cfvyPHP7z/8bpx38mXC7YpuOsFfrdlv2HJ/rt0HSQMs2qVHKMxGWGnNCdQ5JqIrUqUoiE80JegzShtWKsxGVqb/CbHj+0htZKJnmaA2trluIsEz/d2IJoQS0ZoyUK0GmBgqckkzJtZCUcBadzZRLmZhTpNh1+09bdSsDiMYi+EaroUxtySVlLKQ0u70xzy/smVxA2ozYWNwzYrpMpZhVOqLKW5Xzi+PNnLl+esV4z7jYYbSi1Yroev3+k2+6aNlXWkaVACivheCIcD9QUpYFTihwjKUXIDVQOgKasgRQj2ju6naB/dNPNUWXym9ZAnGeWkzjph92mMUsHaZpKRRVBJGmtQdfm3k6Ey0IuVTLNG4xfJo+iORX3vUgjSs5oY/D7HbvvPjE8PspUUva71AJxmTn+8gvnr88sbyfCKjnjylq2Tw+8/+PvefjuI9YYSoud1Jsd9FvyMlPnEzSGKm1SiJZIUN3iIeWpV0pJYgJr07ySqxyQzBVeb4i5Es8XyPH2mqEteuiwFGznWsLSN22sQgxDdtzcppVxXZleDsRlEfi/sQ211egM1qKMhxhZ5gvx7UBtGK9aK2EOzOeZFCLWyaS+VqE22MHTWUcKawP6m+agb6zX/RbjHHleBe/ktDj1Y2JdxPWvADtsGD5+Ynz3SIkL6+sr4XSSdKMqzSEoUkwsp4VlXrBa4XuZ1uaYKEU0l1ctdFWI7KYWjqfAn18yh90f4f0PZBRhkVx3rTW2RYlaI5IFf01qKgXvHa41187bFrebsdYIqaAUYsw4Z26+yisH2FpLKVVSoVozOy/CHtVG03cd8zy3LQVcLhP/8//yf/vv/Y69R3ze6173+v/b+rtGfIbnv7K+/JXTn//fnH/8T8yvz7Ie15IP7UfP5nHP9ukR3/ctk7u2G7gihUCcL6K7NAbT9433KYzHuIQG+ZbpBhWMM/itx4/jzXBxdb2HaWE5XgiXhbiGFjtp5eZoBHXjOy8ausajzEFg4iVlWd+HhDPfDFCl/f5+M2A7Jw1areQ1SA55iJQiRhSQG4ztPSiZpHgn0P1SQDmPbtoy4zqZflrbmjKEEbkE1unM9HZgPRxE72ot1ndU69HbPeN+j+9FsnBllqYYWc8n4jSRlxXVjCml1oaeSSIvUHKzlSmnYKncpmfcPGH6QRqDnCDLa5JiJq6iG1W14rzHdB4/duheXOzqijTShhoiNa7kOZKCJNAIpgeK0qSSMKa2MIHcrgdaGIBj2G7YvH9P/7BvMaTIpJLC8nbg8vUr5+cX5rcLKWVAYXzH47t3PP7uO/YfPgrYvVaqsujdCNZJ4/32FUpsE1Aj0kfvRQdKRRWRX4AkMaV5kejTeZLpea1iWvKCbEqxkNoByqhK1e2ANAy43QZTM7pF2grbvmKcTO+1dd8g+aKFQGtL97hDn7UA8NMiDvfOoUyHMxIXSqfphoG0f+D8duD842dhpeaEKpWu79FGsEgoSWWyDSemtZHpvxawv3/Y48ZBtMwhyOGgOfVjEO1vifl2QIqXE2mdKeGCLpl4makKrLGUKnrTuIpkIwfhdGprKGhIWVLNtGuYqNya/cpynlinwHSYeEflw2Vmqq+8jd9xVCNciQ2l0DlpsOd1JbVDX62VELiFRcQUb875lLMY5IBUEjXWWxpa12gPWmteX954eNhSasb77iYPoFbWdcU1E58x+r6av9e97nWv37B+dSP6z/+P/zvL8SgGCa0FCL7rGfZt9T70GGtvzYh0jYqSW0pOkpx03XnympmfT6TL3PBG9YaJ0cbQ7Tu6UaDhSmthDra1eV4VcRJeZY755gw2WhiJtnPYwbdMb4kbzAiOJbam7YqI6XxzgVsjUPwGzaZkcgzEc5CIxBAb69PIlLVxMY0Vg5O20qDVNt30zmL6QZifVlzLFWn6cggs54nL56/MxyNaFxQV663kvW/3bD5+oHvYN8C5AmStndaF9XIhns/UKLSAWsSkkVuko6RGCVuxlkSEG57HPvyNZjFXifO8OuCXQG28yqtBxllpYnUvRjLt5HUTV3glhSh552toBweZ8paKsFwRaYWk1ChZ7Xcd/dMj49M7/G4jRrDSmsGQCNPE8vrM8vpGWBbmyyor9NGze/fI0/ef6B8eML6TaXOtYAy0lKcaJkix0QusHBqMxvgO5frWeMvjFynETDgeCZdLe80QDa7vqM6J7OIyo2qBlKlNV6p8Y3rutqicqIlbo2Q7j/Ue03WSZJTzbQpbSiLFlSydVMOAgR28vO7GYV0PiPFPa0tVikKlJAjzQlmjaJUHe4vhdGOPdQpdxaykjZEJYO/wuy1uM4p8ZV2pV74p0sDGaZbPtTEYK9IM5Qx+N2CdQVW5boXtKg14vASWk0SNKgV+kGliLglKQhnRUUuU6ILSmpwS83FimQOlCtBeKdCqsps/sysH4u4DB/OROLznEgohFSrcmshaKynL4abW+g0JVZrpzxicNaRcMNq0OF7btK/SvMYYGcdeTEn9SIyRJURAXPLOWeGmasGsKXOfaN7rXve6129Vv7oRXQ+vGCNA8G4z0u82+GHAWvNt/VoKuUpjKaaNSi1iNMoxEadAvMzEy0IMctN2g0cZI9DyTYcbOnEY1yvuJ7KeJ9KyQtX/KqnH9f2N9WltY1YaMdmEaSZNCzEm4hwpMckNv63uxKEvTavxXm5UOZOnmTQvksZUW967zEqBgrH+lj9vdJumKo3SFj2OmK7DddLwKS9TvhIiYVlYDm/ML6/MpwsqF2ExDgPWd/itaD/9di8r/ZIlTjMlclhI8yQNcS3oNnEMyyyA/Ny4lNSbXlPYoAbnPbbvWuMGNTWc1JU72Rzs1jmqkecp4Hkr+fGuxYlSUbmgOk+32aKdR3cnUgjUWRr2QgFjKEkc7DVnijWYrqPbjAyPT/QPj0IFUIpatRh3ppn1dGQ5HiQNaA6EZlbZPO7p3z2w+/iJfrvBdL00FEmmuKVFPprcdKdK3O9ohUISiwSPeYXQZ3IUTW9eFzGCRZmOaudRzje8kxiualiFLVpBOSf4rrFj2O/El9WoAMoYrJIJqOs7lHFUpYVPSkuACispiHaZIs71mjPucSfcViSkQClFNWKSW5eF6fWV48+fiacJYw3dpm+Ht4yxBt874dGqIprpAtVY7GDx+41Mv3MWzWrDYcVVGLp5WcTo1RKgtJEDg+k7tKqiXc6l6X0LeY4sl5k4rahaW9CEFpNdTti2/hdebKVGiVstJbHMgRQK3neUKo17rRVlLN2mp9/0dF3kO37mbXpm8u94c1u+zhWMbY72QohJDFgpk60A8ruu4ypZuWoinJP0pXleMC0m9MoNLSUTU+V0vtxMjnLwE9NZqYIzM9rItPle97rXve71m9SvbkSffvgO30uOu/PNqFIlfURwSFmaotKmFTmTM8Q1EKaVMC0C7i6l8Qs7XOfpdgOu92Ii6h21lPZnpQmNc/u5CqUW0GC6XlihVqM1MsZqJqB4mghBMspTEDOUQrSmpvO4vsMNMrFqDiHKKk73HNoENCWoCmM0SsmUVxtp9cQEJExGbS3Kd7hedJ+6JQdp31FqZTmcWA5H1tOJeD6TwyorROfp9iP9bkf3+IDfbrFeDCi1FEFALRPhciaeTjKN0wplJZEozEGiH+dFplRKU7QWlqTW0pC7Dts7tP6mmctroMwLpRZxvBuHyjIZ1F7y5LmCz2+/qxNNn7HYYYvdjOLwzhljPSUmlvOFEAIqK1SVm7jWlm7c0D090D88MOy2LU9eU3Ihxki8nFkvE+v5zHK+kGKE1hSPTw+MT08Mjw+43UYeGxJJmZaJNE2Cs8oJM7b4UqMlD944tP9msqm1yDQ6rqTLhXi+kNsEUDuH0YZqrDRTKTX3uFwexRooGtcL8QAl+KIaIuk6fdSS8mU7j7JezHiliJGtyO8rJVNqotaM0lrStqxF94OguuRClo8VsK4Ly9sr05dn8iKfAa3F6JdKRgPWSrgAWibVysjrqweH20oCF8hanFzlM5UyaVlJ6yopYFXdAhS0s/ihE1ZplQ2FMpqcAjll1stCmINISBpAXpvmvu+shDgoLaYnZYjzTFwDKUo6krUG5xw5Z2pMuMHR9Z5+2+N6T82VnDI1rmzjge70C30d6fx7jnXPkjvsuMV7aeRzkeQjwWdB1zlxwlc5MOScGUdhia4htCZfDit+6IlJIPqd8uRSyFnc9c45tKnM89IkN+7v9X17r3vd6173+i/q1zeiv/++TRPkplKvOKWWDFOLpPDEeZUElDWyXlbWSb7MtZEGqRtH3CjMSdd5jDXiQJ9mAdTHLGv3EDFNc6mcE1xN51FWsuGvurMcU5scZkpIpDU0PaH8nb532M7hei8TVGe/6T6XpWGBxJErdCqZlipUm44otDbfbmJa1rbX6EnbdYIZarKEnDKXL1+Zng8SnbmsKFOxztBtR/z+Eb/dS/PZDxjfQ5XnkJaFNF3I80ycZ3HOl0Jtr3uJR6jyOtdUxSzknDSGxmDHDusa9kchzzMX0rKI/jbLHVtMYgJ0V0ZWkcaaZjaTw4XSFrt/wm02jfFqpEGhkNeVcDyyHA7CkWzNramy1h92O4Z37yWBZxxuWd0lZdb5wnI8CO7qfCKvkoQTQ8T0PZt3T+w+vGN4ehTHtjGy1i6FeD4Rz0fyfJFrDkEe1XkWXetmI5PcrhPFb4oSfblK8lZapHm/xl9WrcnoJr8IN20s0KJlHdo4MRo12QFt4i9gdTGfyZ/TMomuLbUrS6xnVe0Q4ezNRGe0aKSN8+i2Cr8C4sN0YT2fmY8HwvECJd+CD1LMjS4BfhgkeQzkwNCkJSIVaeazXEQHnAphXkiTTNBFO1GaJKLgOo/fjbi+kyl2vE4qJSp1Pc2kOTQCg+VK3Bfer1yDxlpyjOSSISlyWphOEzlIcIUfxERXUoGg6LeDHEI7kYHkmAR9FhMpJ9IieuxBHenLxK54LmpgVd+jzZ5gHRrJis85EWrTIpdCyhmrDalkLpeJ7Thi22QcIDYtqFaS4lZqkcNzKbf1v3eS7nY8Xe6N6L3uda97/Yb167PmjSa3yY7cheS/SsyEaSFOUSIWL7OstVvT473Bb3vRYFpxu+u/uSnPR9F71hDFUJRl0mGMwnQd436LMpZSxPFaG/KpNu1dXNqKMUo6UKVie4/rPd47wSNZK7DxUsl/EwN5BWAb18DZDeECbbJXcluDS1qT247YfpAGsvMtNUhRUmI6HpneTixvB8J5IscosPzR0+8l8ah7eMQ18Dxay+NZZ+LlTJon8jyLIz/Lyrm0piAssqY2Rm78MlZVmN4Ln9Q7SYNxVqZvsUV+xijxolHWw6a7xm46idR0zaGNrJiL0phhg3t4wG13aN/JpK3IjTuc3pjfDswvr4TDUWIic0IpzbDf0j89MTw80e12ordtsVs5ZZbjkflwIByPpOlCLTKlq0rhuo7txw9sPn6gf3wQ578Wd3hexdkdLxfy5URNoZlpFEqLLtUNo7wGXS+NK4j0YBI9bVoWaZKiTLrt0AOV2hKloOlbrwEDTXKhjWk6VG4xnMporO/Qm04aXmNQTZ9YciLH0Ca7jTeqtUzXtcE4j1ES/Wr6/haPSS2EdWZ+eyVMcu3kKchr7yxut2XwnunlVdbfvhP5RluLm6HH9oMwV3MkLxGUQXtPiiKHSW2zIKxaiRF1vZeDQucl5azWG3mgFCRCdg2kyyI+Myefw1or1ptbE1lBzHxraKxSKFXCAuzYSyNtxHx0TTzrxg7b+9smJccsMp4YmimwAqLJziEymsJDDyn9hZktb2rHQe3IRiJEU86QQFVFroU1rQxDLzn0IdzMT9ZavHMsTZLQd518r6UsZqckkpUQItvNiHPm1sDe6173ute9/v71qxvRnLMEzRhFLYq0roTLzHy4MB/P5DUJXLvkxqYcGfYbuu0gAPgGqS+5kmNqjEbhfeaGizFW43rHMHh872+az+u0Yj1NqFzR/hqHqW9aQgXkkokl03WWYb+Rm6sy1JgIjXVY2t+llKwjr2xI1zu0Fj5qKaXdtA2m7+g3A37cYIdBmg8rK+wwzUxfvnL5/Jn1dCaHBDXLdLLzDE8PbD9+oN/t5ed0m+6hyJeLNKDLTAkRssgWam76vZBaMyuNkLFW1ufeomrFemkilLUyyY2RPC/EWaZKNL2g0kqiLZ1Fa4UqBU2RabbW1JhknTuO+Id3uP1e3i9hQ5FzYb2cOX7+yvHnL+R1xbS1baUyPOzZ/u4HxvfvcV0na16lwBhyjCxvB6aXF+LlLAeHeaGmgLEO/7BlfP9Oms9eJovKyIQwLwvxfCBNZ0ozrFzNWdrJZN32HcZd8VoIgL9COB6ksV8WmV7GRIkNY9R34ARBRVigSHOplEG7QRKVcr5RH0prVCkV6+RgY7qhTYfluixVpsSlxobravnsgHSxcs1ppVHdIG5421GNIp5PXH7+hfnthZKT6C3bQcRvt2w/faDf7VBohodHwuUsq/pcJI2r76jGUK6oJhBzU8mE9SzT2VVSyHKQLYZ72NB3Xhz2Q6MV1EqaJsJlJufazHWFWhLGS9pQWiPWWfzob416rbSM+0KJYrxSVuO8l99TxeyjrRGToBKuqFKaFKIEJqyJMM+EeRa9s3eo3DYt2uAfNriuFyKGgo0K7MMXZo4chvd8DgPPl8KyBsa+Zxg8c11JKdJ3vbjmjUahWNaV3XbLfrtljYG5ZcpvNqOkT+XctKtwOl2kEb3Xve51r3v9ZvXrgfZFbjbLeWF+PbK+HYmrrHtLyWhrGN7tGZ52gnG56jJbBnZMMjktc6DmSlwjNWdsZ3HG4sYePzqJ2cyZEiWJJpRIVTRndkF3DtNg7bUWjK6EkgRwXirKSpM8nc4Mu61oLaeJXApWW7SRxCNrDViD1wrTNtmUCqa2ps/TbUbcMAokveXAozXT4cj5l8/Mr2+kaaassUU8ylrfbzxuHHn4wx/oHx8BmZzmlIjnI3E6UteZGqKgbpSmpECcm5Y2yTS55EK1gsQxg8dtBtzYSTqOsWAldlPMPhfCZW6NQg9NcmCu2KcsGkOZqMpErCiFe3xPt9vi+l4g5DVT10ReV+bDmcMvXzi/vJJCkGz2WvGdZ/vxPdtPHxk/fMSNowQEtOY2h8j0/IX562fiNDXneCGsAdd7hu8/ML7/SL97QHce6aRleprWmfD2SrqcAEmzQonhS1nd4PtbTDfI+2FEH5nCQp4v5GkizeLwvmLAlLa4jZcmexyFuvD6AqoxS0vF77YyUY5BNLRaUapMXa1RMoXsetHcKt1y2BdKChIV2QD9Nac2vTdo74Q2oE2jH8jhBxTr+cT09TPr6UBZml7TCJfTDQO7TzuRNnReDjBKMW4+0T0+sby9kMOC6TuhH8QkOfXOEVc5kIh0odx0x1Up7Kanf9rjt70IYLNMu2tOlKoIS2I9SZNrO4cZOjGUBcEf9WPXJDJyEBPTIKSQKSnhennOpUKeI0pVibL1Ft93aC/c4Lyu1JJuzNrleCaGKBPU3jeOacV2lm6/Fa3rNaZVQV4TY+94vx/4hy4zhws/Xwz/dPL8dFzIVLwzlJw5nye8d3RWZBPTvJBSZrfb4Kwl58K8LCJPaWlpxrTrNUZKzQxD//f7xr3Xve51r3v9q/rVjejzf/4L8+lMXoRHeY2u9GPH+G5Ht9sION6L8aKElen5lbwmUhaWnyqIFrHdzKwf8WPX/pmTpKU1yvrvaq5JmYKskLUx1FwIYSGsq3APmx4UKrlmetvhO4uKmXAW7aCx7jaNQWvc0OGtEb1flpVgEUAi3TjgW4KSNqJPVc4RlpX5ly8cfvqZ+fVILfnGsDTeCMTeS6a4aZD0+fkXaXqHDWk+Ew5vlGVpiCBpQFOIpCWyXmYxhzTOYa1VpAXbUZzYo8f4TlBASZqscLiwHi6E04laC3434vtetsmlUQfiKq7yrq1eUwHn6T59xD99wPYdhJmyztSYSalwfn3j8OMvTK8HccPLJhzjLJsP73n8wx/YfvyAvWlRM1SIpXL+60+cf/oRVSMoyLFIz1Mq/dMD7/7DH+kf34GxqOasR2tyyoJROr5CSmhvpXFBkER+s8E5jXl4kslmey/D+cLhx585/fwTWleGxwe6fpAVey74ccTvtthOcuZBYzYa5x3Ty7M060aYqGldb2iuisI5gzVWpB1tTV9balOaL6SwUmsjDVh9S+uybmgyCnNFzkIzQMVpZTocOH/5iqoFo8WEV0vFdwOb9+8Y9vtmGBI3Ps3RHqcz6XIRU5DfUnNCe0O1ljKvrKcL6bJgvJFAgFhl5ewt4+MWvxnacxG4fCmJimKdC9PXN3JbYQs2zZDmiKKIEcmItICWvKSspWojE9RlwQ8yDc8hM59nyZvfde1zLi782qJ3a8nkEFnOZ2qMqJTphr4lO8lE1ViL8x6MuzXpaQmgYNiO9OMgk2xgN2gedoo/vlv5f/7vR348O3j8RDduWJaFNQQKBWctQ98RQiSsAbwTM1vOLMtM13XUWjHG0vWiXz+dLqzh9Hf7wr3Xve51r3v96/rVjejlyyspRIwCPw50u5F+0+HHXhqNNaDGnkplOZ6YX0/ESVziMoFsphpn6YauTdFyWzNGaFDqFIVpWWJqDldJv6mlsi4zcV1knZ/yze2rtML3ns3QCYIFpKHQGtXZW7qRZKi7pgvMMtVBobsePw7YsW/OcS3rd62ZLwvHn/+Fw19+xOgimBddm+vZiP6vl/x5MbNIk6mtuIeX1y+Y0wGolBjkxlcqYS6kEAhLQDVQvbWS2667Dr/psaPoEDWiX1XI6xxOU0NaBYzR9A8bjLeSFJVTa2glTco0p70qoPqO7t0Huncf0M5Tlol6OUIt5DVy+vzMy19/ZD4e2yTRYJ3BWMPmu+94+OMfGT+8wyj1zdijFMu0cPr5Z6avX0nnM7qtYlMUs4yxVlBVSpFTIZeKKZFcRSO7vL0QT+fmvvaYwTfYfsZ6j9/ub/n2WGnQ4jJz+uULhz/9SDidEGI9XN5mtu/3PP7wPf3DHjcMosW85sqnRE2JPM8YJXGXaAVJsud1u0Zk5W8F+aSuxAJIqxjKSknSaKIpIYnEw8o0U7S1wmnVLdUorYHLyzPnr8/kZaVkcJ0n5UQthc2Hj+y//w7rr8EFVVBSKMqysF4OpGUR7a2zzWykiTExv5wok6R9UQvpEm9JUv5hQ78f5RpqU2uyvN/L4cw6rcTlGm0rpqgY5WDhR48TBUIzPUXWeZYmNiTCaUYrhRs6Sq6UJRFDxDpHv+nothJfS1WSgDYtxHURpJVWxClgDLhxpBbIUVKitHFCoOh9MzhJs9iNPcN+h3GuSSeQ52Qdp8OBz//0Z/xPz/yjNsT6Pcd3/yNrHWjBpqTUdOa1cDid2O92OGfpB3DOCRoNwT2llHh6emAcO9Gf3ute97rXvX6T+tWNqNaK8WHD+LSnfxgFxdMYg3GaxdV8ODG9nYlTwHrBBxknfE9lLHYUU4SqbbU5rzL91Jo4BcmpjulbE6mgUJnPJ+I0k1NqzljR33nr8UPXcuydTMmKWOqvK8GKRiuNaRGk5CTGBW1ww4DvJYZUZHKVWmVKOf30mfPzC9OLNGXdrkMbQ1qkuTDO4rxMy1BKml+jpAmxTswkiJkrB7nxyvQpsBwulFRQWpNiQqmK6zt03+G3A24cML0XVmebzpV1IZzOrIezrOxzxm+8RDsibv0SV5nUdk4mmdah0ZjNlv7T9/iHPVoB6yrg95KJMXP85TOHv/7IcjyhasZ7ad5dP7L99JH9D98zvHsEo6gx3Rze0/HC+aefmV9eqSVKWEDfmqdScaPHD72gsrKYpi5/+TPr8Uj/+ES6HOTAUSvGOezQ1rdVIh5NpzGuF+aokSloOF04/vyZw48/E85n0b02eoPxHcPTI09//D2bxwegNH5oBeTvL7Gt7SlNt6vJuTFmO48dR3TXmtdSqMqJLCUlcmiuc6Pw40a0rClhe4u2HtOLCUrLaQScltXz8wvz8Y04T5SQJPLTSkPkNlsefvie/uFRDHIpUZXIQGqt5BSI5xMlR2wnfNJy5eseL8R5kWaZSk2FnETz67ylf9xg+56aiuiAtWwU4pqYvrwQZ4nzLCULBkqJ3tOOPf1uFAlMCnJADPLZTCGTVmnOtdbC5Y2JXAvaObrHLd3QiT5bC5khz6sESqxBuKtKNYwbuLb2VlbR9wO6reCr0hSUMGd9xQ1bus0ghsSS0daSU2G9XHj9z3/l8PkreQ10g6dUTR9eeDqv/OHd73nZfuTHcyJXjWrfBykFlnnmdMo454gx4b3H9Y6NM8zzSgihfZ3c3Ur3ute97vVb1a9uRD/84w84Jyk4VxNBVYr1MrMeJ8K0tEmOotuMmN5JrGDnWsyiQpdKPC2yHtbcflduOKjUzBQ55wbQllzxGAJKVYnObC7rcdPTDb0wIJsTWBklqThGY50WY1VqrNAiKTV26HGDaD+v05GaMqVW1nnl8nJgen4mXC6yptNGUnKsRSvwe4+xThJxWoZ6zRXT2ds0zVorWKnMzfUbp4k4raRUMMbifWuArKff79h9/xFlDXldBJbf0DzGWJbzhfmnLyijZEVqDZjWODQZQ6mtCamVuKwY79HbHeMPv6d/epLpZVioNVMLrNPM6aefOP31J6bXN3KFrhfwvN9tGd69Z/PuiW67laYsC6Irl0o4T1x++ZnpyxfhW1qL6WU1W43A74Vx2UuEZEpiEnMNtr/OrF9WdOfbzxlxwHsvjFgr+CxqRilDQRGnhdPPnzn8/BP5Mt/SuHKpdMPA9t0Tu08fGZ8e5HBAMzehJPJ0uYhrXsm0VlmLsp5aCgYhNFjftXhJLRNHKnmehbmZguhRtW7Sk9Q0zoPEgKIbV7dhhGpiORw4f/1CXMSEQ5H3XjmH32yEErDZyAesSAqYgPgVtWZKEvSUrKrHNllNhPOR+fUESYD2tWTSGkkx47cjw7st3aaDKugmjCaHQI6VGAvr20n0rblKEtjQN9KTpn/ocb3QFWoU047pOmLKLBfJtvfeYTsrTWySJthuerpd03Nm4fqmy5nY0r5SjNSU5LUDSki4QQ53WhusF+12SVmaZifJZb4fcL1g0mo7tGrlyGFlOh75/C8/shzO+E7oHLVpjas2PHz3gXe/ewCV+Pkt8+My8nVSTC3V6eXtxKeP727O+Zwz0zTjrMUYQboZY+ju+KZ73ete9/rN6lc3om4YUFYmHHFemQ6zrNCDOIy11ditrA1t73GDpOeUJPGclEJRipRLiyWs0BBPGFnZxhTbDTPKOqxUclszG6Px3uJ7j/deUpGck5t3KajS2IpOtwQdMWNordFdhxkH3GaD7fpmTCqUUoghMR/PnL+8Mj2/oErCeieSg6bzc05ukmIzobm4lcSJNsYjWoM11JhZp7Pci5PEYKY5IMYb4ZoaZ7FDh99v6fZ73DCKZrRk4tQRw4pWghQyzrF5eIAC6+EAKQrUPCdykDWzqpJ9jpLV9vD0yObTJ4GT+0Fg7stCvJwJlzPT64HpyzPr5YzS0G0k3al/eGD8/iPjx0/ymJqGNqdIyZnldGL+LAYkMad49HaUqZFSrTmXiZP1FqVbxrzWmNEJ8qpJI8S8IxNFlRN+s6Pb7NqhRSQOOcN6PnP+/JXDX3+mLLMkaFlDUdBZy/DwwOMP3zHstzd0U82FqmRqm+NKacgnWROLq1w7j/G9GFS0bY22IJdyiNSayWERnJHS/8V/5Eqw/YjtRxAIGFApYWGeLsyvz8wvB4nOtFbiJr3D7zYMT+/oNjsxLhWZVmJE2FtqEXlFkxAIHkmQZuF1Ynl+I09zO8xpSWAyGrqOzceR8WEraLSUxPRjNGldmd+OgnUSkavorbXCOCvXeOdlLd4mncrKlDDHxHK8MJ1nSiwYAzlFcgwSAztIOIMbBxQN5B8DdZ6IayBep7QlCzoqJSrQjT2m76m5Ya4KYm5SGu09dhwkuc07cdE7ITnUUljnhbefPvP2118IcxA5S7sutIbu8YH9d9/R77Y3Gc7vHzXf54VfXlf+5aUyPbxDlczheCJtMkZrnHM4K3SJyzRj7Tdc1b3uda973eu3qV/diM4vR2kkp4U4rTezku2cGHUGhx+Eb3h1vt8wREmYnajaUm5aMkrOpDZZKjm1WE2JsHTWUhSYqsT1OvQS/Qm3RJyqVcuat+gqvaCsXRW6ZX27YcAOA7rhk3KKpJSJ08z09YXp5ZlwOkvkojO4zdCmNArjHdY6MTUhyTRVC6/TeIkG1S3atMRImWZSKsIhnFdKlNQj62SqagePHXr8doPf78VAgxJZQJIEIHOVGWiZ7gpkHvqHHTkuLIcZYpPtaaQRUQY7bBk+vGPz4QN+GOUxB0kSCpeJy/NXLl++ShOTM8ogk+vO0z8+ML57x/D0TviWxlEVpDUSppn18Mry9sLydkRladTd0AvXPNebeUiVprN0mqpp6Kge5SSHXLW8dQHCF3KUpKdmt5egAOupLXXp8vzM+ZfP8trGiOs7jHe4caB72DM87PHjINebcIMocSWvKylKpKZqj0O1yZvSGmWNaEC9k8nyNSAhLaRlEgOSuQbPK+JFojVde20kaUoOJigxlqWYCOcT8+sX1suZkhNQhB3qHH4zMjw80O13LTCBtlJXLRQiClh/Xf8VWF0pRZgDl5c3wnnCqBZo0KJNi3EMTzv6/UbwYzWjjaViiXEhr5H1eKYsCY2iKDGOAeAcZvB0m0EOWOtKLplaHGVaWKdFonIXIVfIry/UonB9R7ff4DejHAxyocZZDp4pSbNaKylJ2ppz7mbGM1YiNfMSaEJwSkjfGKObjRx8qe39kq+pOK8cvz5z+OkL8+GIUuC8aQcLix837L77wPa7TxhtbvgubR1pDcyHN/SXZ/64Rtbyxs5veLUd5xyYg7oiZWUT0lz215z6e93rXve6129Tv7oRDefWMFCbbkuQS65zbRLRtF05Ey+BHCKlrSqh0XlqJYUksX9BAOM1ZVBttd5W0tq2zG19zXP3WG+kEbWmJdJYNIAxQGn4IGlAre9w40ZQRSDr8ZyJpzPz66vgpw4Hcghob7GdBa4No0Q+GqOpSqDyEp9osNtBEE3X9W6LqwzLSjhOQgJSirRGahZ4tvMevx/p9lv8dtPSoQxKGclLzxmUuWlilVaSttNwT8v5TJwuMoVcZ6gy5TLGol2P3e7pH5/oHh7k9xYBtafLJAzP56/Mr2/E6dKabUe33WC3I93uQWD7uy22625InjjPLMcT05cvrIcDaV1QyBTb2OYQ14qcJItcg/y9BWGQO9EEayvTX+lYS4PTpxZ9KQYUqsgt1sOB9XzGjKMkN51PgsbKYkrrNiP9w57+4ZHhcY/rGhC+jalzytQwk+aJGIKs1quwVLXx364ZJeYhZQWLVEumhECJa2NxNqNPooUVCM/Sb7YtYcrJzyooJZOWmXWaWA6vpItMismpBQj0+GGg30sDanuJceUa5ZmTvA7td5WWS6+MJYdImCXRaHk9s14uuE70wKUUXO/pHrb47ShShlpQ1Qh1omrRIp/OpEnIEdZZed654rzDdBa33UgG+7I2rWkCbdphU/LkBU2lbngu7RzdtqfbjWKkU1o4rctCCquYybSmItezdbbFlwoxiqukpUhna5rcR1lL97Bj2G+xTfpSm3mMUrm8vvL1X37k9OWFmhPdIN8JCon8HT99Yvv+PX4zygWRVrQxojE/XSSE4Sys3xwTPn3ld/6Nh6T5GkcO7oGFLVlvZZnSWK7OWrrO//d/w97rXve6173+m/XrOaLGYDtZuwtIvKUjldKaDIGG59jiDRvz5zr9ikEiP2MIN/NISbVNLMxN22msNIHaGllnmrbSHFxD6Ajr75oZrZw41o2zkq5jHJrapp8SG7icz6ynE+F0Js5LS2ECO3TYzqAVMqVS+ga6V0ajdLuJKi1NVd+1qWu9JUpJqtRCyW1Sa5BJqvcMrfnsdq0BVUryzJWwVa//+2rQEGe3Zp1Xlrc3Lq+vxNOFqmTSSK247Uj3sKfrR9zje9zuUTSRFfK6sl5OzF++cvn6TJoa1D1LvrndDmzeP9E/POB3W9y4RVtNrYLyifOFeJaM+/n1wHq+CNJHa5QT85d1tq24Naq2iV4FzHUK7SS5SLVkIioUkWekZRFMVsnSgNMQU60pjetK+fy50QdUW/0KTqt/emJ8epLmRwtsvWSZpqcYSIsYYWoSraVSSuJOO4/teozvbq+hjPYKZU2UmsnLLNPJdpiKl1kOHn2P7Qb8bo9xXQt0cFStCevK8vrM+vZGbFNUYcVmVAW/2zJ++EC3GbF9L7pTSXUQCHwSggJKU5HpptaanAU7th6OxCsPNGWk5xaYf7/fy2rbNC1syWjvqMowT4H45SCpWlkiXktz/tvO4sdBJst9BzWTThfyKvIBtJOI3mkhhxYU0abySguqrdv00lAr1YxDEqMaQyTFglYVreWzUK1BF90OoSLdqFnkBmiJRDXOYPqRbrfFb3q00nKA0BaMZp0XXn/8zOGnzyynCa0UXefFKGg03X7H7offMTw9td0C4so3hhRX5tcDy9sbeV3RudwS2lAQpoX1OLGriqftgdluOOYn5vEDpyKfi8PxdG9E73Wve93rN6xf3YgO77aYNq1TSkHOpDUQY5REoSwxebXUlrstbMj1MjFfZkKQ6Z81wmasSmGdJP8Y1xqcpsk0LTXpOnmUdb9Gwm7EwGK6ATuOuH5AuzZRRCayaZJ19HQ4Mp/OxEtLL6qIlrXl3Lvey5imqoYrEn2cNqZN/SzKe7lhdp0gYEIQduIaSKv875oL2omDvduO+N0GN4rJQllzg+WX1tQqJRpIbZz89a1ZD5cLl5c3lsOBNAmeSSlwozQO/fsPjO+ecMOA8R26k/V4PB9ZDifm52fC2xvL6SzooPY+uO2G4d0T/eMj/U7eR6WbOaQUltOR+fmZeD6T1yAu6Na8ymvfEEydAy3JTiULPkeblps+dPL3KaDqvzEp5ZveUYg710Y8i4klBIHC53pjf4qut2fz4T3D4x6/3UlUa4vErKWSo7jJc0oyec/XVB+D0c181CI/JcTAtuYpk0MgzdcVvCYnSbDS2jbcmJXoy3Fs008jUzstOeXr4SvrocVxhqZ/NLJi73Zbxocnuv1O3iNzbUDF7V1rkceL5M/Trg1VDMsq7N31cJaGuggovpaC7TuGhy3dTriy0JiwgLJWQhxezoTjRaQvGnRtNAfn8Jsev+npthuUghharvsa4DpZLjJtr8aAMZjWGKeccYOj221w3t3iV2sRac06ScSuqgqVuUUBWyfRuKolllEqJcnKu1QwvWd83OO2W+EPN6A/RqD3r3/+ide//MRymiBnnNHtMKowvmP//Se2H941raloT5WVv285T8wvL+R5vZnEcgpoo8m1Mk8LcQkYZXDeYol0+cAwnYkcWcZ3XOwjr8kQwh3fdK973etev1X9+qz5FAX0ncSpHddAXGKLThTHcC6S5MIqqJZ1XgnLKhGeRuGskf+0KEjRYVps16GdgSoGHQWyajQabUSTiRYtqExkR4n5NEac8kgW+HI4Mr++shwPklCUM6VUcrth+94JqNp9iw4tuTbdpxGTjbOorq1xG9apxEQ8y7Qwt+errRbkTalUNP3DlmG3wY0j2igxwDRMTW0xnVzZh00XB3LTXs9nppdn1reDIG6q4IKMtfSPe3a/+4H+/RPG+dZYCV8xnM9cPv/C6cefCJcZpRXOaazVFO2w48j4/gPj0wO+F6yUUhqqrB3nL1+Znr+wHs+C1WmmI9NZdFaoVIDWuDdO6tV1L/pgj+17QVVpRY351nDdjD5tHVtb3GOOTbKhWmNWJOjgKq0wgzSgmw8f6Hb7W967NO9FojtjkCa3yNpeo1DOSOiBFU2mNr41Nu2l1pqSInmdScsiTZdVzRBkUEbIDn7To68osKYtpYpB5/L6zPL2Rk1Bmt7r7zaWfjcyPDziN9vGobWt8UrSUMZV/pnzTS7dolCraHGnz19Z3g7kKNGuNWdqLpi+p3//QL8dMFoJR9RokbJYMcMtr0fytNwmpxhLbu9lt+tliuksCk2aFkoMEjWrtbA1VcYafbvmjTWk1TEfTsQ1kGshnQo1VbqtoJ1qrqznC+u8ShKTtVjnyCXfIlONt1gjoQ9VAdZQaiWlzLjf0u93+M5/MwJaS9Wa6fXA8z/9icvXF/KyYiq35lerih89+999z/677zBGSwJWm4LnVJmeX4inAzVGyFVicm2lZMU6R6bzIjKV9jir1uQK1hseNh2uy5T6QrETX82Wfwp31/y97nWve/1W9esbUWWIoRCWWdaFpWFSWtJMDIkwreQUqUVuADEXSssGH0aP74QpaZ1rCSaq4XQkUlMpSdGpjfWptAbr0L6T9WjnmobOtGQiRQ4r6/HI+efPXL6+kXNuMZZtSgb0vcM5uVGilWSeN7SScQ7fi9tfaY1u61ysIZ4mwtuREmLDyoiBqdZMjgk3DIxPj9hOEmTQpnErxXSFsjce5RV2j1JUpSXN5XRkfntjPR7JQZzdioKyhv7piYff/4Hh/Xt5viVLU2QscZo5//Izl19+Zj2cbhGOaE2IFYti+7sfePzjP0jEai0tJlKTYmR+e+Xy/ExeZ0pIUOU9qFXW06WlABlnhNlaJcZRHptuCKyWy45MoUVeaIjzJAgqxOtTYpL/rf7GbQ3NgFKpQaJj7dizfff0rQHtRI9LasSFGFlPR0qKrdkVh5F2VugCvpc4U7SkEmkjq1olzWBeLtT2s0opcJYSImld6J+eML4Xx77WbeJfqUo4oPPLVy4vX8khYMcO3VnyGiml4vd7hsdH+s1GVuUtf70WyWmvJcnramXKSCny/88QY2R6OTC3hutKchAmraH/9J7x/SOuEwNXrZk8z8R5kfNeSIRpRucqRAKrqYh50HuP3wy4oYNaKSERp0k+y8YRwypJRUiSlKRuSYRrCpF1mig5ioYzJHKSzz7klmmvhalaCr7zWOdJSaJ++61wWFWRTUnN0ohWVXF9z26/E3STbeER7fOcQ+TlLz/x/J//QpwXvDeY3pFDBi2pbNYbnNPEwxtnKv3ju0b0sCynE8uXz+QYRH9crgqCynpZWC4z6xywDcIfwrcm2njH5t2GbtM3Tm/BmERf33i3KdzrXve6171+m/rVjeh0PFFW4W1qe20Eq6CcTjNxWamlYn2bNpqKUwb/OND1XnRzfY8ymtDQL8JlNDLBUhqlJLMb08kKve+x40bWeyh0AaymAuF8Yfr6yvz6TLic28RNJlGl1hZJqLFGoRH9negZFRgvbNBOANZKG3JrAEA0gnEJxOMFckF5g9701JipVcxa3cMON47CFNVGJoLQNs9eJAxaCf5FXcFPEENgen1hPbxJRGmOgoPKYH3H5rt3bP/4R/rHJ1Qp0NiXqhtY3144/vWvnH/6TJgXyZXvHCllwhowSjFuB7wzmLySphP23SeohTBNnF+eCac3dCmk9n5RNNYbsJIprrJEHIp2NLc1apFGvpOYUeNFplCD8EErldz0mleWrEwCK6XKmpbS9MBKN/ZqpqQKxvDwu+/ZfvqI2+zQXgDnwhCv5LCQl5l4mW5ygWvKknZeMFON/amMo4YVjOiTS8nE85kSvxntFKIxzvNESRm/2eGGLcr3rXOWpiOVwvnzz1x+/rHFXHbYzlFDIqwB63v2nz4xPD6KIUvbtt6WqXBOoU1bFdp1lBypQdbguVTm1yOXX76SposcwJTwNbVx+I1n/LDH73bUEMnTBTtu0VYa/eX1SFoDJYmcQVvTJvUK03f43YBzDlUzNUh2fAlJTFBU4vmMClGuWyMazhxFNhDmheU83abNsm+Qpt90Fus8urTwBufwgxwAYkrYwePHQTTXyEFMPlVyiOu2I33j0srBSN103vPhxJf/4z9xeX5FUaUJtaIxrrbiB4/xVl7rIglj05fPpOlM9/RetLbLRKXF9qaMcv6GewpToISEb7KbUivWdpjR0G07xqdtu65kK5JDksjbORBejv+e79h73ete97rXf6N+dSMaF9GsSeOmWaaVMM0NOyP6LTtcV3sypbJeeKLKGLkpC11GJqNDf4tVVArREWpwmw1+t5MVa1u7ywhNANPL4cDp82dZRy6BqjTaCZJHN+e51S1FhutqXFGt3MSUkwbUOGFOllSoIZCvRquWHCTSAWSFWQTdNOxG+ocH3DDKP6eKli+35BrX5AJFpjE1ZaCAVoRpZn55YT68sZ4mypokFcgIemn3u+/Z/f73+O0OUNS4CuTcO+bTibf//M9cfvyRHBPWe/pReKg5ZZSCzbbHeXHkSyegWV9fJMd+Xphen1Eli1HDCE4qhQKqknNF1Yq3HcY6WcWmCGihChiLHwa0l8aipAwlkWIkhXjD3VynriVngZZniTGVXT4yDU7SmqhxYPf779h9+IDfbARV1NbjpEiOK+H4Qg2rxGuahocy3CQB2nRNalDFNNdbjO8pYSYeXgjzhMqlSTsEG4TRpMuEdT39xwe087IuLxWVCzknzs8vHP70Z9J0wbXmO4coE0RtGN+/Z/fxE3boRHva1s/kRFxXclwb/aAB/NvUsSjN5eXA+cefycuCtZ5uGIlBKBN+MzB+90GMeaVCzOR5pdaE6TuW45nz51fSHJrhRuHHXtK3KujR0w0eY+TgFk+NOuAdqusIl5n1eGkUCNFUq5zFILcshIsQB67JZbQ/5wfPOHQ450HZNu0tsu53htwOoL5rDFglRp9aCzR6QLfdYPtOmKco8YZRKbry9s9/5ev/8U+s08yw77FaEeZIydCPHrzDOtNkDbJxkM+NSGjC6SiffZSQN5wDawnzyvR2YV1i07QKoF7lirGabjvgHzfyHdWCCrQxokPOldPbmfU8E5b47/6ivde97nWve/3X69cD7UdLLZr5vLBOMzUVbJtouk7jnaXbj3SbkVIVVWv50rda1pzNZa+0TDRoCTRKCWhcb8Vh7ocBrSUCVGlNVYq0Lsyvz5x/+oXldJF1nlaozqGUpPJY0/6+KlzPnIughJomVVaXrjnMa2umZA0ZLhNxFje/bo79ksTc78eB7ftHut32hpWqSstzQImZybm2Aq/CWczlZtRZl5nleGQ9HkiLEAVKzOJ+fnrH7ofv2Xz4gB1HgNtEsaKYXl85/OnPnH75yrqsGA1915icVR6r6zymmUFqmwqWCnlJlLIQv3xp0y7V4jYFVVVyFbOYUljnWzOVBT2UwfkOa4VIoLRMxUrMFCVr5zg1R31FpnkVAdjXSlwWOSTExK2lac5rOwxsv//E9vvvccMAykLTZNacyKcD4XAgnA7inu4HnDaoFIWO0HVY16OBGgOqG8D3t1CBPJ8Jb8+UkMS97UXnK0gph9Ya9/Thxjat1lBToMTM9PLG8S9/JhwPGGfwQyd9cVgpFWlAv/se1zBMStumiZ6FI7os5LhAbc2QMagYG4ZrYf76RjxfKMssJrMUSLWiO8Pm0zuGd3uMl4+k9pJMVkokBzh/fiU2zSbaiE66c2KqU7olQ4kxq6RMWtfb70m5sh6P1JjQVQxduVauHqLpfGY6nmUarBW5FkoqWG8Zhg7vO6xxgG7NpTSotUmdrbPyuYsVpRNkQItEwu639NvNzWiWUxAHvfNc3o788v/5J+aXg6Q6DXLN1SKfD2stSl1Tl6yksaXQCBkeZYXgoK0lTeGbPtUY4rxweTsR5ojVFmUVa8iklBiGAb8f6fc9WhtKqrjRoF0nOuS1MB0vxGVFKc3mcfPv/Jq9173uda97/Z/Vr+eIrqsYHQpoRGOnjRhZuqGTxBsviCVdBTAtTVeSG5KWG0yNQRBISqO9w203dA8PuGuEnwQiSa71PHN5fWV5eyOtKzkKjsb6NgVt+dlKKcnFvgKpQSZgQ0e3HUUb2owjJRbRq8VEmlfiFISVWGnRmQaspdv09Psd3W6D9h5SgZooLUdczFLiSqcWSIkSIzkF0rKyzhPr+Uw4nVsjKA/Mdj3bT3u2P/yeYb9DeQ/ayhSqiCM8hYV4PnL88a8cf/6FGCK6EQuK0XS9F8MXgu6pWtiTqlbCNBPmVUxcShFDkmbRGmKMgliyBqNqm9hdHc2yPlXOY3tzaySUAkqi5NqyxhfyuoqkwliowmhVKaGsJoWVeJkl1cq0mNVSMf3A9vvv2X73UTR92vzNVFkawfD2THx5/qYRNhqVEyVbTD/gfIfpBmla04rStckhCnWN5OUCOcj1acTcQi2YYRANqDaiH1UKjOhBy3RheXvj8NNn1uMbWlcBvCst77VWdNsdm48fxXEO34DzOZJiIE4X0rygrGvc3Ey6rKR1Au0EIfR6aEEOpQUzibzA70Y27x/pdoMkZLXYzOohh8hyXojnmTQtkt/U9W3iJ82k0xo/dHKGWCIFoTnUqlBOE6ZAjRGjFNUaYhEZBaWyhkBcVlKKlNZgXmUifugZNgO+8/TDKE743DLtUShrxYxkGz84tajZVCnG0I3CT7XOfyMGlIw2jpjh63/6E8e//IimMIydHO6AkrJMV70Spq93lFUmmqpUwMhUFtUoG5Z4nihF6Bu5ZJbXI/NpolaF7Xo6awSRpaUxf/rjD2w+PjVe7SQyD2OoYW1GNYVWhr4FQ0ggx73uda973eu3qF/diJY1Yho8vhqDcZZ+7PF9J/rIVMTQUoXJeTUz6VohJarWcgNr8X3dRpoD5T0gpqaSM+F0Yjkemd8O5DXctIZKabStovu0BtNQT0oZUpZoxFog5SKGqVqxGtxmoNYiJo9lFZA2AFpcxt7irKxutbG4jcDnXd9/037WCroCXtacSsvzqhlSwwEtE3GeWKdJbu7rQg65AdmNJOu8e8/m0wf80KGMTHTk14gJJc8TabqQoxiXxnGgfnji+HLAtpu76xzaGhnXtgazlEJYGqezFJqHmHUNKAzdMOB612QTMhWspTmZa2OyNg6r7URvmZNgl0qK7bkk0rKibxNUTU6SRY41ooFck8RjpirIq77DNgbo5v07/DDIml00D5KlHgTDFI9HyKFJMdoatfOYzUY4nFrW7qo1Nkp1Nxd+XU+3CXEpqnFfv7Eq3WbXVq4AVQ47y0w4Hrg8P3P65QslBPzgJdO8Kqoy9NsN4/v39A8P0jDHxBXInnMiLgtpFQe+6az8XFaNehAJrxNxEa2ozqXpojXJQLffs2lGJNUeE1rL89OR+TSxHC6QUkNaNaSYleZL906c9M61CegsBwTrUBpSypTL0iDyLb2rmahKkpjeHINovrU87pwrWmu6bUc3Dlgretxc8zW2DEqWz/52RKnaaAu1GdwMdjvid7Ld+HadVtAdJWeOX5758p/+mXg4SnBE77GdFXmIUfi++wbBr+UGoFfa4IYee53QN7lOPLbPi7HMx4nlshInCSXw3t0SWY31bL/7wPaHj/hxAFVx/YAfRuKyEOYVbTS+6+lHw2a/Iywr0+tBDlb3ute97nWv36R+fSMaa9OVafqNox960WVpJdO8Ft2n2tqc0qI8VRUA/ihoIzcMMolr+s1SKnGemI9n1tOZ9fDWsr5r03wqlAGyuOydc62pUNQCVVeqVoCR6VTK8ruVIq+R6fWEdwaSYIdQqt2WxeRhOoftOkmJ2mxl0tkkAfVvEpvQVriit8lNkkYqRtbzkeV8JoeVXEAVqLFiuwG329Ht94zv3+O3W8HF1CQmoCSmoTRfiMcD5Ei7w4pRKEVZV373XlKkFG1FqZoBJRKXSE7iPMcaVNFNHiBTLd/1WNfiSJuRS0DqyCS575q+s92xcyHnKI1ojqSLuLS1Nt+aWEqL0YzC3dSaWiTQQCkk+nG7o3/3juH9e9zYo2qjLKAo6yLPeVkp6yINXpE41FoypUBKFd2NuP2TJGql3P6eZkYpiRqD5Knbb5Nb0ChvMf0oWKma5T0zllqS8F+niXA6sxxeWacLqhbBUxkD2uK3O8bHB/rNiG6Gl9tjL7lNhldAmmVJiJLnZzpPPF9YjxfSZWl6YySK1Vrs4Nk87BgeH9DOUNZF1vy5EC8rKSTSEshrRKVCJUtYgHVob9He4keJrtXGUFOmhNgOBJbc9JsaOVzULE19iom4BAHdl0TNCa0N1smhRBlwvZYkoV7idGsjNQhbVbi+bhjFiCdQX/kkpYzpBrr9A36/bXJgI/GpVrTC63nm8Oe/cPjxR1RJ9JuenAray/TdavBDJ9KRigQdpEQtLSjB2xYn3N6PXChLIK+B3DYB83mi5orVkvamAK0UfjsyvHugf3zA9G1Ci26vRcF4z9D17ZNXBD1llLBkh563H3/5e3zX3ute97rXvf4r9asbUdt3Mo276jO1ElOMMTTG9M00UatCW40fHGYYsKPkvZsWXVlzJqVMvpwEj3M8cXp5Jc8rKSbQCmdEj6a0kgjRXsxIkkQjTaIMe9SNF6mdxTRsj66SU62RwaVEMzZclFIiK+g7/GbADtJwgKCoSosnFEIl0P4+cqJkwRCF84kwXyQNqGVr15JR2orh6uOO7vEJv9u1VB8tP49MDdN0Js8TeZWfa/tBWfEnQf7ItEkSgqpCXnelCGsUqUJzTtPSoFBQckUZSz8O+O2A9V5es1zk8SkwnejhBNxvZOXaVsI5RXIQlmnNiZIyWpmGX0rQGKcppmaUatnh3tLtt3T7Hf3jI373gO03oiUsRdzz60KeZ9J8Fpan0k2OUAQ0HyM5FtG4FlCnC9p1uO0G1/WtcWhoHmhO+XY9lEReFnm9dluMdVwN25VKCUIRCKeToJKAbrfF9J7VXai50u12DO/f0W027TAlTvKKJuckuekpQs4iOcDI61qVZMp7majabqAWiOtX0rJgtMVuNxLzOjpha+YsB5cYZeoYMstlpiwCXbedo5pMTqC8w17fTy3Xrkx1lyY3iS2lC2no4fbZKDmzzjOhpTSJTENRMAK9R2OcFpc93A5xGGHrKitUC9N16KrgKuUgivFMW/yjIKxM30GMou9uk+84TZx++pnT56+EwxFVK7aFRECS5tYZrLXy3RIzuQp2zVrBlalOKBoSI1va948h58y6RsIq0hdrPUVVtJKptHaOzftHxo/vxByJvDBKyWEop4S2zWDYtDOqJTpVBctlEn32+fTv+Iq9173uda97/bfqVzeifrjC1IWVqVWbkF51hLWgjBU3s/O4zouLvGV8V61IIZHXhRyC3ETDIlpRren6jtDW8MYavLONAymszwotrjA1Y4xoEFUp2MHfVo+uOcCNFlg10Nywsta0Q4frZUr4LXFH0o3UFWCuVIPqy3MU5zxN83kiXM7EZb6tpiXpydM97fDDiN9sZR18bW5LIceVvAiMvaYoYPd1vXYMVI2wIuNKTQ2A2FbLmipTn3mVtX9IbS0twH6jRatrrMGOPW6QKEbjHaWl2NQsmlDbezHuKGlAS4iSFd5WrLUUdK0t6Uhak5QzeY2kNTbGpW5axoI2BjeMbL/7QP/0hNts0FfzkLLCpZwX0vlIXiaZYpaMUpaqNCUsoqFtTUYpVaZfvsN4Q5oEtq/3ewk5QIkWE0UNi7yWjc1Z4irO/POB2m8kcadU0jKL5CHMsiY3+krTwg8j3f4R4zrcIA50VcRIh/WUWqRhbDpKVXJzYEu3rLtODlm+E+0mFe07IUZsN8yvr/IajYNM+0ppDZBM7OMSgHpz7aMEXVVqRVmN3z/Q7bdY79BKSdOZCzXJf6coOuzasuCvk1kUxGVlOpwJy3pr7EqqhJBFY6mNRNcaCVzQpuku24HPjh3WO0SXqajXbUKWaFK3f8CNo6ReoSghNAmNpdTC9NOPnH/5wvz61pK4Gg6qKrRRGGNxXsxGtUCpRa5lZxqPVTVDkr/phUUaowiXhel4YT3PEnbhPNoo4hKpGobdlt3Hd/RPDxh/BdK3CW6Rz9d1kq6yYOmu32elVk5fnnn9019ZDscbYeNe97rXve71969f3YgaL4lESmuJ5K4CaVdGIPDGO9wwYrr+hkJBS5RnDJE4T6TLpa0xxRxUlaBSyhrRgO88Xd9J0s01jhHIpZJWmfoYp9oE0DSpgKLELGYjpdG+pRhBy7RX+L7H77bYYUB3stq/TtVu0x/dfq5mVM7fOKnLzDpNzfl+Ji8yxapFjA/dw47h8Yl+v5fm22jRf7qmYVxm4vkkK+harg8J1YxJ1wSda266NlpMU00ekGNiOV+Ia2yT0krKlRgEmt+PPeNmxLUDgOmlgUM3c1YqoO2/0teVlClVGpkcAmVZZdJFpcbSEqeKTF2DyA+otekNRVJQaqHbjmw/fRIG6L5NIbWst2tFolZPb5T5cpskQlvlA2VZCHMQwpWTyFGjZaJ71bPaRjxQ1+bBWJnOLos0trVNLZVQQsmVcj6S1wUzdwLjX1bR+SqDUu3601akE+NGrlljxLDV/p5SFPH6uLWQGATVlahGkpjcdpDH18Ds1wx7tKSB+d7DbtNIDE5eV0C7nowi55lrWpUqtW0VxMSnnKcbO2milKKukXSN/FSKuAbKKtNh1dinRYlJMK2J+XRkOl6EL6vF4EZV5JJFX+2sXK8NcWusa9euaV4uwa+Jyqa0z5K0ctp3+Md3+HFES0Zte30VKElcOn75yvnzV8msL7WhlWghEoZu7G6fOdnylxuxAtuicLVBWddiZDuZQufC5csry/HcCAKNK1skvKAfPcO7RwkC6CWF6kZCbSloV8avarpdOVRkMJqwrrz++AvHv/5EnOcWO3uP+LzXve51r9+q/k0T0WsyEEjqjO16/MOD6NXalEg1vmFVkNeJ9XgiTQuy9lK3BrYUgWdLBrxkvBtzdXEr0QmW0lzIFeUFDxNDwg4SK3m9xagqKUxat0ldqWhj8PuRbrdt2s+urTRFT6m0TNauTmWusHRjqWTCNDG9vDCdDsQ5kOb1xj2tFexux8M//AOb909Ya274IJppKq+BeHojXk43APt1FZ2XhbyGFg8qU76ScouoFAd9mpY2AV2aTlbMWTFIwk6/7Rg2G/rNBjv2MggrFWUbU7NUQDcdrKznS8nUBCVGSedJsqpVummAlTjcS4qkuMrEV2Zn8rqVBCjcZuTx+49sPn3Cj5JqgzEo2wluawmE5y/E47PksP/Nc5eJVCXOs7wGSiZzV2yV6XrsZoNrzbVSGlUzJUeUtuQayeuFcLnI5Wiu6/0ruzWhnKOkBC0NC6VFXBHk7/O7B+xmL3GyrZGpJTfYfCFOE3ldqSRpMptmsaQkSVzbnayqm15YkrOKpDWVpvG8XGSSa67626adxrCeTqRlxZjr45bPk+67xi11jY0fyJcgOs0CysiqfT5dyGuUA0uF1Nb7vnes5zPz4cJyuRBiFt22Fk2zNpZu7LAt1UobJc2abdIWKxpo1bBqxIjqOknYyhlFxW73uP0eY61c1zJKReVMzoXTzz9x+vqVODXtq9bkIkEH1wbUdx7nRVubchbDnHVyGGqw+yuD1QwjUKi1kJbE9OWVcFlwfUe/GyXi9DhRATt0PHx6T7ffo6y6flWJkTEnqpKgBlKQ983IxL62bc58nnj785+5fHkltTACe01Lu9e97nWve/0m9W+I+NTQ4iftMOA2G6xv00tAxlpicIjzmTCdydPUjEEajCOHQoorcZUcctWQSUobSmy6xFoRSIyS6UhLyNTa4jvJZjfKoLJMaoyRG3xNmeol/9z1A26/xfWjcD6NhRwFW0NDEwkgst1HLfiemhPz2xvLyzPL+URYVmFnxgT5qgew+L7D9RJBqbsGFC8CNE8xkZuDuYQojw0lzUzK5EWyzqU5bUlPSONMqZzfjiynC6oqrBM8Um19rLaWvutwfUe322J9d7vRUjO6rRBrvaYPyQq6tkYpB8laj9OFmgquG75pbisti73FtNLWw3+DxOr2O3Y/fMf2u++xm01rkGTEq7QhnC8sz58bCqppV0tpf64QltYAl9qkHAbjusZklSSt7mGL2+0xXScN5jzJdWE9OSXycpaG2BpUKZRlEolAO0RcdcEqi2ayaEVNK+SC7Qf8wxO2H8A7mfKm2IxpinC+EE9v8mytBZRMU3MRucl2jx83soLXLa4zSy48WlPiSloukqBE+Yb2aqv2NAXSdIaSMFT5V96hijRf/v07jNaEt9emd20aXO8pxhEvE+v5gq5glBiRSpvAllI5fnljnS/tn4MxhpIrWlds57Bdj/MyqddG4bo2yW1xudpaVKmUdUVZg7qupHPCjlv8ww5rfbsainyutYGcmF9feP6XvzC/vGGcafpdJTxfFLZzDIMXyoZSYhqLSTSZSuQexksYhnZOTIN9RymFdJyI08pyOJGWIKxho8XkljPDXuQwm6dHbGdEQlBpmuz2DeQdqiqI6y0Ot6Yk142zXN5OHH/8kfV0xliF671MnudIWu8Rn/e6173u9VvVrwfabzfYfviWMd5QMKoKdilF4Yym6UKJKyW1qYq1Mv08H4jLImtArbG0mwHN+Vsya0yiZfOCEkopU6PoN41XGONwTow5opPL5Jox1jY80gO2H1DWy7RTaVQt1LDe2KKqBMmCNxatJa0l58Ty9TPL8xfiNDVzTZFJq2pRpErR7zair0RRU2T6y18gBba/+wMlBNJ0Ep1iVbepTo2BElZyLGLuqVWaZ6vJodzIAeu0CPC+SvY1VVGNNCrGOrqWJe63W2lMSiauM7WA7zrhSzb0UE5JpmcxUoKsclNYCaczJQSB/Pe+rUUzKWRhSS4LOUlKlFKKkhNFa4aHLe+++8Tm+x8w3lOv61BAGUcOifDymXh6Q2tQxgjQPsjkKa6RdVpvqUogTbXuPMZ2kt4zDvjt2CI+tfxszVQtee/pfKCqivZOEnaaSadmGs1AHNLo1oyXBtNPCtN1uMetxGQaC6aFKqyzAPhjYH07kOcJbT3KG1gXCT3QFrvd0u322K6TNW1p6K4rezNH8hqbxMNTew9VXP3F9hKa8PoGuWC0mJyKEqyXqhazHfGbDpUi69cDcQkoCsYo6DpiriyvAumXrYEhZdGZUhXL4cJ0vFBKwnVGUF1ZGn/jLZuHEec8Wls5rBhNiUkQTznjOo/tfXO7V1Tf3ab7OWf84xP9wyOkKP9RCppMJy2LRKF+/sx6nATx1phJpUhCUd87fGck3jXLGj+nDMahjMV0lm43ops+U6v2ucuZEguX5yPpvGKsonvYio6zZEHKecf44Yl+u5GfUU3TjYISGnt1EERWySIHAuECK02qcP75F5a3V8J8JqeIQslnYs343cjv/q//07/rS/Ze97rXve71f16/uhEd339oa04juqlaKC1hJ769ihP51pxo0IUcM2k6U3JEK03X2TZ9azcabYghEGOWe1dLRVqnGb2skhZjLNb04oQtBaqmanG++rEXIP5+L5B02yDpV4B2Fc0lWqGLOMPRGtUJzzKvkeOf/8r89TOlRHFJlyqwdi2u5YrB2x7rDNoZchR4PbVivKFczkx/+Rdx3TonQGytRcsXAiUslJzJocUidhZlLSVmcpAGbW2mJWs1qkJYI7az9MOAdQ7je4zz+LEHSsP7BJTR9NsR33co5wSXowx6nllOB3GSpyRBBG213e224jRPWbij7RCQV+F/lgI5J7TVDA879j/8wObjR8wwgHWSrJMzVUFaLoTLWZ7jssr6O4n+t6yraIPXJBI7dc0tV9KIuw479Lixx/ct8UnbmwO+5kjJlTSfyWFG9T3Kd5SwUmZBLiml0V2PUgbVMsZptITa9KR+t8cNG2HCghACUkRrTYqR+fBGPJ1FGuK8UB+WAGRMm6A63zVH+jecUa2yVs/LRImrMHKrFimDvmp8O8L5SJkmrDVUZ2XlHxPKW9z+ATt26FpJB+FV5iiGPYwh2454mSnrKuY7bSg1owA3dJQYuLy8sV5WNBVrLdY4kaZozWYvEgc/dJQoHGDX94RlJaeM3ww4629oLTklNIkGoMYN/WYr+e7LpT0uj3KaGjPnly8c/vqTpEWlKJptJ42oIKEMw+gxxlKTNLWKLPrazUgBQaf1neS/5yzvec5oHUlrIEyLSAIG15pc1Ri3mX47Mr5/xF4DEpTQBMRSlcF5mbC2sAashSxw+uo8cVo4/PxXMVPNQQ5wDUdX0bz/x9/z8X/6v2Afn/5e37f3ute97nWv/6J+dSOKlSlSbhrHeDo285E0Zcpa8aQ21mMOK2ltq28nzFFA1tGlENZAqWsjQAnSSRA5Gec81jmJmLRtcqmAZi6wXSconO2I9l1zv4q+saYkq3zXyXAsB1RKomOznlory+nM5fkLy+uBGFa63mOdoebG56yKknVz3lcoiporISc0YHqHHzpc75r+EPRmlClijKQpkpdZGrYqzU8pYLyYt9K0spwnwmUlpdzc8YgUoFa5wW4GjLPYrkNZmYaWGCR1h0q3G3FDL6ttY6BqSojk5URJgTRPrBdZa/uuw3YjtYjTvoYkIPZaqakQYyJn2cFrZxjePbD//hPju3fYcSPTJaXldUhZXOiXE/F8pAQBgUvUqialTFqbTrKIftdqed9zEXSQHQf6x3f4saUEXQ8wVx5pWgjTTI6rZKp7Lzre9phVOzBI/Khpkg6oiL4RY3C7PW4YxWHfDk5XzWBOkeV8JhwOEmiwGUX/0a5l03X4h0fsOKCMkA+EUcoNa5WW6cahpJnrlGpNTKmiM71cWiKXIrefN10Hwwa33+H6jnw5Ei8L8SIyEAzgrEzkXt9kQ9B1QCVnaaCtd8znM9PbGU2l68XdrxUoU+k3Q9O/SviB8Raz21JjJqcVbQ3j8IDuOuHrJtF/1tgCGDrP8P49fjNK04ySeFTfTGjLzPGnnzj+8kUSlXKRZCQlyVKmfaaN0WgMJQqFQGvhuapGsHBdL6lnqorzv2l8c4hM80JZQjNICrKqpEJBGtzNh0fGxz2m69uEux0+c5KUpV4oBqpKbGnNlRqjQPitZToeOP/8E+F8IS8rKWQqYFC4ccO7/+EPPP6HP2D6jeiN73Wve93rXr9J/Xqg/bIS15UwXUjzhGqAceU6VIWCANDLvFKvWCPv2w3aiEGpZtFQRplUDrsNVIinmRgrfhzpm2np6hxXVRJtlNX47YZ+v8OOoyBVru79BtQHiah0Wv65mJDqbYobTq9cXl44f32BlDFeGIlFNec9Cq0tVhnJoI5ieCkloazBd+6WPqQbWN40tExJUdKRVtFXVmpjaNJ0lIWwLKQ1StJTyKK3tZoUEhRhtfpxoB9HjLUY227AJVKSxvgBN3aYTlA+SouAtuTGyVwWUlyIk0xhbXOeK9OSknK6MUAlcvGqH63Y3tNttowf3rN594T2krAkGlVFDYG8HImXI2meG2OzSpOVxPxFkmjWvARSzFjn0Ko2vqrBjz1+t8E/7rFd34xoomMtaaWsgVwzOa4UJWDxNK/yOjfQeV4CVWmM76TJj1FW8kokImYY6T98kulZawppE8ycEynG9vgrbruT/PJaqSmiTIcbB/xmKw2OahpPFFWLcz3HQFonSoiiYTYyKRdIOiJTOD9Lo6yM/Fx7nrbrhKk7jpAT4fkz6bKIr8wqtO3JKREus0w9vb+ZaYw1dNueUjLT25F1WtCq3lbhNUrqmO/lObiub0pO1fBIhVIy2oobHjQlJHn5VSNgOIN7fKB7eMAYI8zRfpDDZjMdrYcDx59+Znp+/ZZ41gm2SmI6K0Y1fTMy5ZRmHWpjAvtxlJ9JDZPVNMm1VsKysBwvlCjqTkFJGfKaKKVix56HHz7Q7/eNjlEgR4EdaIPynTShWoMqUEQLWmIQSkROnH76UVz38yqufm3QDiiV8f173v3jPzA+PqKtTJ2vh5B73ete97rX379+dSN6/ulHQQ3VKk1YZwWvFFbRx7WVIUqmHTUjzWCtpChg9IKss93Qob1gWeK8oq1j6EfRVtaGg2mNjus7/H6LH8cGnjet0WubRG0a+1OjawaKoJGahrXElThdmI8HltOZHBPaiUZSMEUVUsVY4WtSqqzNU5TEl96DVtihb+54QdxgpflIMZKnIDfTLE2x8hattcRirpEUhNNZq6y+S9OKuq0HFNbLCtEPHjf0Yq5qcYqlFFll9h2m627JVbUlV9UsAPo4zQKiF6uyoHC0RFGWdsNXVVz6pQiORhsF1jN+3LN5/4Fut8P0vSRl1Squ4sY8DeeDTMBTao+rtkY2C5SopRpJM6/pusZwNRbTbfDbDW63lZhOqjBAlaFqiQfNYaEoSevBGFSW+E6MxXSOG+NUNWxXW58qpSk1Q2lpUPNMeHvF7R4w1jbTVRGM1jxTasY4h7bi3q8xyoFgt8eOW2nArhINIy73kiJlORNm4ZDKgFiSkpQxkjK1BkF7pYRRkkBWr8wBIzpTvx1RNUEKhPNEPM8ygTQWZRxxnSnzirW2TYppKViVnDM1COYLCt3QtcQkeazd2NFvRpl+GtP0raKfpebb36ONocZMLfEbtkhptPf43Q6/f5BUpavEAUFtrYcD09sr6+FAOM8yoS+SmmQoaKXRutw2GAUa9kg1SUFpZIAB3XtUhWoQBFepVK0pSyBNKxqF7lw7xEJJhWos2497Nu8fsNdDgq4y0a1VkGm+E9lH+w6hQo2REgMxrKyXifl8JE4z4dLicJ0mrxljHPs/fuLhD3/AD30LSmjfNFc6wr3uda973evvXr+6Ea1ZINimgepzjsT5TA5ZTCjmyu+UNJicxZxTUm6Qa5mwiKPbSDZ9Kigs2jWETpXlqjJaojfHkW47CkIHyQ4vNbdkFdsyy5FpDvmGlpI4w5lwPpOmi2SlZ8kJ164lpwAUya1XAqG85WIrrYSN2nlhKTbtqZIBoDRfVzNLuWrf2uTX1KYzK6zzSppWSsvndp0np0xIScDyVjA9vpObtzaKkhKqZLS1YrLpO9GdXoHiVd6LHFbRKEZZg5fWUFAEzJiLrCiLABShVmlKc7klEmmjccOG7R/+SL/ZNW1g09ch/M08nUmXMyUuzeEPtcrzK0kYntAyqHTTYLb0HNt3rQHbipZTt8zzZZYJlbHUtIrz2xm0EaRPWcXYpL2k80hkarhpFykFfIOs5+tjMA0zVFjfXknritvswGjyfBEnuGvw9pQkvcc57EZMTLbzN46o0uK8TjFSQqCsMyXMbbraDmKNGJDmiXSZyCGI0Uc7uJIrlcREmmHA9T0oSHMknS/kmFFdJ01vyqRpwhiFf9iKhCKL5jWX1J6fvG/GGPAdNSVS44dqZ+jHga7rKFRqbmYgrUBHTHUY6wXBtSyNV2pbxGaH3+/otxtJPtPqm6scRTgdmb5+ZX57Ja7hFmggaooCRWFaOpK2BpSgoWhwfhTEKJPough+bYhbSa9KK+lyIcfarm05xCjfeKLtve52A/27R7rdRlK+9PUwFuXgaxzKe/k6yKlpVOWwV1JiuZyZj0fCtIgBr8UAa6WIa8YPI0//4ffsf/+7bxIia+X7pFrJsr/Xve51r3v9JvXrIz63e5majJJxHZdZ0oHyQq2J1Aw8Sss9qOQMaJTzN5C7QqO0xRgnQ4Y2IRQ0UUMvdTL5M10nN3wQo4sxt5uVsB/1rcFSWhiZcVkJlzPr6USYJ0kqSmIwEfi9viW/aGUk1jK2nHYlEaGSICUJM7brBM2ErLZziI0IEFG5tJV7S+kxAIqcIilmUkis8yqxikajmz4Tq+m3DXLetK+Kxqms0ri4TUur8R3aOkhB1qNFJrBxmmRliLwEV0QOKEkjCoH1smC1bo1omzJfMTm2uZWtSCDC+YhWBjduqTkRF/n9ZVnl78nNHX6LH1W3KFfxgSiquUanGtxmwG2F32r6XjS8WhBOpEQKcjCQlb0C5+Wen5NIG1aRKqCgttQgaqE05qtWSAqRVWKOSZBDlOc2dDfwfLicRWPaUFFKS+OqtMYOG+y4wVzlI7LbBStM13g+kmYJIVDIdFppLXITrYnLKqirEKiNVypO7UxSBjfKilym2JCXuUWyil4YpahJwhyUAb8RHXWOYjDLKUkKF1V0nk0HnZdACYG4JpQxuL7DOovvfGtYaaECBdUYrfo6WW1M3pILylr8ewlisH3ffEq1GX0gzTPT4cjl+YXw+iLTxXbQM1qTW4a9sbKGvwL7aXpKZYy8X8hkWSVp8GouXJ7fCJcJ7w0qQS1KiBZaJuo0cL/tPP3jju5xj+kGefjaiGIiRXmkvkOhm75Xf8NqpUhOiWW6ML2+EpfldpgG0TrjHPvffeDhd98zfvyItl6oAH+jdY+XmfXt5d/+zXqve93rXvf6VfXrXfMfPjZHuAI0qhtJsbAc/iS54SA31ygmEmO15KBXJALTmJZoottkVNab9tq4DH2bPoq2TLSf6QZKV6o2ZNA1/10wMCUlYpgJp5NEcE4NxF6vAEyFLm1i1+JEtWo39SJmItNZjLOYocc425iU0lSVWonnEzkkWWm3JCR15S8iCKSSChpNjivrNEsTmgvGW/r9nn7/SJovkCJWG2i3xJIL2lrcdsSPG+w4SKSh6BykQY2RNE/y3GKUxqrxSQWHg4DLjWrNh8J2HWkNss7WBm2VpOdYh9bCyDTX1fI8MaWMWxd0ipQc5bmmxoo0ihpFUlAyLZigUougiHRjwfrNgB067HBNx2raySwNfF4WUgyUHG4yjoqGGNqENVFjhKb307SVNFVkBqkB4JVCl4TGNLd044gqgwZKw0/VlATDZSUzXRmD3eywXS+g+eupyRhAcFUpRNLlQpomQXVpOWho71HaklKiri0MoIjcASPXVCkV7S2mFyObNuZb85kSVEVRIpegxdnawYuJrSASi2UlpyCRpUXQZFopaozkVNq/L5jO4zsJaVBaU1CCu2pudduJG15ia9uKPWUwBrvZ0j08SBxrc6JLd1db83VmPbyxni8iR1CCe4pFmlurK0aDNRrrRIMsDbsGa4TCkMR4pa2V114bcqlN01vbtJLbBkQ7MbtdJ/vd0DHsd9ihR7kOtBVpSQoyFbcWbazg2XKUz0pFQieMJs4z09sLYZ1Ja/zWhLfH1j09sPvhd2w/fZIo2Co6a3JCW0MKkfX1lXg83g5997rXve51r79//fqIz87fkkji+cLl5Znl8EpOcoNMUVJ4rPdokImilkzp6/8TgLusXO1mwPWjTD/bDf8ae4mqbYomPyPTkn+d9yy6xQvr+UBaZuIySzqRkwlXikmmn0bMT7pB1Wsuwu/MCdMZuv1WzCZKJpTX9W/OldTA9HFZuaar1HzVzilKjqIzrZUSEnFNhGUlhYjvO7afHth8/MD44RNusyNME+c//4l8vqComM7Rbzb4h5byo9qkF6AUUphIs6yxcwwyhaJSWgyndk5u4DlSUoQkj8/2ns3TQIqRdV5QVWF0m8C2GEfdIh2l481oCixncmkr/sZ5FbNJJi0tqrHljddaZIrtHG4YWub40NQRuRlcKjUkcpApcsmSC399/ShJXO01UkOTTijTDDQyPWv+F1JI5BCw3t+uC6VozaZcL6Ah12/TvZJlQqYMdtjgdjvhltbGAaVCCyOI80QOMzkliZx1LXMdhXKiNY0xiEmJ8u0xtBjbqq1MJ73DOrnO02UmhwTWUo0Vd/YyoVAY53C9HEhqm7av5wthWdr627QpsmhlU4g3U1i/3+E6MQnmklHKUBC6g/EO4y0liQxFDHNNEzz0dNsNbty2CfH1fTbN8xMJ5zPxcqKmRDcMMqVdO+KyUk4T1ILzBmutQOOVFhxbW+mHNZJiwvXudmC8OvfjGilGYUHStNrPG9+a0ChT3uHpgW4jXFFlLCgjSK+UURTwzRGfM6R00+sKpD4yvb1yef4qW5uUbjgrIWJUdj98z+7TR3w/SiOeMg1Ii1KKOM+shzfKsghOVd+Tle51r3vd67eqX92I5hCJy5nz188sby8Nk1LJS6Skgm16PrTkvzvvRAtaRS9WqdjO4rcbuv2DJKcYucGra0INgL/GLtLW74jWTTX3bAyky1Fg7SVBLS37XaGxkEErg2/cT9UMRlCpEZmsOIvRTqajvmtJS1WSkXIip9IMO8L+1NY2k46s4ktbHWIQY1ZMrKcLIQT8Zsvj73/H9tMHhv0jZhhlva7F6W27gdNf/oQzqiXVyM22NvwMFPISWA9HibGsMuGxnTjQ0ypJQGbosN6QJ9Gq6jbVs2OP3YwykQqJznWtsbyubdtNtWRwSh5blkmq+DKEFVrWIM2naqaPnOW/qdLcdw43js1h3jXCAdQs0yOFIs6TSCRyRmt1a2KpCVTjnl5NXtp8CyBIidrSiETTqqAUgb5b28w1nUwcl0UaZN06VooYWABsh3t4wm02GNeyy69NdlIydZxn4uV80xArBLOlrBXcV6mE6QJI+pV20rTVXBogXWH6Aesdxhkx8YRIOM9yhvKOdQmky4QuGWMN2klsaFoCtWTCPDMfL6RFYjslqavIe18hU6FIEMI1w15bQ0lF2KUlo73Hbjo5MOVVDoC331Nx40j38CQHtWaiqiiUEn5rmE7MXz7L82y8YJSiHzdEbSkp0fcOY1TDScnEuQLKWlJMzKcLSlX8ICERuoi+t6SE6T0KJVxgrdsUXxrtEjI1B/xuQ//uETcOYqxSWqI5SwFVUEZh+u3tAFJjbJGgAJUcVk6//Mz08iJ60CTbC0B05+PI0x/+wO7dI6okVArgeznoVrku1rcD68uzfF+0abO66kbvda973etef/f61Y3oT//b/yrmiXmh1CKQayXrXeuUNHjWiS5OK8o8k3NAadWMRz2uH+geHtFd/43bmCIpJXS/aWYHmvGnGSJU4zIuF1JYKGvjLSJ/zvYDBUU5TuimARSeohLIe+OWKq1w21FwSxppyIqSVXuKpBwlrenWqDXdqBUEE85Jwk+Y5RZupBFI08x0muiGno//4z+y/f4H+t1esrNb4k9tj7YCqiZ27x9kba2FMND+BWldWd9eWQ/HBghvcPxcoMRvutWNFmdzyejOo65pR76jVMV8vKBTknW9tcJC5f/L3n/1SrZlWZrYt9QWJo5wdW+ozMrKYncD3SABgm984B8mwJ9AEAQJPpAAARIE2VWszFBXuTjCxBZL8WEsM48C2FmeIt5sAjdvZLjHMTtm22zPNecY3/DkWkmp4IPHb8cWg1jaE7QaKM4Ly/FMXpIaR2+ly/TSWFpr6fd7JTxttnr+OVPjrMbdoBX36URaF6rzmGFoDmYdHMqyUklYl7C2Yl2TIhSxZIvs2JhasS4ogalNck0fmpNahi1ybWY2IKupKTXh7u4Z3v+asBkhJ01Bbbvcq6gI0+ePlGWWgck6clbyU9huMV3Hcj6Tz0fxZBsOyrZUojgvVOMI40g3DrggBNh6nCgxq9k0hunlhTzNmpQOAwar554yMS2cn5+J5xljrN6XXpGXkn9w/TyUDClXdg8bpVm1n2Fyboao4WoeM32PSYk8L9jNyObxg5zmVb97heY6NxQq559+JL48CZlmzFXXLCf/ynI4UGOi3+2aNEdbAOt7SVfmmbxGuiFQnVF+PKaZzSQVKalJqa0R+SJXaTazdN7j20c2795JU+u8PqMp6T3xFsJWlIeo6+MiORHZAKbnJ57+/GfiPInju0ac1WYD49i8ecPbf/+3DNsd+q0lSyEtYDtwjtMvP7J8+iTdcNC1UpPSz251q1vd6lZ/nfrmRjSeTm1q0HSRsWCdw/WKoHTet2lboawN1dI7+v3YJhxyyteUMT6S5jPz65E0LSzzyva792wfHvRgxlAp5NLg6dNJq8eLps9ULikqJSbqkrClNs3j14mliaaZc7xSfMZe080qgHaOk/73MZHbWlC7OLWO1er3rXllPp2lm6wy53jnmj7O8fb+kYff/obhzTsIPTSDkbEGXBCk+/AC66TJjjHNaCWjRo6R6ctnTp8+k9eV4IOME1Ya0WotZpRJrKxLm/gZmZ9KUYxqraxPT5iMQOFjL8B6QzbVHLE4hu0GMLBGvZYhwGaQAeb5QJwWrTIvMY1ZSB439ITNQNhsCZttWxtfYi6TGukYiZMmgabr6IZOAP2UqVk4qJJWcir4XpgqSQ0ixKbza2oM45yMQV48SGMDOE0S8zxTL1Ngo4kbWZpWM2zYvP9Ad3+n11/pBk2CUKjrzPLywvLliTRPhHFok0FN1uwwEivENh101gGWEjPGQYlC04bdrumeHb7zisycV4wNhHFgmc7E0xFnDd3jvYxJOUMRsH1ZJpaXV3KKdN2gg5NXNvtl7W+dpx8F1E+5igvbDVfntzUGv9tqG1GyPplO3MycMv7uns2bN7hOQHxi1PvQzHVpmpk+/kxZJiyOmgAfWvBDZn55Zj4ccRVRBao2INSM8YrHXFeZhsKml/4yV4z1xGlWlKzp2uXRom3b9P9SNni2798y3N+rAQ1NepETxUANA6YbcCUq1rWRC1wv01heF15/+pnDTz+R1qUxdSOmVEo1GCyu6xjuHjRNDb3W+7UqRtYqKGJ5PlCmM36/VdRoM7URs4I5bnWrW93qVn+V+nbXfC/AeVoiecr4ztPvt5o65kyNWRO0DswQCIPA7641a+RCMYX18ML548Lh4xPnaabznmE3Mn/5jLMw7PaKpYwybNDMJrY0I3XLmV/PM+l0lk6sxTnKfq6Vo9uM+O0gvapxuC5cm9C8rKRpkv7y0mh5JyZjVYNjnKU0LmRcV3LKSrXpe2GKamH/+Jbx/oFut8eMW0BuXtYV0w9ylR+eKPNRmkUXtJK+rPpshTDy/KcfOfzp93Shw/c91RhyLbhuoNtu8UOn5qKBzm2bhhoDsVbi4YCp4FzA90HxquuK7YJc5VVUS6xrOC2ZgegGubyfX4nLIsB5qS1O0rRsco/fDPR395ouWtuQSXK817iSF623K0VNeDNjyeGdMF2n3zVHrHW4+0cqagBqM5ZVjCQcNeOHHrfdKsXIgO1GSJrG5xjFXe0GqqHlkS+Y0NO/f8vw5m0zIUWhhLwaqJoy8fDM8vnnZj5x+NApBSyu+L7HhQ3xfCKdTk2jqchRO3SYnMmx4McNXRewtrRzl15rYy3+/p71dGR9+oQiaDdqluZFZqNcyGklnyeW0xkwdL2kE4WqeM+mm+w3Pf2woSKqw8WYVGIEoBsG3DhQ25qbLKkFKWJDx/j+kbDZ6lCV4xVNhpemc3l5IT4/qamsFWPL9b1dpol1OpNTxFmLa5gscmPb1kJuZjy8x3YdDYjQtLuGcb8DaKY0STALFVMiNWdc3zHc7xj2e8XHWqeEpEt4QozUlijGcqJSGnIJTditYz288PL737McXkWhcE4HXeu0Sanguo5+tyU9P/PlcGB4+8j2wzvCMGL7DXGeWY/POlB5r2a9Rh2aL/rcJf5rv2dvdatb3epW/xP17clKuSqvPME4bnC9F39z1STLdg6/HeVytQ47CL5eG/A9LSvr6yvraWI6nCm10o0j3dBphVyKNJFNe2aM3Mi1tCmqs6Q5srwciadZTWHwWnVmxS6a3uDHnq7fYDuZV0zVdE/RhDPpPJEnoVxKNS11KJFSm9I4S0b4l3qJcKxaj2IN45t7rWOHkW67v+o/6zoDBnxHNZV8PlKTGhTTwPCX5k2TVwdphfXE3a9/pYnv6SSMkLN0d1tcP2BrpS6aOvkmh6hGDW+cIzUlur7XRBqjgW4zoJguyAhWBAQvUVpNnKWUSnp+Js8Lit8USstap2jRzhOGDd1+oySgi6v6YlDJibjMpOlEzrklPbWM9Zob+N1ACEImNTD/5f+vaaVhSalrUgxqLfihww1DO3VoDby+HjEpSY/ZCaklN36mGkf/7jv6h0dcN8gARYV+VJOWMvH4wvL5I/l0bhPtNr1vjnI7juScSYfPmJK/opwcCmSYV7nUd5tmrEPmnjUqfcvL9b788hHSive9pr8U8rK2VXAmzmfiukKuX9FguZBSJlcZtYyFEDq60OvQVLLc9m2FbZzVit85LuldpU0ljQuE/V7YLGtloqpAbcYuKuvxyPL8pM8LFyd5kUyjRuKyEE8yVHVdwNLYtsaC1TQzlUzKyBzVtNQp5iuKDWOldb2kf1lI9cLvBD/2bN4+MtzvJZcwthkhC8yr/h08zijWtbZDFI36UIDTx184/vlPOoQ0ral1FjsYSnYiLFTDsN/igleC0rJwOp+Yfv6Z3W9/S7ffE58+S6IQo9i94ygD3HKkLJFSv05vb3WrW93qVv/29e1mpTkRuoAdtA4V7iTix04atc0gZiQC0+dJLvaySk+XloV8mikx0Y3NXdy0WK7zMnsMfXMzK7byMk3Jy0qcFuISqTEjWVgVpgkZVbqxo9tv1NRiNKH1Ws3GuLaJ3yqjdPDUpvkTX9NQTCGnJJ0hiqq0FbqxY9yOVOsZ7u/Y3D9Kb2cVf0njaeK1Hi3TkZoWrFEDWkppcgKD8QHbKRXG5JVqKsYHBtfz+Nvf8fKnP2JSbBnsylAnF6FugGoF187LTGlOfuO9zDMlt3W3cEP1slpf05VzaXxQxOfhqDSsUgEjCVwVlNyNPf39jmF/pwa01MYSjWAFnM9xJU4HSoqKRB36q2OZfGFqtnV4SdTYwgZsFaqpxT7WWtpzAxda9njfqzFo11eNUY2U87jGKlVqkMft7ugfHvBdaNddoRrX9MeZfDwwf/nMeniBnIWt8k7540aT+2osaZ2oa8Qad5Vf2K6TDrgUwjjSHEqAI0/rFXJeS9Gk9jxTkb6UWsWTXdYWpar415Izzlj00liB/CuKbEVxmc6HZjxrEhAbBN93FhtaCIIRhqhmYJUe1W0H+rs7XEvlUoupjvmCxlpen8nHg/S33rc1vcV2jrxG0nHSdDiEZpjSwcOETtdyysQcKRVc8HL7p8z5cNY2424HOEILaqDh1TAWayxuDITtyPD4iB/0GRKRzbXDSVLcZtdja5NrGIu1Qde5tcRl5fDLz7z++QdFnAZ3xSsZ63DekNYMeHzoMMWQFum/TUGxrzaTjy+s65k8zSJ3DJKKlLiSZ31PUQsmy1R2q1vd6la3+uvUNzei3TAAah5C14mXGDx+GBTX6T01ZvK66qY2L5SiVaMSiKTr8n2vGMLOYUOH3/Q456/u3rKujbkok1KeFJ9oO0/oAzhHyUk3XC+Xvus7fNAazzTndM2VdD6Tl6jHN3yd1DQdXTVtunPJX283q1IVgxm2G8Y3j3S7Pd04qkmqWm1S0MS2tsZonTBp4TI/qbaqgbIOnCZYYlc2b1AYMBTKupKnF+o6sxkDJemmrSZTzeQlpWo9HcnTJLe/9a3hyUJm9X3TtAo05UJo7EhhlEou5NOZvCxNqwiXuFBpfTu67Yaw3+PHUUSDxgtVs1rJy0mZ8LUAGd93LXSgyhRSzfW1qUX4pJpT08MaHQT0wC2eNGP7gHUeF+RoFxtW0zUxMRsv0looIgb4zQ6/vcMNgw4lpVKtTF91mUmLko7iyxfyGjHNSHcF0hsheeI0KeKzYbNKatP90Cn2cxj13MvX+No8zZRUKMZR1pl0PlNyIQRB+9MkxFHFEJeFtEjPWkppGkmB7CvSnLohkEvFGIfveuGrgK+UA0fnvKb/zl2jb0ERq37c0D/cE4ahMXprO4jovcs5E6eJ+PJEXRb9Hd+03t4pSSkpQYqi+FOso140s87K5LYsxGVVGlcIkiSkzBoTNgS6sQcc3ndCXxlzJUEYtKkYHu4k57kGVaBrIX2NsnVdh6lJJqGLdtcHapGs5/mnnzh//iyd6NCBszgT9DNqJUaDDyNdb4hLJOXSzFmAqYT9SH+/FZT/NGFHSRyMdeRlIk1z+w6SIfKCfrrVrW51q1v9deqbG1FsxVpPGHvCpsd1naaC7YazHM6UGNtU8bKja41h685s8Liu5aYHfwXU55btXXJukYqrMuBzuWZe41r29OAIbmyMRPEHrdPq3RSxJtOsZqGmJC+NtVe8UcmZmBLxNMn00YDkLvjGPLW4fqDf78RrHEbFKrY0IYxRvKMxalzWpaXutMkiF9i98D/GtWndBWLemoASF9L5wPJ6kBvbS1dpvZNZolTKksgxkheBtk1KeK8pXS7SsvoQNKFFeKLL2lphAqlNeBY5qkuL47SeaoW0CUOP34qxGcaW4d1wTTWba5xomk7UmrTODgFnh2uCTcmX3PmqyattGKZyid+kNUdAaYxMvS24sf8Kvsc2lE7GGjE+TVFgAMbhdvd0uztN0oEGkxImrBRKjsTDK/HwTIkRY8APvcxIF95nKTporCvkhPdeKVEt2tMFTy3KZtd0UHKIy2T74laP80JdZmyTfpRcMDlTrSEtK8t5ukbACr/Qnm/SIcm1g5XznpRKm14qCetyODAGnO/1m5aM0SlJRLOuE4XiTgxaJQu1BvRCFVgW4umVOJ2htMjUFpVLY6nm+dKMG1zf65DRErKuSV4pQik6xHWBsB3U+KWkaNAQoBqZt9oq/jKFNdbS7zcMD/f4cZQBrwoeRdZkW2lrXoatqseqRkloWEtaZ+bXF06/fOL09AK1SgttDDll6VcxeN8Ret8+b9JC49p/do5+t8EPnd7HAnYz4rtObOFlJc9nytqu50aIsC1u9Va3utWtbvXXqW9PVrrb44YON8iNjYESM2ldyTFpjVpo3E2wIcgp3Ew+NgTcZsC25KKaqxq5Bpovq9zEOWWtxUwzJjQjku0CLiixybZ0p2t4Uq3K3l5m4jQp7rGKfWO8YPb5YlJaFuZlJc4R69RcumAZnKPb7xju7uj3d3Tj5mqcKKXKJX6ZjDQ4e83p62uR1SzZfosNfeOgNjzUZUoF5NOZeD4r8jHF1oR6MSGdGpYYtdYVqqY1M6UlDDl3TUTy/YBzjQfZ/juDEEZpXsVaTWoeLwk8F1u67Tq54Ldb/Hbb3q/GbLRWE69lJk1n4nTGmIobOzU6KUnV0FKdjHOasqVy1QTW9DXNBidd7KVhNBa8t+I0Orm19bjtvfZev/PF4N3dEfZ3SkTq1PSQVjUspZDOR9J8psRZEPklYhs27DIpLilDTo0HW3QN+R7nHAVN5RRbWq4cW3IkW7Fjq/WkaWY9HnVAKlp5Yw3OKN+d4HFdx3ycSCljL4eo1gDXXHHOEe4GfHeZ8la8qZIj5KoJnPOSmDQMWY4ZcqTEivUdfrclbEa9Hm0S3C5CCB1xOrM8P0FcqSmKgIDV9Wst1EajOE9ys4dGaKBgigFjSas4sjllyUSMUGMuSItcSm2hCNJtahHRJBcNu+THge3DHd12KwpEO4DUFiZQQRN16zFFBzXa5+kiT1hPR9bTK6dnxYK6IB2yC164r5SxxuFdkDkPZJK7yGGMmMZhN8o42QIVbJOApJQoUQe2EhUte/leEW/1phG91a1udau/Zn1zIzo87LWKzkXGo0k6KtNicK6TSaMJVm4TlNA0oMZ3MhwYpfJcHdNZDVOOQrOUUtvNz+OHQLfdyJlvbUsHauvNtkqVu75iSlH8YtHamRbpCEZpRy2dJi6RlDKurb19F9g+7tm9fctwf4dvgPt6geD7Tq7mHKlrVOyocQ19rgaqGo/tN9LwuRbfeZkE6tZLjivr8UA8HJUhXqRv0/QTMEXTspoxVGyRDtBAi2gEh8X2nVbHlzSbglie1lBzJM0reVma1FYawItu1KDoR78ZccOADz2291ALZTpplV/RFHWZKTFSyXIuGz2WMt/b1Ne6poVVYlOxWdOmVTn1WKPJtb8QDSQHsFa3eLmwi16vkptTGYUaOIcftvhxq5hI5zCuAe1zolorvezpVXivddWwz1ns2EtWEPTvUhIgHqStrdG2TtdVrYqFxGBtlW6xURNA+sC4rOQ1U5ZFsZwXI45+IWoIhL7DdNJWbjuPP51ZXw/Utb3XXmlEoe8JY6/Xkax4dB+otWIpuKDpva1FGlVQItWa6fc7xod7mZWuoHWZhQiBWmF5+sL68kxdF2znsaHTe9oCCVzXkeYTJa3XsIdSgVKarAXiupLWVYlJ1/QtQ4mQSNioTYUNksRQG0KrbQysc/R3e/r7e7pN00Q3QH5Ja5NkjC0NC0V01tKuVYcxkhTMz8/Mz19I89TMRFrVl1IpyNXuuw5vg97eJUrSEjy2ijfqNz3dbitqhGnveUtpy8ssE2HOzbyoz6sCFCrGW4VOrTfX/K1udatb/bXq213zpbKejqTzTIm5TUQs1TTHbVAuuyD3Dj8Ogq0XQcJL0bo3xZU0zc08oklVWhatmo2ax2470O+3mho53xKWKpRKrlrD5VVSgMvUrbbVqet6wuCJ88wynWW2WVObfGi62HWB8WHH+OaR8fHNNU6wtknXV9SSodaFmib9d9iWtmPU8NqA7Vo2vG1NVWlTndYkpnkivr6QV6Gg1HyrKSD0ytFuE11qwdbmNPYG0yvfPMcVk3JbX7a0qcvE0FmohTxH8rReoeY5psadDG0CGui2O02nQqBpJyjLLEMRjpRWTWuXSVPXriX1JE1/q+nUgBvli9MiQ2tF2JuUZIJKUeaaXuEBNUtbfM01r7aZbapy3VqegQABAABJREFUx62h2tCacIMb93T3D/imRZQd2zU9YaSuM/HwTDqfMFXvqfHNjQ+47ajp8zJrStsaC+n9WpNZjdawMWpyGZoh5jK1S5n1dGadJtLa4PreX5tQQKvozYjbbASD916T2E564m4YmJ+eICny0jaJgHGmJYzaBo73iiM1WlvXomCFmrP00P1A/7hl2O9QX6gJKk0HigukGFlfnynnM6Zz2G4rkkLTd1bvGd++pxtH8nJm2exYD0fSNCs+M0unWauaPCVlSUNcgZQLFkdZC673+KHTwTPrWqMWST02A/12JIwbhTq4pt2lNhKCxw49zoeWJFav4RHGiq87n86cP39ifnkhrYvej5gbW7ZtGorCLFzw1DVTSxI9oxRqdITesb2/059nRf/aLui6WAt5XcS8rQWTK7kUwAlBZg0+BErJzOcz8YZvutWtbnWrv1p9cyP6+fc/UlMkXDLRvZWztrnkrdPaLoyjMtC9IadydUCnuLIejuR5vbrVfS8QuDFWju0+KP2o69WENLNMKTJ/mOAJ2xETPNPHn8nzrIlcBeuU8rTMkfPxQIpRzUNbeZIL1VTGN3fcff8d45u3hN2OS7SlTD1KJ6rVqEGrCazsP9YrjrTmBC5gx72iLUvRWpHaTCRAi+lcX19I57MwUEhLKy1dwPZBLvhFOexUJQQZH8DU9nO1xnTWYzqv1eW6NvTQ1zSgsqytEa9iQjpLre6q9+x2O7r7Pa4f1H62BqDERTdxCimehCNK7c9KxcRVOCRjwEhLqQm4pbGNqLElUkWxMg0WOw4QOpprSVPdDBd9Yi2tKaE1sw3cb4aR7uFtw2L5tqYViopaqOlMfD2Qjq/kdcEY16a1kiRgHXYcRQaYDljUPNbSKAqWpvdsE+sYhSC7SEC8HPdpXlheX4nnWddywyCZWrAXHat3+P0GO/TSvfogCULOjcea8cGzub+Di8Oe63CR6hTOYJyTwUgj6+vzS2sCZxke39Dv766mMExRs2wcuE5u+OOBNB31x/0gk5F31LgSj2fc9o7duw+E0Cloodvgvrunf1g4//IT0+fPrMsZwR8Ctlwmwi2fHaAarCmEYWzQeaHZSrv2Xefp7/f0W02waUEAmnpHPfd+xPlO72UzXVlrMS3kodbCdHjl9OUz6+tJZrKGTbv86jWhGF9rMYlr43gJXzAV/GDpH+/wfSBPK9ZL7mGdJa1JDOF5uj6HsmZN7217H4B1XUnTQl5X3M2rdKtb3epWf7X65kY0TSv9EDRhcxbTkl/c0OM6J+epC80DIY1YqZl4nJhfzpR1FaKGizFEzYcbB7q7nVz07pLj3Zq6rNQdEwLdvYDqtgsyroTAofyBcjxTgOU4kefIuqyUmgh9TzcO1JJZpoTf73jz21+x//57fD9qShfXNuGz4AdKSZTzCVOSNITGQUYygKybldns1Yg3E5K6kGauTtKara9tWoeR9tIKRG4wuM1GjvpSNM2rXzmpxhuMLQ3rUzHGa9rczFw1rY0XqWY5X0xd5WuetjSahm7oCOOWbr9vyTpitSoVp6OWxHp4lbZXUkUxRDs5kNO8ktaFsBmw41aToyZ0NU7A+LzMMqcZcM7ieh0SymWqzKWJNNKW5gpl5bKnN8Zq4jfsGB/eEsZBzvnm/r9MmGuOpPOJ9flJ+l/v2xS6gUid9JQlZvLxFVMizkr2cGlSi7cNpaTXqmRpP+Vw18Ol84nlcGI9z+TUmsTGySzNYFO9k9luHKE5/Z0zkFfStApptOp9sn2PNbqWc0vIclQddCp4L2mAKUAY1LelCGnFbjaM797R7/YyIukdxtgG6S+VNJ+IpwM5RkHnmyGs5kxcFmqt9B9+RX/3iK06LBC8jHQFfNfjd3vWn36ktGSyuETivBKGAddJBmMzhM7L2OWaGW6ade33Hd0wMOx3CjyoXHXTcqclaU+7Qc16+UqwMLQG1HtyzJyevzAfnknzBDXJQe89OUbKRbtZbdOJ6zNpTIvbrRXTeTb7jZ63d6TzigsBG3T4idNKms+sJ5EOrLENUSUjZku/IKbIOs8QK10/cD6e/xVfsbe61a1udat/qr65Ed292cussN2As4oX7EKL/pOrtyyz3NrGEKcz68uRvCaZlZzW6yVnjHd040C37XHDiOm75lyuUBS3STSE3Y7x3Xf4ceCqhUO6xDBsGB8eeTkcOb0cWc8zpggtNW521GLJueKHkbe/ecvuu+/UPBQ1t7UUrZ59T14jdTpAnmX+uGhEiziIpuu0gu97aQvlspCxxVjqGlmPB+bPX4jnE8YaJTl1QU5ta3DjAEgjhzHU+Bdoq2ZCsr2iUNPLC840LWxrxkqWq7sCaVrU7Blz1cGq5Fb344bh7Rsl62Aa29O2tKdCPh2Zv3zU4aDFmpo2Nc4pSnpRIeyb01lIgtbkWmpMwhYtS1vdGqoL0DUz08WZhbkGAxjTsEWXayUn3DjSvfsVw5u3OLi6n00FnQAqZToxffqZNIv3aPu+/fiCKRUTlEQVzydNjKXgwLU0JZnKFEmpcAHbnOeF6j0GByUTzyfOzwel6FwiVhuiyDqDRY2pv9u1tLCvJIZaGrbsPJHXCUql225kMGoHGKxrZIWiz44RRgwuDaRMYKZWusc3jG/faLWeL2lL5srczNPEcjxSo5pBOfubvpdKOi3YYWT34Vc6OOakfy7XSpWe+PlPf+DlT7/Hh0C33xAPE+txBm/Aiq9rrZW7v9PrUZKiNrEG2/X093f0d/fYIKrFRTtNWqFGXTrjvq3xk65RL7mIyUriysvCenimpBULOOuIRoczZ5ou1IHzkgOYICxazYWyRPIqnbHvHdYbbDdSYtLBBigxkpLYrrUkNaBWemVKFLEjymWf0kohazLcWc5PB56+vP7Lv2Fvdatb3epW/2R9cyNqxk68zrHFdjbHb1rWr1zDGElzIp1nalSTYzp/1Y5aY/Bbwdq7cZCBqaFWSpEOjArh7pH+bqcM7Wv+O2JUpsRyOnL6+Avz0xdKlsYv9B7vBHfPCYb9lu337xlb1natRWYj5Mw2fU9ZI+nzL21dGbDdRuv3GKl5Fabo/lHT0eaKNxfXTY5QYT0fWT99JJ0OMoP0TYvWpmDWd9heoGxhZIxcvaleTUB+s8XvNg0lk/BdT12Fbcoptqla8/CmrNVs6LVqbtIF4x1us2XY7fCbTZMSiI9p+p5aEvHwyvr6TL6scUMHXYetMmuk1vTYS9iAD1DzdcVPzsLcrCtlXqHpJsPdHcYrSYgiLI8pmogaYykoOrLE1ExCnu7xHZvvfkPYbqnrfIWZA6ISpIX1dCAdXqAUwu6OamxrVqVhLBXyQQlWF26qJsmGXGR8Mk27aH2nayBnaX27QEmFvEbmw6vSk1xg2O3E3lyWpgWt2K4n7O7kVA9OsgNpHCApBlKs0YL3coGnKAKBtZq6akjoMS5Ir4hW0aW52A0GO4yEzYawv9O0t7T32lxYnwvL8UQ8zTpYBCd5iHcYSps4w+Y3vxP14YIXs0bxmdZRU2R+eubwwx9ZD68EozSuOCnGttv0+KEjF0NeMn5sqV0564DIBa7v6e92DI8P2NC3L4mLnlgu/2odbrdpOKVVZIdmAiQnqgvMpyPp5ZMOl12Hc454Puv7oKGusJ7gmonItzjfirBsfcAbj9t0uKZHLmvC+CBNdlzatZ2vOfXVGLnuqy5vGyQ7SVHsY+sD1jrmw4nldGboHbe61a1udau/Tn070H474scN0PAsqRlurEwf6TyTpuWq/yvGYJuhyfmg9Wjj+XnfUXEtz9xSkm7Y7m5LGGVAMM20QeMZlvnM+vrK8eMnzp+flLhjhTvSJMZSrWPzcMfu3TvGN290g8lK6MEYTDeCceT5TD78Qo1qNmwX1BTXrIbTeaW79MN1kkvXa4rWeJz5fNYKfjpLX9gp9UasypZXHzQ9rSVL5mYRrgnRBXAe14EfPORIOmt9b/uOVAv5NOuxzKXBEj8SL+1drbWZu7aETd/c5UaPE+Sur1l4o+XLR01rvX6GsV7mr9NZ0+HWtIrP2lzyjSmppluHjrwsmqD2QRzQELS6XiVzMAZNHqWIVCRlH0hrpKSJ7u6B4cN3hM0Gg6VeUnEaH7UuE+l0kuaxZDUdTqD7mpW04/qRkhPx+KqprtX/Fj2ihqmlYkID/yOdcm0pVcYU4pSYDyfSNIGxhHGDtVZNdow4a/B9jx8Hwt1ODV87hAj1VNV0JTVnX7k/Ql/ZxvvU9FaNjAwzmozjNYklyojlxpFus5EhjTZVdv6K7UqpMH/8BFRN9s2lF84yf1Vwmzv6/YMIBOuixs3p969U0jzx+uOPnH74szBIFfKaSbFoArjp2ito8FYHGz/qEFeO56ukxnaObi/TW45JvFzrIC7UddF7kyrhbnudPmM7MI5aFS1agOnLR/KquF59n2ic7YcNbtwyvx4p86oDQRZgnlKb1ho1+N4RhgHfhytqyWAa/myFmolrohorDFVMlPa9QQXb9ZScWY4nStb2ppbS1vc6CLibSPRWt7rVrf5q9c2NaBhGReCtkRxlNigxC5Y+LQJLXyIBnUMSz6wJWCzkGEkxYdcV+/BIN1hpxjD4TVBCk3Utx1sTr1or+XRieX3l9YcfmJ6epd0zBt/+nGLoxoH9+3u63Zbd27cY31FqVdOEGlDjNZUs54OMSFYNMrK0cHHKm0E53VwA4sZQrZdrfF3I88R6PJLPJ0yWbjLXjAmadOWL+zkX6tzctrWZYxr6yI4d3WaHDe4aYSkpaBZPFBDcXO5g0zRxxntNRbOmfm7s6fcbnBfgvaRMJeu9qZl8eGJ9eWY9HARHH1p0Yy3CCuXSjCMV4zQZ0oPLVEWSPrMkreprKZomW4P1Vs+/VHLMyoh3DpIc3xfQgbEylgx39wxvvyNsd2r6c6ak+aonrDmTpkkw+pRwQ69c8Zh0mCiajFVgPb427I6uBWPanLpe3OQW571W3kXgdQOaElfLcj4zPR9IMRH6QdMxA6mlThkvU1zYbpUJ30nnW9ckTBGKl43nExaxQS+4JwNfn5dzwrY6Iaxsmy6WLL5uSdJBdvs9vh//ws3UJnc5U1IkzmfWw0F6R+fJSQEKxkuqUauhu3uL3+6py9Sa+3o1tJUYmV+eOfz8I/PzF7y10Lipvu+bmVC/l+863NCiRLmY9qrkON5hg6O/2yhlzBhKWoinjOt6TFyZDgemlyNpjYTtC5t3b+k3m4Yv1edhTYl8PlLiinOWckEmUaFz5FzJ84LJuWHQrA5PCIOW5xXfkt1c6CSD8e56gErnCUrUZ2CO7cBmyGs7QDRWLM5QSibNs6bazdhobMX3Hd12y7AvDHf7f8VX7K1udatb3eqfqn9G1vxCNes1VaasK6ypOclrMxNobUewgsUXyDkp7/zSldRKqUUmmmEjHqOhMS/VxJacieczy+srx4+fOX16Iq6rEDlt3UsIdOPAeL9n9+aRbrNt7M/GKLVOaUxtHVnOh3YjLO0GLgONsQ7TDzK/GK1DTWkRo5mWrT4RpzN1nSnz3EwSRuvdWoGA7dT8ltgaJExrqltjah3GBSGVGpaptgQZclFzkosYo+sqzZrVpNXYNmVsKBzXKbNbsZjNwGIdNihpKC0T+eWZ9PqqtXXfS8OXdSDIWYcG27isztLA6F+Te4QRym3C3aavRpPOy3Oxvk2SG/IIAFvFbGyhBcZY3Djit/e4frhqCGvT/KohW8nTURnfbfBVY6LUS6NVBHtfZ0qODUgvjaVpcahXHaVviV85N6h+EYUARW4ur0clb1XaQcSoCUHNSbcdtYLfbMRstVZJO2vSVK4qtjTPc1udt8NBkjPcmKbDNIbatNE2XBij/opnss7Tbba4rlMTZ5262CaPKPWCSztCrYTNSI2ZNC3tk+s0hR93hN1ek+kkzagJl5z4Snp95vT5E/Pzk5KivMM7R44Z14IGiImSKxaDDx2u66SbbClpxln8oHAA3+laNy0JjJoo68J6OpNPZw6fn1gmNZikzJRX8n5PtxNlIs0TJS1Y7/C212MUNbpUZckvr+LCussav5n3as0Y4/CDo9+P0uhmmcgu56eSpMvNayaeZ8C06W8lL9KsOq/DVIra5JQs7TLNoGYbuqnrO+4+fGDY7f4l3623utWtbnWrb6hvbkTX8ywszqIYz69f/M1NHiwW6daME9RanGp1Fq4L9Hd39Ps9w+6ObrNpN22BrKs1gr4/H5hfXpien5kPJ+J5IcZ4xTSFvmPzcMfmYc+w3ytjuwHfte5uK8CcxRnN59Y8ebCBmqP+nvW6kYeh3dDEylT3iJqNdSHOE2maxOVsyS01KQLQNW2ZrZU8zy1XvV5Xq9VqVWiHATduBHJv/Mwa17b2rlQMfuiJcSEdJkyumqD1AdumatYHPX4nSoF+TjNLtUV4mYWbSYeXawNh+414rzER10jKmZQSVJnN+u0G11igF47qBfBd23rYmHp1zV8mcW6zVRa7MZoUp6x4UaOpUo0RO2wId4+4vhdR4cK9NEBaiNOZfDoJ72PE8rSuyshVMnmRCSXPDQ11WUdTlWfu9T5zSdG0LcSg/kXjHDzreWZ9PQpgXtRIOww5Z0rJ4t72Hj+OdNuNIlObBjqvyzVxqaakVKAGta9WcPV6gbSHDjsMTd/ZpoiDQg70nieM8/huJIzba0St6frrqrmaQowLsTWhxjlc16lhz4276YwiWfcP2H7AlERdJDGwTdsbp5nTTz8yf/6ZNLeIz0a6MM7pmo2ZnColZcH2QwfVUJb49WDoHX7sCHc7HdqsGrVasjisqz4n85NwV3leIGd8P2KdoaTE/PJMTpGw21+DHkqTN9QmOamlMB8m5ucDJSZ8CPr8tL+TlhnnDf39Dj+2A0KpTd7jmuFI8b46NLY1++V6zPlqLiwlkWKD4jdCmG/fIYWK7Ty7+7eMd3u6cQv225OQb3WrW93qVv+8+vZG9PWgqU25+mLJOWul6y3GVCFxUpuQosmO7wa6xy1Di/rzrmuA+gYFtJa0LkwvB6anL0wvL6ynM/OkaM3LpGq427F9+8j24Z5ht5GBAtSZuA6CNHw1Ra0TU1R7dsEwGcBUaltxWxda5nmFKKi3/veJtExa065RLmGqdKulKuqwGyi1sE4rpcVGikijfHBpA5vutRdZwJivmCXd8Zp+dhykR/WWkBKmWpbXV0zVFNSNg0DpRpxWvXSlSSB8uwEvrPNEnWZYVzUagxrysibW80KctH6sVtnoNnSCts+LEFxGv3uOKyWlxkkXXqii6akiXhXTamxjwFIUdYpRvvm6toz1LI1wv8EMGyxgSqJkTdDi6xPxdMJUg3WN4dma4VyKjCa5CPGTlbQlZ3lrkGsRFB4afL3QRrtCLjlHyoXpyyvx9cgl1lOMVckRMAbrHf1uwI9Km3K+a4Y1TVSvLv+GkcK4pmXUoYPL+7TZYbuuyRtERVDjF9o2wGBDj2/pW7YFBtS2gscYSi3E84m0THr9rpPJdugAzDgQ9veE3Z1kjrOCHapRilW1luV45OXPPzD/8jPGpGaYkjRBRrrCek6UOWHadeUat7XkBEWNdOg9YdPrPbfuauopqw48+kdxtBXkcm9EDN9fOMBGGs4uYGtuRjLJUGqSGarkwvJ8JE0LLjg1+SlfD7k5ayLab3bKikebCmtd0wfLSBXPk67xWnC+wwUvpFrJasBrZV3WlmxGa1KFKus6T78bqM6zfXxk+/CgA0lDyt3qVre61a3+OvXtHNGYlSFvFLWpyUGLwaz5mjOfYsJYw7DdMjzcM9zfEYZRN8MWS2gaaiZOM+fnL5yfnllOE/G8KD40rsSU8V3H/uGRu/dv2T4+0u+k3/wvYgLHHQVLmc+Cr5csLIxR/rqmcEasSTK+ajpqLtO5IndzSZl4PiqaslZtqUttwHPhdyqCjed1uTqlaZGVtOxxN0pzaMkCe2OpVY2AqW0F3poGF4SFMkYRnC44Nu/e4/q+5Wp7JT7FRDWVXIu0mV7/W3yAXPBV2rlkqswppjWFbYW8zjM5qjH2LY4zp1Xc/LxSS8SGrq1Ji7S7LT7SWIMfBlzf44ZeE+E1UdLCRYdYc9NMrgs1J+x1In0gTzP9Ghke31DTSjq+6LAQVzUlKcvFfOW1VuJ5Eeg/F3znCX3QFK7JKS6NnbmgoqwDQlvvFnIuLC8vLMez8GEGZc5XtNrPFRs8YRxwfUfog9iyoEasXibia2NYFkLwcnE3Q4yITEEbgL7HXDSe7pKM5XQdArbTRNyFDkMzvjgvw1KUjjlNZ9bXJ/Iyy1AVwvVwczHthd093d2DDFzrrPfg4h73gZISr3/+PaeffiLOEzUXfOdwXYvqrJW8ZtZpIc2R4LWGv0SFKuayCMu26XGdlznONod5TORUhEOaJiWkOYNtZjDrLP5uh6lCUtnO0e+2hO1GBqWYyMZI91uVVpWmmXQ4k+elyRg8ZMi1bR28wzttDFx7D4WDM81Ht5DXSJwW8pJ0CLNO0a5Z6C3nPLlk1nklJjWhJTdDWZGeN9dK2G7ZvH3HMI5Nvy42bY0XjuutbnWrW93q37q+fedkJPivVVnwmNpW4frjkpQtP+5Gto+PDHd73Dg2B7WMRdZpejG9KkP6/PTSjA1JEXut+fP9wN37Hffff8f27r6xSpUahLHYcY/xPaUW8nSmxqVlbyvNRSu90hJwhNoxf7EyB64r4hJX4vFIPJ/aal0NNcZd1+MVS276TZJ0guaSjW10EzYNneScwaSkyVsplKzXxhSL7xx+GK/sT02GDYWqaSsoX965xn8s5POs5x88trZGviI3eGuSrfdsH99y9o750zNlmqk1a/UcpansehlQSs6kNQme76QXtNWQY25r10suvIxJ4f6BsNtByeS1Nen1gtUxlGquzUBtmdzF1KsJqcSV9ekjtsrBLJ1eey+rwXXSyqZlJcVCuUxusdeEnlIbEsoIVG5aY3QRlGp1nqipkpeZ5XCmrBEfPGE3Cj9b1Sxb5whb5b3bIMj6ZTVcc1a0ZoU8T8TjmVyyWKoXcxxtsuja9dE1sH7KgsVj2rUqPJbf7NXsAfhwjY7FKBSgxMJ6fCW+fNbE3DTeQJvqFgomDIxv3hPGjVz0q9bfNvTgNB0+P73w5T//I/HwqmvdgrtA6LHkIsxUjoukBaEjbDZq/OMq6YVp+uNxwG8GXafXPHjFp+YlkaYzaZmbuVCHDtd5arZKU6Piuk5r9NApNKGWRpRo1waWeD5RFunML6lWNRW9rkOHcU6HhLFvMlH9XlYRWZR1Jp7PpFU69AZSpRq542nPb42R+XCUWdJZXPD4PmDb9bPGxPbhkf37D0qGu+qOi+QUofsXfLXe6la3utWtvqW+nSPqDbVmYXhaU2kAUwyu79i+vWf7+EjYbLTSlWivGYi09j0/f+H88SPz8UCMkem4UNZCXLXa2+12bN/es3v3yHh3jx1GTRBTotaiNe8Fyr4c5TgvNAdsywjPrSnd7PV3c4vgbEYco6giclSMYzqdqFVAa3fhWFrB5QmOGNcWX5k0YQke6zooi26AxrD57jv6zUg8HsQwNAZDi9i04KzF9x2267nkniuDW9Gl6rO0Fs+NwyjgfaUa6SHLMhPGB5zrW2KQNIxWTiZsN7AZtizPR+bj53bTtnjv8UNQbGRUcx7GDmdNa8Is1qjRliZQ0gW33eKHHoOlrMJyVdpr3UwkaZrV2LQGwCCMlkxnFrqObugEXC+NI1pzOzA4LKWtowWDLzljqPi+x/Ud1WhiFZcZVzzddtsauEJt0aO1FEpJxDmyniY1/dZjfZAppQUK5FJw3hKGHt8Jqm7D0Fb8RfpBpzV8PJ3J84zpHH3YtKlkbu54J74qF7ZqgmqpDkWGGjVMftwSdntdv9qLNx5uxvgeqmH6/Avx6YsOQJdIzNZs42TUCvsH+vt32K6HtMoUZQ1m3Mhws0y8/ukPPP3jHylrJATLumZ87+m2A2mJ1NTMcCm1RlCxqNNpEtgpJnxw9PstYeixfYfpumYORNdrhfU4Mb++UnPBhg5FgEobbCqkVVGz3W6k2+8xzsqNn6teA6cJeokyEpXUcGj6hmmHk0J1rSHejIpXzeLoXnUv3l+b0DhLCmLaQ9SsLYfr1cjO5zPT6cQ6rc2o5ChzxAbLOIjKcPfdBx5/8xtB+61rmmdtB0zwuP3dv+5b9la3utWtbvU/Wd/ciJbajCzUazKK957x4Z7Nu3d0mw22801DZ5DlHPI8M5+OTE9fiC8v1AIpZ+bTSlr0d/rdlsdfv+f+3Ru67Q7re6FvADCYYcR2g/BGcboaHgTEp92gFznlfZCBw3vdtJtmzLSfldPKenxmeX7RDbVFhtYcwXsxGvuBnDPpcGhaNE33ZNIozOczpuvoP9wTQpCxYj7TjT1xlhFD+fQOH5RKY4yjxLXdSEObfAmllJZJ09YGQK9AcQZTKn4zAhYzbHBh0HNp01QTGtzbCkn0+od/JD4/Q1bT5LtOq/0qU471Hj/22rrHCDlhxw3OGE24ncVtRsJ+Lw3pGinrigkOfEedZwpaV66HA6WxKk0XMH0HWWkCFXC7HWHom5ayuZlTW506vRvLYWJ5OSrKtQj71I1it+a0yqDiLMN2c21ea8qk80mTW+fIy8L8eiBOK8Z30mE6hzEX/qYmt2E74AdpNLGXyRxqNkwhpURetO7OMcnJ7losKtKu+rFXEEIplPMkk5tp7M0krTDjSP/4Dt+PmGbEM75r08CEcYF0OjJ9/IlyetFhzlhqia3B16rbdr2SrYaN1vg5iefacFDUyvnLZ17+8R+YvnwBDMNuJC0rJa9430mSbPWaWWPx/QbfOVKMLLEwnSfGoOn7eLej2+kQabuACQ1ZVkzLsz+RlogbR5wPDdu1ShcdPGWSVGW42+C7XtsHe2F4NRZtqeTzTDwJMq8psyEmaWS9NTgjnanfjsj+iLi5cNX1pnmmxAWsgP61zJpIA9VU+t0GsJwPR5bTmRILOVVyycQ1qsFfLVOsfPi73/H4N7/RBqRFxlbt7rH9AMOO5fWWrHSrW93qVn+t+nZ8U9MYWguh79m8ecPm8Q1+GJChyGsyVAqmFNIyMz09Mb0+qclIhRwLcY2ajJXKsN/w8KsP3L1/p0jEbtQNrJarWae6rjl0p7aOVHqSTEiVui5U1xBMDUGkzPu2IrUCnOcYiWc5keUORw2ik6nCv3kE331d968zthYZK9okdZnPZGB4uBevFKgpydDk5cKu9QJC79pNfQDXtUQfGadMRe72OFNKm7zky8pS+lG/30JK0iG6TrGEDWWjpCBPtYb5fOTwww8sX75QYsT7TkQC22QDqCHzfSdcUc2YapRo1Jq/dU1YZ+j3e9x2J4rBGlvkZKFGQ7WKQlzPJ9LpLCNOEB8TLsxRGWy6hztNRFc1CyUVytIy5p1lPUc1T1EGMYMV7qetmcsaqTnSj6NA8rW2hiqRTi8YG7DGsp4X1sOxHWb2mi6X0nSeyjQ3fU+324gO0PfgPXlZYZUGtRatdfO0UpIiS32/1VR6jS0G1OB3W0wIkJTkZZuJDAw1rgKrv/tA//BGr1vO0AVwoSG6ImCZn59ZPv0EcVFDSW1QfAOuYi34/R3d3YMm3437ijXgPSYXyrpw+OknXv/xH4izgPDDXga+WmHbCa+1HmescYS+09SybSacc4QcidYyvH3D5m4r/muu1M6oUV+jjEgxcf7yQi2FMOqwkeMs2bR3VO9ZpwnvLMOv3uOcw1KpxrcJuD47OWfSeblOR2ut5DhTq1WiGpU6BMKmo9tv9V42rTephRP0XlP4ZfoqC6pG101p1ITQkXNhen1lbbKWkpPeM2vpR5nR/Djy7t/9lt27N9A4wqU1qViP3e2oriM+f8Jy04je6la3utVfq759NW8t/W7L5vGRzUNrQEuW6cB6NY0V4rwyffmsKMm4NONMZZ4WObStZXzYs/vwlu27d4R+aOaO1jwmpSClmInzWY3v7l4xnUXcQo1VddOw/Q7TD00oWP7i38poz+vKenglzTMGsGEg15Vi5PT2o3SCpRTyOrepXryuL60rlJqJ1bL5/nvlbrdpa4HmSLYNRwN+6AnDcM2lr9U2XanA3DUl1uVMScq7h6Z5cwLElzWCM8rV7rcNOo8aaiv0DhbW84nzp49MT5+J5wmThHgSM9Sxns7NrBLohk56S2Pbyto1t7ZerrDdEO62uDBQjVdTGS/sV0fJsB5PlHkCKs5/XVFXA5SMC53g797LER2jnmuWprEUmVXWL88s09JCsQqmWpnevCQLJa74PtDt779qQYWHpaaEdR2lZM5fnohrwlsvkD62Oe1XTTu7jv5upwnrdeqdlYGeMy1+qUWptgxyL4d7jasOGcbhugF3QTLVJqkw7ffKmui7cUP35h1hu9N1aYCWUFVrpqaFvCaWlyfKdBJay49gWh6tD61pHgj7R7rdXk2vaZKTpsMsa2Q9nXj9/X9m+vQRgDB0Yn+2n+E7T4mFGishiAzhu6CDQankYkhrxHY9b9+9ke5UnICGZzI6OKyR9XhkPZ6vkb41Zkx7S2qpmGIo80zXeXFCh67JXJIm4S1tap1XltcjFhE2qlHznYtc+6H3WO/o7vf02027NhvvNzcjZMwtQrjFwYKed8p4A3Yz4vuB5Tzx8ukL1hhC56SHRr4w+doMu/dvuf/bv6Hf7q5Iscu0Hyp22FKrJR+ecN5gTPhXfMXe6la3utWt/qn65kb07d//HZv7O3wQUsbUhjIyaHX38sR0ODK/HijLAsaScmpGHbDBcv/+ke3jI+PjA2G71UTIXLA94vzldWE9vBJfD9LlDQETeoJzwixFNaBm2OJ9r2YirrqhgAwspZDmidga0FqLJjVtYmRDkHu80hy3Z8n4nNcK37rG2iyE/ZauH9t6MSlbPDdQOkLuYCwuBCW8hAETlDpTUxSftCGAak2agBoZOkBuZuPc1YDk77Yt1ca2xltaT4LW+TGunH/5ienTR2F7SsXgsJ3HeGlaTdIUKvS+cVZ9M4sZairENYsPudng9zvp/YpSfAyabOZcqNVQc2Y9HjSJbet3rauN0m+sJey3hL5rGj79uQFNo0oi58x6mkhnJRdZY9WIWou7mHcquL7DjZreXX7v6j3kSp4n0rqQ5hVywlTo2u9maiWuK7kUbBjoBku/2xGaWQ5Ma+TWlhKVr5P7nDRtdOPAlYvbnrvv5XYXaFJGsZrSfxGvGvb3dPcPWN+6Zd8OCxIoUNaJ9fBMPB7bNFvBBjVfuKRVjNjdvZrv0IgFLW3LVKgpE6cz55//zOsf/0A8nYTyMqYdBox4t7mo2cMQhr6lTlmMl9EqxiRm6NgxvH24pirVmP7ClFTIKRJPZw4fv+Cco2tmQ3M5gNDQrc7SbwbCZqOG2VnpUNHrVSss5zPr6xFTlY5VUtJrZQ2dG3RA8ob+Ya9mukkmLia2UgvVCjs1vHmkxJX58yfWw0EHvKLPjcFyenrh/HKU1thaijXYJiEqKVK8Zf+r73j43e/ww6jvjFzEZzVy4hN6cszU85Oc+dbpMHirW93qVrf6q9Q3N6J3794DXL+Ucy2kqKnJ9PSF5XDAYDXJXFdiVrMyjAP7Dw/s372lu7vTetT6hlNCTUaMrPOZdDpQ5kku9C5gbE+lMn36hbrf40zF9CNuaE1s41IqjUZJQDlF0ulMOp2lyfSuAdWd4OM5UVCaTlnXlhJkG4S8OXtR3KUfNrhhVGZ1SpQL/7CIbeqctHS+72V0MDJn1dT0flXA7FIipazC7DinyUvRGtZ6q1Wzk8HGOLE7CzQSgLLL43Rien1hfvpMnbSOtd4L01ShUoXzKVkTxX6jJq25+qlQqsF24iv6ocOPgyaFLe3HYK4xrTlGUkMJ2SqzSJlm6hrV9IZA2G7ESHVW7nyM/DYNkF/WlbQovUZNK3rNjN5724Du1VThoboOqE2/6cAGyrIST2fiNEFJYkduBqyTIa5ERZC6ztOPPW7sCRcZgrFCBTWdsFKyVqgyq1njMEENW7msx5Hb/ZpG5b3kAkVyERDz1G+3hO3uaoq5QM9rEVGhpEQ6PrGempbWWUzoGp9UrneM0TT18S1hdy9jFZcELZlu0nliPpw4/OkPrE+fMKbSj72u1XbNp6ZjdoCpDh/EnTVOqKTSghqst4Ttjm6nLYBtjWHNYqzWLBNRjooy9d43ba7BbboW3Vs1vRwGxboG3z5b+kzVUsFKerJ8ObCe5kvqKpWmMy8yDdmxp9/tsGNosgH9uUauVU547+gf7+l2O707Q0/YblkPr8xfPpMOR+ISmY9H4rR81XcGq0MYlWVasWHD49/8ise/+Z00rsY1eUaSRtd3VOPI80SdTm0Sevn2c//Cr9db3epWt7rVf62+Hd+UMrW5q9d5Zn59YX59IU/SbgoDI1Yf3jHc7di9ecP2zT3D/g7f9TJdtAkVQF5W4nQiHV+J52NbWcq5qr+HED8NpG36Xu5hg6agRQaREhvzcZ1JMVLW3LRpmg/VgpSSpZLXSF6WpsdsD9EiI3XHNDjv1bxiqHFWxKbzkNSQWO/x/Ygbx4awaZOTWq8NQinSHGrUadqKtWkKG8Tc2oDrxCy0rXHSz6iNtVqIpyPr8cA6HRWPGDO2XghAhmo8hvb7AmEchRuqVigog1zwvZo017Wkn1rIy9rSfTymarWdplmPs0rTWaG5pusVwWO7nm6/I4xDA9THFg1aKakQxoF1mlheXqmrXNXuMulD8k3b4iXFRXVY37XeqzXxJVHXhfU8sR7P1FoJ7XewwbfpZWmHlo5+MxI2g7SQ1mqyt66UZW2udDWbtREYjBOCqbRVsjEGE/xVW2tadrlSaRWFSs7YblAE6LiRhhPa9dxWvCmT5zPr4YUyC6N1SaGvSQismgthHAn3j/jdHtdJxkED4OM6SpxZn79w/PFPnH/5SF1mSUWGQAhO+tY2qSwp4XLF+q4dPkQ1yCmR1yjd68a3LYRkDJfQAVLGtkZ8Pc3kJWrCaB3DbqP3rBn1zNCJ9ek8fuhlrCu5NaBFsbTOk+eF5fmVskS6cDEd1uvnzDpLGEfctsd1gYqjtPz3WloUJwa/GRnfvWufxUuTajAuMNy/wVrL6zwzv7yyptQa8orzAd8PDZRRGR7u2H//Hbv3bzHhq/yiZj1f22+Ub386UJeTJqOufVZzMy/d6la3utWt/ir1zY1oTIXp8MJyOLAcXsnrrDZFNCRSlClm9+aR7Tv90212Yh3aNh1s/MmyRtJ8Jr6+kOezVrnWgfNKKooVPwyEQfo8N2zUGLSIPtokqMyTmIazVr5C1AjTZLuAMY56RZDLtFCrcr6tbWvE0lBD1mlF7Rqgvk1lLg1rLRVrHH47qJnrOjWqLXZReeiJvKxavzfKgPEOY1xLXdL0yBmDHQw+qLE2LdVGsYqFUg3r8VV8yVVTyJILJDWp1bWVbC3UvGJNi630MveYFk9pGgjebzZ6zsZQkiJaS6kNz+PIMV0lCnma5d53rr1mSiHShGkrEHyvhq8W4XcozUyEJsbL4SjYeRKbsukdrqEHxjncGK4hBxjFu5aG/6GqMco5kVuwgfSnym5X3KUaF78ZCX0vR/sl3rO0JjQnmZFypC6p6XgNtpMmUe9VxfhOk82GIbritS6ZokaRtW4Y8JutwgSg/bn+Mc6Rppn15YV8em6RpJfDFA0RVRUDejcyPLzBjbuvcaAVPX9jSNOB6fPPnP/8R+LzE86AGXuMD7g+iBPqKmmJlCViTVVSU/tZJSdKFevXBUfYDLhxaFKY9oYYqNZSbblqT/Na2u92kR4YbB/ahNvgug7X+Ybwor3G+fo61ZyIx4l0PmNyafIBq/U65noIckOH8wZrvdCpFJ09ykUb6un2CsOw1gjTFi6BBRWTImleOP38ienpgAW64DDVt/fKa6pbYffuLfe//TX9fickVqnURdsJ1w3UEMipEJ+fYFWIhPFBn68YpQUvlwivW93qVre61b91fXMj+uX3vycuM3malF6E7p9g8CGwf39Pf7djuH8gbLZKZGnNHLW5ZpdF6JV5Ia/TdfKHazdsgyIxu54wjEqiMcLAGGPkQK6QpzPpfCLPs1avKcqxXnQD9cOAGzpN12Kmpq/Z7W7sIGp1aoPHhh5rG4TQIHc/tfEfNXW05qK17LCha7D6NoX0l4jBSXGCuU0hncxFF4i3c0oCMpdkpyFouuvU0Jmq576ejsyvX4inU2vavLLtY8Y6Zaf7YWC8f6TmzPnTz5hasKFXw+ukFTVBTZvpesHv1ygiQG5cx9BRrSdOE+k8CdWT0lXL15K4lW409HS7Eec7cUbRlKhMc8PwCLye51UmrJQawgq5RIxV42gqYQx63a1t11Btk8tLo9jMWZfmL4RrhrxxUK0B4/EWTHCKJ23IoRLT1aldYqKWSM5RsoALRL6pKMuSyKnihh4/jq0/M9frrbbf0ZgO165H34eGTlLCE236WFJkfvqZ5fUVm6MaK+e+mmqs1rx23NLd3eOGEeek7WwfIjCVkiPr82emTz+yvj5T5kUsV9OQXilSIxScImiTrjXX3Ps5JjnfjcFYQxh7wqBpu3Vty2CNDjVVh620rMTTTE0VH7z0s1XJU6YPii1thxLnnSa29fJepzY5NqTjmXg4iwva5B1kXUfGFiWJ+UCOK+s8U4ceZSeUdnCi4dQ6uv0dfhgwJUsyYZ2+qiqYklleX3n+4584f3qipKjr3IBzllLEMzXe8+bX33P3/XeE7Vaa7cv1YSx+s4UwkF5fSK9P0h1b9/UayUURr1Ts/uFf+PV6q1vd6la3+q/Vt+OblpmyJtISm77P4seRzZsHxvt7wnaPDQ7jxcxUydiTTkfS6UBe5GjG2TaZqeSqaU43jsqj9l5TI3fJOS9t0lVI51Ob2p3azc60pqdlr3uv9erQC5lTZQi56EBrLdSkFWy328r1n8WRLKVejO2K9UQrPhcCrh9w3agepjl6wchpH2cxSK2lNn2kfq7g3fVifnG+YSJNoww4cNIg1pJZj69Mnz6yHF4pcbkC2Utu+e0V/HbL+PhIv79ThnnJ4Bzx9UnTzoIiF7uviT+1QFmma2rPhVCQcyYdjzJzrZrgXqbJOWVM8ITtQD90kio0uH1tRIJ8OimGsxQk67PX11MNtA4XaVHWeRgCLmgta7wy0algYmwG9ta8NP6qtMSX6adiOmn6Sdc5ZdR34TqZTdOs9yZGJQgtM2WZm4Ne08Syyh1fo3BAojF0LedeU10DlLiIgDBu5GBvjvmvSDDXpouWOE0sn38hHV91AKnlK/i/HS4IPd3dG/xmqxV3I0xQcqMCWEpOrM9PTJ9/IS3nRi0AYx3TcSKtM4aCDx3GBiG/rMG5JueokLOuNdt1dLttY7IKGXZFfxVk0EmFOE3SYWagVFJc2/Vh5frvuquT3nonM591lKjr3zRDUfzyqgQw2gS9ESRqi64l5wa3bwfRWlmniX4bGe7ucE1f64ZAt9l/pVI0s5UQTjIhTq8vPP3DP3D68qzrvVaCiK3aiORMt93w5m9/y+Zuj+vFeS1rJDfurd8/QrclPn0Uy7VIy21c03jHJCmAcbi7eyHYbnWrW93qVn+V+uZGdJlmwOA3Pb4f2L19y/jwgN9uMKFr7t6oSUtrIOQWftZ/fzEhWEdepduzXlqxfrfDdReMU5uCUq/NapxPTW+4St8FzUShGyLG4MeRbr8j5UhZNSXFGWw/UJPQN7bvCNst1lnIWv1irED4tYBtck5r8V2HC2pgTOj12I13WBqrssS1YZWsbvCpXFNyFANpCV1rWqy7Oosp9ipFWKcz8+dPLE9fiNOs5sIHjHPkFCk5ETYDw8Mjw8OjUDpGWjrjA5v337EOI/PnXzBk/GbAhY5cteokJ0ATYawjzQtpPimYoGk2rXeNiqWm3u83jG/ucU6JQkYEVGpeuWCQaoW4RNKyqkFxDuMtOI8tmi6XNeJsxQeL78QcNW3SfIlOrM6T06SYyAtMvWllL1xHE3TAkKFLUofLFL1EYZRqFs81rwtpWaR/NdIZGiv5gU4aFbsb8dsNoPWwCb5NgtVEGSscURgGNUIlkZeFtEbc9k6Tt2WVWeb0ig1OiKilJR+FZjirBTuMDG8+4McNpuRmUmrpVFXPPZ1n5k8fqSnhfYA6sKyZ3AgL13MdAarDYbCNopBzau9HxYVA2G3xmw3WiTtbsJra5oTJmvAtp4X1qANUaOlSWHQA9M285yymSTJs8OD1M8p5asarQJoX1udX6hqF0DKGUpIMejlrkOl0OK3OEE9nTckvKC+OpHVl++Yt47u3hHGrsIosuYeuJ9euvsL5yyee//hHpucDMepg5Z2RG79UUiqMD3d89x/+ln4zYlwHxlOWhZqiDH7bO0y/JX76mTq/to1MkytY2uGgUkOPv3vQZyAu/+Iv2Fvd6la3utU/Xd/ciDoH48Mdm7dvGe4ecP3mGlMpWLfBhJ6SE/OXX1ifP1PXVZM5r+lKXi7pOpZ+f0e/3+O7QUlN1jUEk8FaaRnTdCLNZ/J5olZzNTMAbZIJtgt0455wd48NAyGtvP7wZ93UCYqutIb+7h4/DErOmaevsGzDNbHFmYr3HtePclNXWkDUeuUjlnWi0mIJ7VekT27rTte0fKbhoOTubkrVIkGtMY54PnH6+BPL8RlbKwZL6HxD7cgcETYj/e6ObrfHtmmmKRXIbf3eU3PCdYFuv7sC5ktMmDVp0oOBbiDFRHw5KIaygexr1Zq+tLW0G0c2+x1hOzSXM5gik05ZZq03HaynhfX10LLla5vCBui8kqzWRLUo1hTTknqay73xN03XkaaJ5eWA83Lxm+Cp1RLnBVNKazoFInfdgAsOWiNaYtRBwLh28Emsx0OTaRT8EKQBLJWaVjXT3uLHDX630+tCyxNPWufXNeH6nm6/x3dNB1orFSOts9EBJuXM8vSFMp3wo/5eXYUaMt43s1rF379lfHwrU09LnDKhhxbXWVJm+vyR9emzHO+hkzu/QLAWuxmlfU5nvUauk4bWaJNQGvLMWkvoBYJ3vTYSpuGYSkqUtKhRz5k0RebjuTF1ewqaVoZhgxsHXalZoQfWudbwFuqkSM5LYtLyfGB5PVKK0GilKPwhxaTpaQjS9PaC8pekQ1JNmXiYm2Zczf9wf8+wvaNStBJ3ip/V58tRqLz88Q+cP/1MWlbWtZBixntLxhJzAmd5/N0H3vzmV3gvCoWStxptwQfs/g2pwPLzHzBp0e9GI1PkJMRaKSJzbO9EMciRuk7/mu/YW93qVre61T9R39yIvv/7v6d/fMQOGw0iqZDaRLAbyKmwPH8hPn2mLEszkmwwvVzupWRMcAxDR9gM+P09GK+hp20szVJI68Lrp4+8/vADkLn/7jsMcqQXIySQwRLGgbATPsgGTT5qW6/uvv+e0y8/K8pvO2oCWhLp8Crdn7XXRCDx0muDgrem2VpNmZo2seRImidynL6ucK2RQaRqBW99J/Vhaz5rIwPUnKA2raDrKKlyfvqF08efMKUoUQghlgyayIVhoL9/0Aq+OaBrexxcaMzHSjofSPMZrMVvd9CaDWMttg+QKykXlpcX8rJqrdsFcSObCalUrSS7ux3dftNiKxvGyFq5/ivQjSzHE9OnT9RFznbjLK5zWn+mSpnPaow6QeYvbvBaigwizmGHXjGd05n4esQPA37sMECcGtOViu+lJTXW4DqPC5IcGOtJa6RWTRZFSpiE2GoQ/W6zw15MUjW3WFGHHzaazqUmD/HKFa9Nz9ptRkHpGwFBmsEqZ7W1pHVhORzI0wnTJvqk3JriSI0rpVrcbsfm3XvcsGmbgKzPiet0eCv6Pc8//AmmBoy/IJsWuertMGJyZj6/4hvuzNmOUhLLPOv51aqp+/2O4fFBk+ScGsDfkJflq5lwXomTNNUhOEoB31l832Osa7IaI2h9Le0av2C5CqQFUy0Vy3I4kE4T3geM8cR1JZV61UeTM24zYBx6XVZl2VcsuRb84MkJhvs7Hv/u39NvdmIPN1uhMZeNQcd6eOLL7/+B+flFn51D46WaQkqaXrqu57u//y0Pv/4AWKxxVGMpyySn/rDB7t6Slkh8+glLvcbsXmKCazM7EgZcN0BeqQRYl78A6N/qVre61a3+reubG9Hxu1/pRpoiNTZenwuUJbJ+/Eg8nynrIl3lZnPF89QGfA/9SNh32Jwx4xb6EZNTM1ZY0jxz+Olnnv/wZ5bjUVNRY1jXH3n33Yc2TCz4fqDbb7TGayaKap3c5EnIIVME9K5omkZSxGipBdcFJbZUGRx85xsYX3pLY2SuwnsqKAf+cABTsU0TVysyrKSkJqXrmxveNgj5RTIgPmmtmlIuL1+EvTqd8CFgg266KUZSXAnjhs3jA+PDg5q4pusEIY4u07Y8nYiHF2qMArFbo8lPRWYlJ+PO8vos7WTOONOaptrMJFmvR7ffMTxsG+xfY1BrrSDx0yRZQ7VMzwfWl4Mawz403JVewzitQFFGeN83PqihYiRpWGdMUGM5P70oCapW8T77jrykK2qolkoYOrqGaTLNHIbz5FRJ0wtlWTHeUuLKejxichajtB+gG7Siz1ka0m7Aea/pl3VQrVbdxlBaE+qGnn7bMErQ3mNpK+Vkt8yHA5//039kPR7YPt4z7DbUYqUtTknZ5yHQv/0V492dNB6lIZKs1UGpZGpJLM8vnH/8AUoh9J0aSCMDXMWAs21lf8bmjB9HNZelshwXXOuyXRcY7veEcfjq3jdO9AFziciE5Xhgfj2T14V+HDXp9G1iPXzV4tZpUXPrg5iubUJYc8UYT44r0+tEzpngtLW4TJYNej/Xecb2DtsZ8qRELYwhptgm/fpc3P/mN9z/7m80wZ+lL71IcWh61vPHH/nyxz8Q55k0razLSkqZXArVWkqtjLstv/7v/gP79+8wWYi5khI1zkJF7e4wu7fE04ny8rPk6dbrcBB6mbty1MFl2CpMIU7S8jbt6AX2f6tb3epWt/q3r2/+hq0VmE5azxpDipHl0yfi8YBpmrUwDsK9oClbXiPOeYG/Q3PR90aryZy0posr89MLrz/+zPz0LFTQxbFeYXmdeO1eePPrD4TNTjflhqG5rPIppYHmK2k6kk4nNY59x4V/ibc4H5rpQjpEdzEL5dxA7NI6Ktt+Jc9nckqYYL4+ZtX0RINK8UNdaFDzlFrj4dpk0ZJTZH55ZnpWFKdWxeYqExQGy7B5fMP2/Xu6zbahnzKmNZY0Y0+eJ+L5QFo1cXaX/PMinnqphVJheX5h/vKMN5ep5gXYjn4/LG7bsX3YYp0iIXMRReDSyORlIZ5nlvNMWhac7whje6zLKnZdtdIPHj92iv6u4qQaIM8naTWDdKXx42dYkzBAQ4/xljyvQu00QkA3Km/c9t11OlszpPNMmibpZtOq6XE1kmx4j+vUAAvGHvHeireaCtXR1rxGzV4GrExs3f0j3XaExuRUwo6MRjhHWhdOP//I8aefyNNM8J48nZkphH7EYCgVwv07hncf1MymtWWqoyamVEqM7Vr/TD2f8MNArZnSUrlMra2BLlfeKbnK0e8DNSfyMuOcxdoOO4rl6vte128jMtScGmHCka5YphVnLdX6JtP2mKCEJ2P91YCmyWxLF8sZKNK1ek+KhfVwxmDoNyPUQpxXmbecrgED+N5jgyMtq97TxnQtLQij2wzsf/U92/fv1b6uUa9TSxiTNKBw/PQLLz/8ieUspFfOchIaq8Y4V9i/eeT7f/+3bB8epCl1QRPudQHvsZs7zO4N6XSkvPwiuoB1Oky7FqFqog47oceRYF2w/dDIEPo/X4nDt7rVrW51q3/r+uZGdHp5YdiMxPOZ9XQgn+XsNdbJINM1I0ptLvGc6boO328wvm83R93s8zyTlpXTp08cf/nIejxpnewUk1jRlNOFwO7NPePDPcPbN81day53CKjNpZuzwNp5pVK0FmzTyVqSjBjOyLXd2J22xQlSkSmiVUnrFehuvaXbjtSLtrFkGWBCwIROOjjbuIrWNVe8eJp5WYjzxHx8JbZmgFLxNlB8pZRIXqHbbNm+/57h/l7c0xxbeqicyxiB6cu6ks6vcpDbr5O6kmVIyjER54V4OlNLIYQWnfqXVAFrcMHS7beKOCyFMudmBtJrkGMmzTPr8UyalpbMkzFEvPdNU1vItVD7DrcdlcBTkiDhyjMlxURe5fxOcyKvM6VUuk4ufGolLYt+F+9wLhCGXklNDflEMyyt0yz3fIzUKi2fYkubc7wLml4npeSEvsddtKRVUbQyi8nFbbC4YUM3bhs6SCY0maQgZ2F+1pdnjj/9xPr6gnEGPwyAGl/rAoWK8QPjm7d0m42m7zXRTmLSGNZKijPL8ZX19Iop9ZrmJCNUJc3zNVkozZochq7D9A5j67W5NgYlWm2a2arF1OoQdImdLRQc8XRmPp6wxtJvNuQ1gjX4rpPEoW8sXGuxGcwwYILXJHctkES4yKWSXk+kedWU0Gj6mduBMSfpw6txxDViaiHl0mgXOgTVoveo3+3Yf/jAsN+3A0b+C16rPtd5XTj88jPnjx9ZzgvxrOjWnLJW9sbTj4Hdm0fe/+1vGfZ3AC2aVN9H7u4e028w/YZ0eCIfn/Xd4pQSZUInNFOcIQRMGCSdiEpuk6GqXMQ17fvmVre61a1u9deob25Ej3/+I+lur7hCY6XLDEIEuaFNryrKzW5ubGOb9q0ZX/K6spxOnD49cfr8meV4BvSFb42R9ssaus1If3/P9t0bxod7MRfT+lUnWUrTdCVyXIUxMrZNhlpcJ1xh6z50+H7QCj10bW1a9e824SypMTApmoJ4xVjirKZbpsjwYHxzWoe/WMNLr1eBuCyk+cz08kxe57bazFgahsYaRXBuRvzujvH+HnuB0xdFlZp2Y1ZqjowmOa6SGnSNZWmcmqZ1ocwraZrljEb52nm9uKnVqPjeE4aOMPZUI+akafpQY2nYpkQ8zSwvr5Q1XidUPgRc8JIK1sqXWnkZOz6NI6/BM1rLZi1sjGNvMm9LpS+GsiZKbElUXXdhw2viV1ujEhx+6PXnTglGtVbKPJPSCqkIx5QiphnPrPVQstbIIVwJCi4o7UdvvlbCF+QQRgYYcUE3LU7U6ODU+KEVKMvC/PLC+fmJeDpgTcV3amCkHdW/bdfTPTzQ7R8JXQ+l6QiNtKdUKKWwHo8sr8+UdZLkwYovWlsjqmuvyRJWHeJ88NLvxkUwdaP31A4DdhjEFrVOa3FjIEd9NhDCaTq8Qq507fMJQjr1QkLI6GYN1oiYYHuHaalpNIZsrZW8JtbzrGljRbnwtZLnRbGxGHLOOO8oJVLJpByv0bItR4sw9pr4v32n1/3yHjUEli6KwnI6cvz5J+bnJzFvSyGXquuuRY5u9zt2799w9+EtYdxhwiUeNAIW24+YcUM1jnR6oS5HsX/b95jRBQglyVQ4KHRDU9QBUyWnqO17puREPJ3+GV+pt7rVrW51q39OfXMj6p2jLHLBO+8pbe3rvMeFrpl05EA1l1WhlWkgLgvT8zOnp2eWl1el94jwQ85ylAdXGfZbxrs7No8P9Pt9u2lpVX7B3tQUtTKPa9OfAsZhvdEa1Hql4+Sk/O1OOCMTumZMMJh8SUIqlFUNqKIl9TuZSyZ8jLAWDO4aw2napEui1TYpqbDO55aGdCCuC3lNMhq1KaptOsWw3dLt7+g3WzVd0NKEmlHDfjUnlabHLW0CbJsEQBPXSJxm1sOJuqxqFJs7u+REWtTshM1AtxvxYzsslPa0nRr1mhMkvbzr8USaJjVKqEm3IbTJc2XB8P/sAv8XW/kThdfzieIdnfcM1rF1lvvg+fvQ8ZvzzHcZ3vXQGaUdXTiPCi7ocIPiMo0X7sjUIjZpXPVPqVeOaM1ZMgJjtfKFJonw19fXNR1oTYr0vExBjZN8wnW9MGHt0KTmMmgYlyNpmjl9+sT502dqWqWFdZdDiwgRpVT8Zsf44ftmJjN6DY3kFpdTV1raFPT4qpShdh3ndYGWsFRz0vR5noTNCv2VD5vXRTIOI7OWH7fYvpdBrjW65KKmqirqVJG5MxRNPi/OdOMclhao4KQ1vkxDsUifWtt1mBKlVtK8tCAAKCVhqiEvq0xuFlzXkXPCFtcm5Besmm2BDtKH+35g9/4D48Obdo2apiPJmuCWQl6VFT+9fCEdXjHtNTSl6vGNHm/39oG3v/6Ozf2dDpX2L9KWgtKQTDeQY4R4VI/bDXLCX7jCWfp20w8Y42RcymszdWnrcd22rAvL8cDy8vqv/qK91a1udatb/f+vb25Eu7vdVTNVqTgnQ4Pre7nNufhqJH6sVOISOT89c/jlo6ZsrTnEanKTs6I9t/d7du/esH24xw+jHLzGXbWGgsUbNSd5paQVuDRtbSrU3OrGKLHH2oFGvJY5wTZXctXk78KcpCg//avNmjaNLNRl0e84bnSTg2Zi4bq2S8vMejoxPT2xno9QFY/pmmYPJ8Zkt9vR7+8Jw6hpa8MCXVieGN3Ia4uorCVrfWhaw9sa+7Rm1tdX0ukkfWXKMgcZgyGTWrNnG86n2wz4TpOsmltqkVMaUDyfycui6M2sxtQCpa3+1SgrpefJGf73JfF/WM98cr5Nh6EsK8fzWW+BsXRd4I/A46bn15uRv6uV350n3p9O7IqQO24ziKjg2zSzOa3rMpOX5RpBWlsDqpQqMSpL0WTOD8N1QmcB13A/NZf2nJ2A7D60ia7iTu1fYJloK/tSIvPzq9bBz6/UXGRwcl4TY6Pm2fYj3f0bhsf3+HGj1/QCpTcGg6XkTDwdiKcjaZ2vhzPgmnNfrVXDPc0tC94RLnKRpoktjcXqu0AYO0V0tskuWSaiSzOXloW0iLnqh14TwpjJqWDNV4WjcU6xrk5bA2MvutKLgS3j+p6w2eL6M+dPn0nnkxpCDGme8V3A931LMitYkK71L7TRBjC1Mtw/snv/nXTPpmXFm0aaqJqypnnm+PEj8/FFwU/es8aVdYlNj2ywwfH44T2Pv/mefhgUUBAGHfLaNgQXKC7o8LZODd+kQ90lOrUuk972YactS+OqGizYBumnGcXWifVwIM7TNVnqVre61a1u9W9f324HbYaXkgSB32z3dIOYmcB1FQqGdV00Wfr8xPx6JC8yS3jr5EI1lRB6tpsNm8c3bO53Mjq1VV1tufTGOk2N4qLc5+sEtJHnL8u/tua8uKPNxYjQQOcUoYpybsk6OVJSm8i0BBylL+nxDZqguN2DmpcQrm55EzoMhTidmA+vrKcD8XwWjJ42+WwoHmMM/f19Y5huBP1ujaZ+h8vysgHyU2rZ9Y3X2EDjWGV9z4cT6/MreVqkyfyLhCdSm8r1PcN+Sz92mp6ZZtApwhFZ7yhxZTmciIcDpqDXq+qZ1GYCq6VKI7sZKM7yvzsd+T/mzGHSitk1iYNM0ULerylymicOxyMfQ+CPw8h/3O5423s+1IH/UDv+2z7w667Du7+IpYwzJMkPcktYyjGp0bGGHDPq/ivOe8IgSoGc/5pW2lq/pkcZRcL6rscPo5pUf9GItsMLQv8sry+cfvmF5fmzEqzQ1BDnG0mggHf0lwZ0u1WzkpphzV6kIIb1fCK+POmgVGlmoIbCaq9Rjonl8pkwltAPuK5T4mbRpD4XIbC63YDve63GG6Wg1rYdKIlaKnFZKKkoLtbUFnEKeIv33RXn5foeNwxf1/jV0MjzunaAsL+nu3vQkHEYMcOG5dMnli9fSOuKDZ5CZTkcNdmuVQzeUjDG4AZHzgkXOnYfPrC9mLeKUpGqdaKBlQrGMx+eOf3yM3k+N1qFJafMGiMxRgyVcbdh99179t991+QdTeNp0IQTfSbX45F4fMUFR/f4FuN6KFFGr5Qoi+JH3fYR2+t1uLrhaxXIzVgqhbjMrIcDaZ5lcOxvrvlb3epWt/pr1Td/w8aWEa/RkGGdzoTdvrm2K5TMOk8cfvyJ08dPaiCTIkFD55t2r+KGgfH+jvH+jjA2o4u5rNWbmSBrapnmEynKpGG90VrZGmncLtgYJ72qDb0a2dC3taU0hLUU8jKT09Ji/BqEv630S1za5EsYHdMaEON007xOXAHjOnIuLK9fmJ8+E+czOS5QKqELYL1MIbVegf1hu9fP44KmoZlahJvK9WtKU8ktd7tNjFwn4PZ6OHP69ESeF3FH25r7Mv3LJeOHns27R3FT4Sp9sM5o8mwUpRpPE/PzM2leMVUNW0mZVOvFLwLW0g2duJoh8H/ynv/YjzxiGOcz0zSR4no1UeWcMd7TbWX+WZeZ07xymheeDwd+GHp2/cj/px/4vzrDvy+Z/74U/j5lxpTJORIb8D2XrBVwBd/3OFOJtYrT2jkoqUkWLglFasRjTTgvTagdh0ZqkBv9YkSi0RgomRxXjh8/cvrpJ9I0X8AEamSdAVPEXt3t2H7/K7qHt1jfwboKE2YdmAaNz4np6RPr50+YWoXUqhWM0q/IWYSIeWZ+FUnAtUYRYzQBzklpWBXC2NNte/yFYmDr1fhj0AQ5TSvpPKvn3GywzpPOZ+lMG9/VWDDFNnOeb7+XUGc4o7X3KiZs//iO7u5eh7Gcgcjm/oFhGDh0HdOXz6yvr8ynMzYEvLdNB0uD31tqSXTjyN1vf8fm8VFbg5qvnzUun4KSef3lz5w+fdZjtS1LWhdyzJSYCd7R70Yefv1rhv0dtpcsRWlJKPLTSO+6vD4z/fQDlEq0hpQzw/1b/NCL7TqdKBj83VtJH5reulYFQ+hnAaWwHl5Zj0fyujbJx9cUr1vd6la3utW/fX171vxpauthaebW1wN+u2fY3xEPr5w//cL09IX1NFGypmkGQzd0WGexIbB9+8j45g1hGBuovWm3vNe/jSWvi9aaixoznJUOL9X/YtplnbSpxndtktkavXVprvMqzuT5SC2Kj3QuUJ0GQel0Yv7yirWOzbsHrDXSYPqvxobrf/CBgmV5/qws8HmGKoe2IhkLOVXIhX6/Z/PukX5zJ2h+kamjDfSuJqRcpEktOZLnVcYqK+NQAax1LEtm+vQL6/OBWuVSrjWTSxbjsBQIns27twz3d4Tg1aRV06a64PxAzZXldGL5+ESZV6yxbd3YGt6GsMppwY0jQ8MCWQN/sB3/t8f3fGju8jkuHM8Tx+nI+XRiLkdiPFPmhZjzFfTfeS+OaCmcThPH48RHZ/nzMPA/bkb+z97xt97xP1D5b1PhuwomKkqzILi8Aapx+KGTTKNUarVSXBiLc+K6Qhvu2UD/8KiJ6SUIoBSwFVMKFMVqTl+e+Pz7fyRNZ4H3vcV17QDS4jBtCAyP7xjffaewAAzEBje3XtcchjhNTJ9+pMxnTS2z4mRlqjKwzJSYmV4OzIczphT6fsB2QSasqHV9zlmPud/RbUZdLJdpam0XYpYrPJ4X5icxXW0XpCduOlU3dI3w0CQinUIBalzJU8NtbXealCdFlvaP7/D92KgBBUwBpxW67wd2Hz4wPX/hfDphraUbtAURag19doxh8+aRu7/5O8Jme9Wu1ku0bzNx5ZR5/sM/cvr0kdB1YBxxXkkpcp4WTIF+CNx/eMfdr39FGEe93l0Q57fQYnQtpcL69IX49Ek58ReXfopMn3+RhMPKCGl395p65qjGMkaRAbK00NTCejqyvL5S5oXqwHY9tUlUbnWrW93qVn+d+vadU6kyuBRhUmouvP7pTxycI50OMjnE3G5Omnw4Z7HeM755w+7DB/rN5jpdBK5rNaqmT/F0kFmGi7tVN7LqLGZUFr31cq1fOJ0UwOnva0WvVXeaTqTpTE2p5bMbSpypsYL1pOOMCx2bDx/wXtnwOE2oNDGVuaOU2prsz8TDAeccppbr5LCWQo6FbhjYvXtPf3+P8f1XqYJtzTYyxOScwFttRlcBv63z4Hs1AblQUmY+vLC+HllPM6UUuqHDeUNaV/1o7xge7xnu9zIU5UyeJun+QqBMEbcdiPPK+emV9eUAOQtjY5oarg+ULO2o7xz9/VvcIDOaqbAcjvxvy4n/93niu7ffMQwdu37Drt+Q9ne8nk+87g6cT0fm04kLCivOC7WmZtDqrvrbXAvLtDAtCy/DwE/O8//a7vjwds9/mCb+V/PM3znPYJuDPRdp+EzGkDGuxxRPNaU5v6027AbC/o7h4YEQQgOwt4us89huwHhHns98+Yff8/LHP0tfGKStDUNH6LSGz1HN2f43f0O3v1ckZy2wzkCbcFppiJcvn1mfPkmnahwlivVpvVOCVVopMTKfzuS1KD7W9YAhxYxBjx3XlW7s6e93ioQtbXWu1FhdZxj9rKfPxOMZ33dNxqIDl6odeCwtjaq/OsS5EhQsZZoopTL++ncMj++o80mYsxZhqkOTrvH5eODLf/ofiYcj42ZzkV1fdaU2OHwf2H33Hftf/07NeEmQUuOy0pLTPNPxyJd//M+k0xHvbTNlReK8cDqdqNYxbLbc/fo9d7/+Ht8P4DtMN3I5NNWaxQsthfnTT8TXJ4i5/b0O00InyroIuxU6Ng/3uBKBoPCLHKlpvhq+SsosxxfSos8WxmFLpa6ZnFZSO+zc6la3utWt/u3rmxvRUgumqPFKURrLMp0absg2zVnBhUvWNmweH7j79a/o93eaBrY1qb7rHQZLOp2I01nGnIuBpJQWu1gxXmYfG7xy6W2bMlat3o1GHlTnBLQ/PktzFjy+V/55KZUcmzPWOMq80O13zZSxacPU1jheDCMxMj194fzpJ9b5BFWaQyrUKLRNMZmw3XP33Rs29/dtymiuGdkUJb1UKmVdKFlrUGJqqUQGU1qDZYVcml5fWA8nTFLmuLLEwRi56EsF0wW2j3f0d3tB3Bc5sf1maE22nu/pyxPnL0+AsEg5Jupa8ENPtxulxzvP9Nue4eFeOkMqcZrJLwc+lcofQ8fpdOYfj/+Ju/sH3r55Sxc6rLU87u/YDiMvw8B5uyXOC9PxKCxPVqNVYsR3mlCu80LfD3RDT5kn5h9+5GmNLL/+nuff/Yb/75v3/Pta+F+cz/zd8zPDesK4NlEu9YoXcg12X3PF9j3942UKanTdtMbfeI9pCVXnT5/5/A//menphS4EKDLWbO62YCtp0bRw8/1v2f7qd3otaqGuSv0x1mtSaAx5XTn//CP59IJzcvzndSalpEbfahI8n2bm1wPeO/rNBusDJWWhs6ym+hVDt98Sthtc3/TW4su3Zi9hvEIGpucX0nmWZOEyJXauJQXVhtwyTSJhqEnBB7V1p74L+hx3I7vf/DvC0MM6Sc7CJZmMhkNKHH/+kdcf/gRZCK4aE9ZATtJc+2Dx48D97/4d2/ffq8mdJ12zf7FWqMZx+vLE53/8z5RlJrQpbV4Tec0s80LwHd12w8Nvv+f+V9+LUOHVbJMaIQPEby2G808/kl6fmrazYqzkQfl1kcGvVlw/sHknZJQwakm4tayNAuiwM3/5fOWh0jTK1RhN4OOK323/pd+vt7rVrW51q/9Kfftqfk1y+8aVuEwyihRFaBojqLvvPL7v8OOG3fv3jPf3mmw2U4E2jBVyJcfIej6RJ2VM18sDtYbQ9R7bBZkFnKY7JrSVYIy6SdnLKi5RzyfifIaSscOg9VsqpCWSllkr2F4Nkb/bYPteblkJKfXYzlEwLM9PTL/8oIQmKj700uhVo7zuZcV1HfcfPrB581YGpjb1E4/SXDEwtRTyfFZn4cL1cQwCrRvrFPt4XJk+fyEvZ6jCOjkDXZvUlayEm827O8bdVqaPdZWpIwTc0F+JONkEptcvpNORC1EoRyGqrDOUklmXGRc8++/fYCq4To1cPp8phxPeOf5xOzBj6FOiFMPr6zPzdOLx8S3b7RbvAsF3vLt/yymceTUvOOeJy8J8PCqRqe/I64IpldDQSj4H7h7fsf3+t5hVCTzBdsRU+b+XzP9jHPmfPb7hf/38xH/z84/kpKxyaw2Erq2bLWbbM9w/yNDTkGGC0xts8FRrSNOJ1x9/4vVPP0DKdA0VFYaOfr/BeMN6OuM3W3a/+g3D43uMlY6QeoGa066zTDwdmT/9QomxoZYkyail4nxoEszC9PzMel7oQk/oO6xx5BhJa2yNUSZT6e82hH5Q8xMLJniZ11okpimFNMkQRy6EzYjru6YXBRs8bhgo0wxdVv47QNJBQM+tUI3iTcPDGzbf/1YGvLhQfUeNq2JSJYomrSuvP/7A6ZefMSk3sH3R9gGxR13XMdzds//VbxnevNdrP58gx+bul36zFMPh5595/uMfIC4Eb7HGNs6t5AfDTkSAuw8fuP/ug8xlxkpXatRAUpUDH2Nk/vyR9PoESSlSxvvmPUvULILA+PYdmzdvpP01Vt8dNX9FcQ2Ouq4sXz4rHhcdIEp7j3zXN8xVoFxCOm51q1vd6lb/5vXNjei6ztI2pkJJFYtRbGABvGnQ6nuG+3uGuzu5qhu7j0sWfFyIxwNpTVSLbkQN3n4BwuMUeehDwDnfjEjdVS+njGjxMMu6kJZZNxgnvqS1clPXnMjzyno4qZEdBvwwSgPqQ1t9Rt2gG0Q9nY9MX35heX6iJO1FDRVToJRMPM+4LrD7/nu2b98Sxm2LGaVpBtHv28D0pbFAzQWqDkBRnGOt5JyJ88r05Yn4crxq0WpNUCupNeW+HwjbgW6/J4wdNQqAXmrFjkNzxhdKgdPTM9PHLzgLYew0XctFhpJe2kPjDONuw7jfYXwgp8Q6n6nTQl2joPn9wH9aVo7rStf39N1I9oWcVj59/JnT68j941s2my2dC2zHLWM/cDgfeH59xTnPMk/ENeK6XhGX60zoerJzLDkzGNhtd+R5YjofWfuOTGUu8Knv8S1hqHYd1ltKabGuztLd3dON268SDd8OFUZNTI4r06cvvP74E9PLi5znxmKompRbWE5HrHds3r5n+92vcKMmX2U9g3E67KR4NRTNn34mn06SnvSDJpZx1dTSSW6RlpX1dCYvkc53dGOPC0FHrVKFOUoRP/b093vcZtRquRnP6hqVIJWzrsnTmRITfuzxo6OsLaq1SRPEhk04atNMt4bLmvY5yJTG2Rw+fMfw7j3WCIVW1/XK6L0cFJfjK19+/0emT5+l0c31yga1zuC8xfYd49u37H/9W30GSpJ+tYUG4APVOPK68vrjnzj8+GecddhBiUZ5WbnGzhtDP2zYvHvL/sMHyUycsF61XprQKi3p8cj69FlSBOuh02ugaWeVIc9Ztt99x3h/ryjPYrWNsbmFa2gKndcz88dfyPN0/e/Kusgc6SyYih87cq3aONzqVre61a3+KvXtE9GUuOCSvHPiI3olzGzfvmXzcEcYN4ovBGFmaoNDp9JSew7Eef7q/m2MSozyy60TOP6SG/61eavNdVup1VCjQOB5mXUzCw0+3zR1BivNnimMj29kvOn7hl5S5KCaXiUaxfOJ+ctn4uGpsTZtowvqblmLjEmbt28ZHx/pNnuMVbymED5OyS6lUK0mwCUnqrGNDYkmoEUrw1IgTpHpyxfWw5E8z9KJWk3dSpGez/Ud/X5Lv9tq9WwtpSSqATv22CYDqCWzvB6Ynw7kZaVzlmotaS3YSpMuGGxnGXYj3diDdaRosHWVMWxNTZMJplTWaeIJTaWWJbLWWVMiK0PPeZ5Zfv6Bx7fv2O3uMMYSnGe7vSOVysvhhdCP5FKYjge9Vt4xHQ7cdQP9bs/Pz098bprVmDN953lJIgP8d0+f+NvTSZdcruRYMcERhp7hTrxZLk3oxUziA5TM8vrC4U9/5vDTj5CKdL3Otn+kIawYhrs9u+9+zfD4Rj8jZ2qOTdMoc1YphXU6sb58hlSwfXeVjWiS39b1Wa74eJJpKQwD1ggHlnNrgpwjbEa54jcDdhilMmmoLwUMyGGfl5U4T5JcXOI3S0ZvicMGLxNfo0qYJgeojbhAypqk14Lb7Bje/4ru7kEmt1pgmQTEbya/EhPHz5/5/A9/YDmdCMG2100u9JwywXj8ZsPuN79l11bx5ChdaUXkC99TK6zHIy9//hPTl08iBHSdmvRJLOFLxGl/f8fDb35Fv9tL0uGsGsNq2gRThrXl9Zn16aM2AdVoq2DFba21Um0l9G1CHoRsMl6QeyHRkMGpJNI0sTx9piyzooR9IK3xyo+txkDw5MZt9TeO6K1udatb/dXqmxtRa7/GFtogQPv4cN8as63WgQ3RZNoNuizL1cGb1gVKxg29JnSNOaqGVjB666zWm75lygMo3kcNXlrJy0yazwKdt6hCJQ9ZbGgrW6ubdH8/Yr20oxf8zYWXWVJinU5Mz0+k8xFTWuSkdYr0rLXFcfZ02w399k7NT5MD6KnJ6KMmNKmBtEqtwQVFaF54oKW2LPEz88sL6+tJj5G1Kqw5a9JjLLYf8JuRYb/RWtf7xpo0OPqWUiStYT7PpNOJdJ4wtEQdIBUaC8hie08/doShU8JP1bTs0386MN5X+kev3HATZdYphdT3LCHgYmY5TzJtJOGl+s2GfnfHcj7y+dNHYkqM2z05aLU7jhsy8OX5ieo8xgemp88wDBRr8CkyOMeXedLqk4INHfl84rCe+Z87x//SdfS1ssaIqY4wBLr9jn67UcRnbS61FluJEXD99PNPvP74A+lwliGrGdUuEZimTYQ3333P/te/1RoYdIjACvaOctBTjMTXJ/L50BonR10VA3uJFa1U1nlhnVY51b3SwGzo2pS6XJvgsOlwwWOMFz6otI1A01eXkgX0nxeFCziP7X0D95dm/mpT4dZQtsiBa+IWJZPWCEW4rv7hkf7tO1w3UPOqpizn5mjXqnpdV55//JHDDz+xnGdNTBOkigD41hC2PZv7B/a//R3j++907V51156WKkAtlfOnj5x++pn1fMb70HisEJckeYxTM7172/igQy/GaOMG15YZj7EULNPHn0mnJ5zzXBLIAGmmo0IfwjAw3N3h+17NeejAS0eLowVeFeLhwPzy2jYwFnBCUAG266ipyIC13UHXGKRT/Od8p97qVre61a3+GfXNjahu6o6+RXAO9/eEzbYxMrmmvMjtnEjrItf6BTIO0o0ZcUCtD9jmgjcuNJi9a71iS1RqLuASF0padZMqWROgK7amSCPpO8DqxuyajrAZmCBTq8WkSlxn1tOB+XAgTmc5npu7v4K0dRZC19NtNgz7HWFQCpC0dlaO4mYfVvpPS2hxAuqDplxkGWcKkKaF+fmF+PpCms76O0ZMU9OiGF3f0d/f093f47yhrmszoazUpOx3itb667KSjmeIsU2mO8q6Nsu0wxfpB8NmwPUe16aGJYn9WdbIy58j0+fA2/8mY3yixIjrPKHvOLnAYh3eGGp0nCbBwUuMxNdXht0eF3rSeuZwfNHkb9RreQ0X6ALn4yvFWpKzLK+v5C4w18LaDxzmmZrEdLR+ZSqZ97Xwvwkdv9l4rHGEfsSPI8Nu91Xu0ZJyaNdUjpoun37+mfn5BQyEIeiQUGoLUTDSwjbGprWl6Twv6C97vU5LSsTTkXh8gbIqQSplSgOkG/v/Y+/PYm5b0/0+6Pe2Y4zZfd+3ut3X3rX3qdPYPj62QxI7smM7sZ1YGJwgUEhsEBIRdnLDRSS4QBEXXHCBQOYCoYgLJJDgik5CsiJAKEIJwmAIET72aard7eq+ZnZjjLfl4nnnXJXYiVbFdU6d45rP0a46tfZa65vNmHM87/P8/7+/IYeZNM+Ew0ScBYnlvD8HEyQlDa22GuMsbilxpjVnWSO31Cb5fEiUaTwciYdRNIrO4PsFylpKaRNY34nZJsjnAKXAuzOVQFVNSUXkyMs1/c013Wol6+sYZEvRghnkupqZ9iP3X33N7uVLtNZYZ1oDnQWGr6C/XrN4+oTV42e49UYOAbHpNpFpLNoQx4nDq+ccnz+HUjBNLqEVTIeRWhJ26HHLJcunTxmuHolhq003aVsFpeVAkKaR8eVz8m7bDpJaDlZaU8KpYVX49ZphvRF4vtbowYs7/vS9pA05BkkjOx6gbTqUlim1TExbtG8HfrXErddUY0nTSAiXRvRSl7rUpX6n6q0b0cWTxwxXG/xyjR0GtJP1rqLIDQSBkafjgTRPZ5blGfWiOKcOKSuNo26Z2UqZN/GFJwRTyc1p3hyzOVHriecn2tQ0TjJp6gasc00WUNvj4s2aUmvRQW7vZcV3PIj7eikrz5oKeYrUKhGJfrnCDQt839Ke9CmRpzmKqzTbirbmbM7lkzFLAP8yLZ2mA/N2S9gdSdMsfE8UpWlJlZKJcLdZ0W3WMgFtcaTVin41Pmxb1rohhEhKmRKj4B69A1RrqGUypboOYy229zJJRSgEJcSWH67AWOYwctwXck7cfKJxi5ZslQqhJHJnSDWjOotfL8gpk0ombHfsX73GOEd/vaaonitt2B332M5jtCWVQlGKDOyPR2LOjMcjpfSUcWaXMyEnyQjXSH55Sfwx7fgnHvd0SmH7AbtYCOPTuAaRFzkCLaVqvLtj+/XXjK/vBBTvZHpKRTLGjVx3SmuMVVjXpr/jzPjNl9j1Nf2jp2gtJrM4HmQKGt7gfapSckjSsqrPUyQejvI+pIZlcl6MYrlijJKMeq2xix6/WmD7DoBamrNeiZGIWkjTTHjYEQ/H5qjXaD9Aa1Q1MjXN4yxykfaYlBeZhKotkSkmKpruyTv0T55g+gHVIi9rmttUWBz0aZp4+Oprti9eE4+jrPmLrOkbPw1tDN3VNdeffkK/ucag5LOu9dlApKxDOc94f8/uR58TjjuMBYykY2kl2K5KxXSO4fqa1dOnuM11+8w3416KYjR0glgKhz3z6xeU40HiWo1pm4YWwkDFaI/rO1zfY/oWgUpt0grT9L0w7vbc/+hzagz011d45ygxoZwXE18IaGWwQ0+3XmK8k22L0phhgW2Hy0td6lKXutRPv966Eb35+BNZq+mTm1VuWtLkBFIYBfsTBYOi2pqeXKlKjBS272X6qSVLXilNDiPaK1CurdkLeZoo8yjMwNPPKbTUoUJNSX6OUrh+iesX4H37vQg2qYLShlQT4+1rpvs7ahTTgW454rJ+nSAXFIZ+c8Xi5gbTScqSbrGKMuktZw1eyVHWm63BESNKaqIEMWCkmDm+es18d0+J4fz3qSJSAqXEYW2XHf1miVsspQHPSfShvgPn5GdpTTgepcctYpxRyOq1nPLjtbArTe8wrdlSbWJ7noLGJBMga5ge9uwfDmg3oF+C1pFHv2TRVbLDTQVdK5lKTJmiFSknjncPxO2B0mJYUy0MTwy7eUI7y36ecNog5M8qjeg0UUIihETOR8qcyKFNuHtxsdNZ/oCCf/7ZO7zboO7WesFzGSPNYC3S8FtLmmcOL16w+/o5aRpFC2oN1suksYQkE0nvZCrZWLGnyXxNmRQTqMqswa0fUeaJdNy1iE5p3sVNbdt7k0nTRJmjmNlyEW4p8ppplJjsrEF3Fn+1kvcRzp8J7aw0oDlTMky7LalNQWvJGKtwC2lclUYOO7kI71XLoY3anOstiKCWLFgvaxne+UC0oE4mwiXOcohrByO0YTzsuf3e9xnvHshVYlRrlcNfVUoIE86yevcdrj/+mG6xbI2zmJIo0swq7Sgoji9fsPv8R4T7LbYzKGvJMZPjGxqGqgXjevz1Y9xy06gXRugEQZpk5TtKhfnulrjbksYRZUTDia7nBr40WL9frUW/2eKAsVb03O3zCJXD7R2vfvv7jPcPGKOZDxN+vaJfdFigzBMKOTD011ftYIccJHU71NbLRPRSl7rUpX6n6q0bUTssW/JKlnWXghwm8mEvzVKtErtYmg5PST62ckZSjZxDW9eW7kpuRIDphjMgPM+BeDwITsbKaq02e+3pBp7Ho0DIFwOmX2L6hdx0z3nrsirMtXJ88ZL9N9+QpoNk3fe95GWnRM6RMIo7evnohuHRYzGYaLmRoi2cJjVVVvIlBjGnoFBemnJVY2MPVsE/ZdHIxe2RGrNsTVvCUklRmiPjsQtPt+5lamk9VHHtVhT0iqpExzo9bJkf9k1XqylFWKsS/yjax6oUdvDYvhOOa5S1ZaG0law0Lso5wjgS7vZM+5nt7kA3gO16Hn6Q0P7IzacLcsnoeaJTmuwMqRZyrmRjoXOUwZPHmTJnDvdbzGbNy4fXvPveBxz2Y0uQargupZlShHkmpkydZgixvV8Rta2UwfHYLPgXnjzhj3/4PsNyKZNSVDOpmTfNtvWM2y333/8+4+0d1hv8IHpcQUNWdDOwUaqs4b3Ev9Y2JZULS4IOtDHEw5Y0jVjnpCkzgvahZJSV6V8ulTiOxCnID8oZ3TJRtRaEUC2ChTK9xy46SepqOlBt5GCWRY1Imkfmw5E0BXJIcnjohQ5gvBf0UUri4nYObRS6yDWge49WSMpTEUOSXW4Y3n0ft1w3+P1MnWdUkfAJClAUuxfPefXDH5FGMQ0aI5NgrVRLLFX4xcDmow9Zv/+haI5LkcNCbXIAY1BGkqHuv/iC8dVzyiwSC2ohhSzXS5QDjNKiYbXaML1+CaWweO8jVIwQ5zPwPqfI+Oolcb9rLn1Z2ZvBQ82iI27vS7dc4/qhDXCbyc5oQWAhW4r97S0vfuO7pP0BozQlQ9iNzIeJaeEZrq7ovMat1wzXN6KHbYfZipLGdp55w5a71KUudalL/bTr7TWixgp0HjHKhMOWvBcTh8QMtqZRSz6z7T3KyApepp+ydq8hoPoB2uqrak067klHyXcGuQGRxZWsrZWkoJJIhwPOd7jra5QTbamyXhqGLM1x1Yrj/T3bL79iun/AaIVtPNJaMvHQXOIouvWazbvv4xaLZigx4tw9Oagb3zTOc1vF17MOTbiiYnhQ1pFrYnx1y+HFc9Fa2k6mNdpSSiSniKLi1iuGJ4+x3jSotpJJZ5zJ84jpRV4Q9geOd/dilGi55aW0TPfON8dwQXsrTajRgEYbR5qj4J1KkQZg0ZNCZN5tieOMM4YYEy/vH1hNGbWM2KBJvx4oTPSbTE2Jx8MSjMEYi6rSSOnOkW4jabunIE5ttX3ArnpCCszzLJpVFL3vmWNgjgE9HikpiaY1RtH55UTVCrtY8Y+tlvyL3/42m9WaYmRlW5sEQ6csLuYKDz/8EbvPv2A+HnHenZmcJWXinHCDGIJojbusa+VQo1KU98to7Goth5JSULR1b2rs18rZcV1SIBxHwn5s13iTX1TQtuG2SsY7g14u0IsO03XSpCrAi6ZU9JQVKIwP9+Q5kOdIjBHnHc45lJWJaVXC8gzThB/82ZVvUE3fqikpiiPNebonT+mfPEUZ0ajWhoiiiFEQ6ykx8PD8S+6//JJwHIVQoaXh0trinBHfVz9w9cnHrN59V54DharaIU8r0B5QxOORhy+/Yrq7lwNoaoB4BJeUo2TIG2NaNn2H8RZS4vj1V4TdnsU779IvF6AN4bhnfP2CfBxFW22dTEOdRVtDSYUcAyUFuq7HNLOjrOrbd8nhKMY1a7n//Etef+8HlBDl+6QWTK7nw9G8mwhj4Nl3vs3ynXdkSg3tsybbF0msqmh/Wc1f6lKXutTvVL11I1rzTEUT9gfmu1ekGLGLQSZwp9xzrZvL22CdR1vftKIyAa1VohnFIKLJKRAaUFppAUqrk7vBaFmTKYUqBV00w+Nnwri0thlWoKbAKd7z+PqWhy8/J2z3GKswRtJkUJpcUnPwg7++Zv3sGd1iLc1xrc1pLyku0mAqwjyR5qOs4dF06zVKG/l74gFlLAXDeHvH+PqWtNsJzkYZck3ifNaKkiS7fHh0zfBoIxMiTilAMmGi5ZtjLdPDlunuQaDfVda92gpVQHcOZTQpnIwfsvo11lOp5GbsQiFSCms5PuyJhxFdkX+0IsTK6+2Occ6kMNLlyuqhJ8TCs191LJaap9OMWiypFOYciHMgochGE0OkGkMpGTtHqrfMQZr8quS9rihu7+7JU4RZjCg0U5gQBhT18ZoP1gN/9aNv8a0nz8i1QhbdHoh+tirL/tVrXn3vB5Rpkk1+3+EWHm00KUVyLKJdtoo8B5xv/FlnpSEsGe1lKqxd1wDySSb9WpOn+ZzXrqxFdWJUGe8eiMcgqFpvMNZIslAt1KrQSNOMM9hloyrQpozGy3taJJ8+TxPT/X1LwgJlDV6L9ET1Bq0MtVbiLA2Qc5YyJ2yvyaVQrOhkS0jklNGLFYuPPsFvNqKJjgFO0ZWqipPdDcRp5tVvf5fDq1fCJPUWZx1QSCnjfFv3DwtuPv1UQhoEIgopvzElFUXVmuPrV9z/4PvEUUgNSskB1LnWNMcIVGwvMH/XdUIvKIU4i7EvH3Zsv38gv/8hdhiYX3wlnxNr5NCLUCtM78VYlUW7Omxu5HGdHPQly2ueJLVMK8OL3/oer777fTHo1YJSsso/4dNOOtLH3/6I6/ffP2t1ZZDfJqLz3KJEM+Gw/2l8117qUpe61KX+AfXWjej06gXhcKDME2iLMU4aKWveOM+dQyuDcQsUhTKO4mJdrMG6Bh9fS+b6uGe+f02a5raaBtu5M9ZGO4sA5bUkGw2uGVVaelHT8NUM037P/Q++x3h3izFG0p28lUYxi9Gp5ILpF2zefYfh5pGs0kuV+7WXKQ9plv+KmXm3peQkE6oiAPBJH+lvbiAGalWM2wO7r1/AOKGtRxVEf9jWeykEtNX0mxXDzQbXdTJVVhrtO8yiF+NHmCkUUoX5m9fUKNPMXArGOMzQodpkqLZpXLdeyRuTK9o54nEizzNVZXkPvCelRHh4oIQk4QM/xrPcj4H7w4G7eSTPC564gc5o8nPF7QrsL3ke7XeoqzWhZqKCKSfSPJOtIS976hQhJmKYIDsOMRE0TOOItZbd/pbDdocaA4yR2jUyQUjU3lIXnn7h+eevbvhnP/52ww+JCUYbi+4XxBR5/b3v8vD555jGZTXOtDhVaYSVNvill/Wy1jJd1PL/15zEjNJMNXIACGjtMMOAMop4GKVJMbrl1yfi4UjY7ikhAwbrDK63pBjJOQkeSWvs4LCbJabrIFdUqrL2X/YyNW+GmXgYme/vqMj01vY9RkOeA9pblLMScjBHiavMlRSiJMJOE8oYyjyy2x1w3cDw9DGLdz/ArVYy+UwRcmgHt5bH7joOL17y8u/+Xebtrl1PkmxUa8VYQ9c5aobu0Q2PPvsMPyxkw5Ak+QutZa2vFRXN/uvPuf3+D0hTkEZPK7Aa2zBPGdDOYzqB7UscqchY8ji1HtCgrLjz91/9CGutyCl8h/HSzFbAWE1tkhbtPN1yjaoZasO7tUhggR5IAtlXf+fXufvhF3Sd6E0laKuQWxOqWujFu7/4CZv33pOtxAnrVgrVWlStYGwLsTjIa3upS13qUpf6Ham3T1a6u2t8xE5uPq0pTKngnCQguWEpAPeSqM39W5WiZMHklFLI4wNlEoSKMY6qZeWnNbKSM7at9cVwo0+cR2EqCcsxTtQUmQ9Hdi9ecnz9ihpnFpuV6AjVKe+7YW+sZ/XkEcvHjyXlJhe52RphTJIFEp9zJO4PpDDL1FUhBh9pXyhhJM0LSsgcXr5iuns4m19yDDIZgmYKqbhlz+JmQ79Zyc2tCKy8VpnOKq2oUeDx8/ZIOk7UVJogQOH7QdJynCXOERUi3aITViKyVq21Eg4H0jijaFNkYzjuDk0zq9pqM8kqvRZqjIzzzC5MTCGxqJoVFl80vhpe/VZAucKTT+DZFPiqRFIMhHkS7WnJ1KGT5xIKoSGDDnFmTIEpJDyVcDyKuz/Ec99QxwmspnqHXvb8QWP5Vz79FFcLcZaDgHY9xTjun7/k9vvfR6fEYrU+N50KaapzFJe8tQatKrYb5FDRcsPLmZpgqdq2iFnQ1mP6HpRiftiBEu6n0qLTDfs9YX8UWWXVaG/x3kFKYkhqXMz+0Q3rD95He0eaJuLugLJifMEo4Wwi0/pwOFCjwPXtckUpYiKzQyeNV5HQB6WhVi1UhabfBKgxClS+7+mfPWX1rU8w1kp6UIoyyT9N140hK8vui8+5/+5vU8axxcQWtNJn6YwdLDnD5v0PuXr3HdGdliQpYSWLMck48B0Vxf6LL3j4/HNqLRLBCzKpb2lORckBwRjQpeCGRWOIVpk4pyRmK61aUyzg/xoitAQ14QBDbWlnJSXs+ho/LGGewHYttjSd8UsoRRiPPP+N3+L+q6/pvJe4jIaCS0mA9kpV3DDw7LNvs7q5RrXtBSc0lKryM7wnTzPT7WuhLpyDNS51qUtd6lI/7XrrRvQEXacWtHbQmk9tLX5YSFa5sTJZ0KpFDUJt08t0PFCmI6jSTE+iP9PWkGIQePywxK5WKGNk5XdKUKGZB2qhhEDYb9m9eMH+5Wt0LfSDh0FQRSVVSpWpk7GW4eaGxaPHGN+dHcZoWfmeknNyKYT9njwdhSDlelTLnhbHvqxiSyg8fP/70vSljNWGQsNTNde81hrbdwzXG4l37P0bTakSw0kNs2hPx5npbkua5jMqCArGy/RYGKSyqnaDpRt6zgD0JLSCjEQwGuepWhHSTN4FjGor4qZ3qyhyScI7rYqH+x3HGDgS2dmZYHrGDJiOEhLPf6vw2bXnTz078u9baQpQkEIkThMpyNq2trWmM5ppnDjOM1UpxnFiftjJ1Hyehdk+B6pRsPCw7HhsNP+V99/jF/ueVDO670E5xinw8jd+k+nFCzrvsE50u9Y7uZ5yRWuw3slzN6aZkjykIgafNj3VWktTqLVk1VsnmskCaXsvTagx1BxJoTBv96TjETHUOXGxW2lSlLeYorF+Qf/ohuHm5pycJTpaCU7IMVEnkYzYfiEmOW2Y9wchQsQAWviiaJEp5LE59RVvCAudoaRInsUwZ4aB1UcfM9w8QpdEzW2SRyPvpgwpSbLV57/F7osvKSlRq5jmfLuurJMJZDWOR599yvLJO2+mqoomq6ho31GVIey27J5/Q9ptRVaTC7YTA6LEnwqn1zlNqRL9q7RGI275nFLTj8t1VCn4RgaQrYoTCcNJkwoQI1VbuqtrbNc13ah8XcnU0kjjSGXaH/jm7/0Gh1ev8dZhjW2a39jMhXIeGTZrnn3nF1hcrd5oQs/VNLzOk1MihQm7Woq84ccg+pe61KUudamfbr19I5qFeYkVnaLpeqzrGpBeUlBEfiVO3tqc5OJyTTLd7AYoUW4QDaptuh7VEDduvZZkmtZ6nnmcSlHiRDwembZbDq9eM+32SPyhPyOlwhgozbm8uHnE4voGv1y05kVuNKrdvGqVlKg4j7LSLllYhMZIBOgJWF8LZZ4Ih5E4SYyoKhKfqKrCGrn5Zm0w/UB/vRb4ujXnn3nSnGon7vmcE/P2wLw9oKXlpTS9qDQ2YjyqGmmmN8vGA1WUXEjTKBrKWmVdnwspZ+I8o4rgqYCWMd8g51lma2kOYly533OMgWIqY5w5mJmu61CmR5WR493El79+4I++c80v3cDfytJ4zvc7ysOBbB1qak5pIKnKMcyEJPpOlapMCMcZYqJYyWKnl0PDorf88aHnj1thjho/kFJh++I5dz/6gjJOeCexp8oZtBciAYDpLM47rJEVL80MlMdATYIqwrbm09s2JW+JRNaiciY9PMjr45VcAyESxpkcMkoZnBMM1Pl6SQWcw1+tGZ49wS5EGiH6YoNSBb9cyup+ChhrhW9pLJSC7wdsPzDe3zM93KNSPr92OSZyKecDjZi+DblCGgPKKobHj9l8+C38egNxeqNnrKc/V2SKd9gxvnzB/LBtcZigjMF3XprICkpb3PUVN9/+hG61Ee1u2zjU9jiUEanA9PCa++99jzKPuG5AgVAwmtQmxdTS1poGvFYximktRjDdYnBRbTpv5dBgZAWvOi8z3yIHnZorJUZKLvRXK3n9YhRtsZbYVdGRS1zn+LDl9ns/YL57wBrb4jhPiDQxKloUfrXi8UcfsLhaSVOsxICJ0dQY5XDnPDVHCbpQNPnOf7RhvdSlLnWpS/006+2z5kvBrJYCfHadTJdKeTP9BFkTtmlKielsJFLWtmlpaU2R8CD1sEB1Ha7FJWpjZbJzjuKU9WWaZ6b7W/YvX5KD5KI7Y1FWsDgxZpSq6L5nuVmz2GxEO9ectTWXc652RSY4KQRymFGqyiS1CPZFeIuSX11ipIRIPByI0yz8US2N5yklCoDOsbjeMDx6JMk0IZCzQLJVkQSbEjVpNqI93B9lTdsmQIWCspJIVBt6yHiL7XvcIM1MRTiQeZ4pMctqXmlye7yUImaRU3KOkmlojo0jmmW9nkPAGc1+iowp0inLnCLbMGIwxBTxVVafL7/IrP+250/9k0/4f/WVQyyU2x364Ui5WaFDhN5TlGJOhZJHSIl6nNC5UseA2jW3OYA3MDi8VXyC5o89zOwXW+43O9iOTHf3THe3GKVwnafU2vSTptGDMrbzuEWP80IXEK5rJockzSYaZbVA8DsvjWfDLIGCEM4Hj+o9JRfG7a5NHTXaWOGAGt2W4vKfZtHTXV/jr9bYbmjmvHYAy+JSL41z6oeF6FiVblB94dFqpVjc3KCcY3zdTHqF84HFeEfNhhIjaQ7EWNB9x+ajD9l88BHGD9QcZKrb8FcoBaUSx4ntl19yePkCXaTFLbWKVro1gqfAhvW777N89z2MM6LJNYJSqyDcTGNJ08Tx1TccXj4nTROmQfCFherOk1whW0ja0Wk6q5VGGSXT75O4QIHuOtxi0bLpFcrI36NKIau2eWgEhBwi092dEAmWa4zv5REmeT9KSuxfv+b+R1+QpxG36AjHINpSI5NXbRTKO4ara9bPntAtBgHxK+C08RARqYReTCNhvxNtuDltMbhMRC91qUtd6new3t6sNAZcX1hvHqG1lht5kamDcDSLoGNyOk8R9KkBPa39UpTN/bDEdL3oTalyY9KGenLCNgh7PByIxwMlRFKaz6tybZQ0wkZcvMYPLG5u6K+v2hpVvZlmqMYjVS16dJ7JMaIoGCeImJJLWz0rUBXT96QQmG/vULlSirAfyanFESqhS1lDt17Rb1YCIHeCOFJGY00nq2sNuVTC4SjNTqmoIr7qmjLKCZNRgaCSvMF2VlKdWqTlqSnOs2SQK20ppZJjavfQxjws9dwM1CzO6jgF+X1tUi2jNE0slVAStihiKeziDKWQjWdlRWNXYubz37zjHWP4p36142+WhB6jvO9ZptXFGZQVvmmuCfZHjNak/QGOR+EwysUAqx7TOZ5q+NXtTH2+49+/G+l/+zlXzvL0amC1XsjKvdETbOdaOAJ0y5ag1dBV4naWRkI1F7oyoJ2RRtAa4b8WManULIlU1ELRWiag40wOUQ5GGMwJmp4yujEs/Wopsav9IDKHUs4MV06TTAR+ro3DOtcaHt3Sj0SeopDpvrD5ozRrOaMquM4LDaElfCnnWT29Zvn+hwyPHjfjf2wudS2TUxBu7d0d2y8/Z7y7paZ61jRqq3Feru+SC/76iqsP3mO4ftzMR605b82YMhJHO93ds/vqC/K4o8RETrJOV6piUOegMVmAVMGLGnlctIOBVprGSgLAdBJoIRNXOWBglYD9U2wreyj5lBpWKDEw3r4mjSMuPcIvV2jricc9x1ev2D3/hjyO58+Ask0S4K2guLRi+fQJm2fPcC2BrCLXv2rhBsr1VF0ID3ciOYnNua9Ni4jNssm41KUudalL/Y7U23/DVmkuDtsd60ePZEWmZDIoNw9ZFatTvJ46/Tlp4moK0NbX2kg0oTShwv9EaWloSyLud4TdVjA3RRz5bhjQVrN/KTfqUiVVafn4Ed1qgx16qKfm2JwbrqpakM08NTh9xXanfG658dWURc9mnZiuvBivwu7A+PK+OdUzuUrikPI93fUS33v80GGtk6cZ5YZaphntHKXAtD+QDqM4qq2RG3ARTV0J8txLrdihxy96yUJ3DWFTKjXNrcGXtKiqoJSm+2vPobb/LCmLiSclcgyEKcraUVUxRlUE/6MVIYiBIxdJR5pKxCsI2rKPMxbotIU5YH7zgT+rl3z5eOQ/CDOsFqggiKHqDFU3c0sSk1pJmbo7QAjSvAP4Ab1ZsNaKX8qVR59/w/dfH5h/9JpBa37hnWv6T99huVmKozoXoRDU5r/RggRTp/esZmpRnIzdtpekHmns9dlEprIwUasxYA15kjV8ilXCAQC0aEm1PsW4iuTBrpb0j65limdsY8uqRlJI1BAF+aRF46jE7SPIINMkA81WhrXEKXB89ZLwcCuTyDYR113XjGtRjH1dx/LdD1i++x52uZLrNshE/hQdixGD1Parrzh88w1xPMhnqn30/CCGv5wT1VhW7z1j9ewd/DDIzzpNBUsBc3KJF/bPn7P94Q9Ix4MA/xUYrVpyVKGS5RpWmjwFaSqNxIzKAUhkAlUbdKkoo9BeMFYln8Dzou+UjYMA90tKcl2X0kD9tUkPKvN2y7zbYRdr3GbD/HDLdH8vyDOrpems4JxwR2staO9YvvMOm3efybq+SXzASNPsnDTBMRIOe9J0pOQqTv1aSA2hZVw7TF/qUpe61KV+R+qtv2H9eoH2jun+DtsP9F1HjtMbaLZqZpEcWtPpAE0lk+NEDhPaeLph1SYncLYx50KtkTTPxOORPI2SBa1Uu+nJDclaR7/ZEMaZxfU1i0ePxAhycoO35BkRgInzOE6jTJ1oEYFaIgLLnIEWj2kNxgk6xhgr/9tY1h+8z3i3JY1BssONwz+6oV+vcENHmSdKiFRtmiFrIs0zrvOkVJiOI2ma0VluaMab5iLWlJjBVPTQ0W9WuL5DLEWiJy0tT76kKCk7tRLHWYa2RowgtT0XzvGnME8zcTyQ5kgtYIw6HxhyqeQq+r3DFFFKEqhyLcQCSVvGHKhK07uOznhKTeyOe1a/Bf/cLvPcVr5SYMeJsuyh8+JwThnGGXKh3D6IOz43keJqQN+s6JXifee4+c0v+ebz1xxCRqMo3vH84cjj2z1X1yt8Y6UabbBWYVsmeY4Zo5Q0H5xy5EUWovse5WXFfJqqn6ZZpj3GcDjIFDRmULZJLRQpJBkWtwQh33v6R9d0jx8LlunUZJ0iXVvMbEmBqq0YywBiM4PpJi1pa+BqLOP9A4dvvqKEuSVyAZQ24aRhqzJ+c8XyvY/orx/JxqBkao5NBws1y/saxpG773+P8dULapY4U0ntUpIQZoX1qrue1bvvCTHCmPPLoyonzj8gsbHbL79g+6MvqHEWukStpCyT0BwDxWi6dU+KkRKrUBqMRRvdNNWlUQ8cKSes9/i+bxNcUEphvEU1LmmdA2WWg0rOiZoEW1aao54iEhRVlVAbji9QD6/Jp2Su9u9luisJTiUlMopnn3zI8skTtNHi1qcdMjTShKJaktueiiSnKSUSl5JaQpxWVFvfpHFd6lKXutSlfur19hGfm400dDEyPTxgr68gTHITdi09pkj6CVVLUlBKYCq5OX8VAWUt/fpabh5JzC45JUlWmue2DisyRdGIGeMUoWktq2fvoK3DdV1raBtsG2kUlTGUIgaUEueTiV/WrbmtUaNMXlTnMd2AXyxbCo84rFWBmjJd1/H4O5/y+rvfw/UDw83mTeRhg9TnJFNPrWRdrLolIc7UMGONxnSeMM8UJTD5HKKgm6yhf/aIbrMW/iWQk/w7oQPMcjM0nvlwoIa2lrWa2tbilXpeEcdxZtzvCPNISUUiTTvbbuKZ3HSvSktDuj9KitUpPapwakorzjqu+g1eCaKn1MJ4DDx54fjTjzb823XLA5U6eGrvqDVBrNQ5oO62sB8bviijvEPdrLBW8yQXHv3mc/a/9YIak6xTgTln7g4zz+8P3Nzt6HrHZrPA904mw1nevxMOTGt1PjDIUFMoDKqAcpY6jYIE877hujJhexA4/RxQyop2kiZrUGKUMdbgFwPDoxv89UYmkE1vy2laeuJNVkk10ihUSVCEWVqNJEKJ1EIm5Yfnz9l98YUcxpzF9L69hxIhWvIMKPqbxwxP38MuNjKFy0E+c9q3BlQOTtP2nvvv/4D5QZLDqnZnnal1nhgiecwMN9dcf+tjus1GPgQ5v9FNaw0poYwm7nfsXnxDPB6E02nlIBAPB0oRI5wferqhpxSZZJ4MS1SZqp+IAQApJZSVcAuRyQhbVJv2ea21pVgpcsnyuVGn1X6WrYC15CAbjFwhZfls1HkkJ5GlaGPkgFiVmPlqJYXA01/4lPWTJ2JEKkKJODnslZbJdhpH5u1WprE1N/mHao9Fo5zCdC3dqT2vS13qUpe61E+/fgLXfMFoQ7eSm7tKCdX1YjgAKIk8BzEXpSMlTA29JLpPt+ipKMJxj+kGrO9kLTyNpONeDB/AeZWZIyXKhAVjMcslflhhXNciOKPcpE/uVqtR1hOmiTQexO2sBadUQxSkTjMXqVpxmw12WAiCRvg77Xm2CW/DzfjVkusP3mlRhV70a06MRTkEgalvrmW9FyNl3OL6Htt3lJyJMQkAoLR1n1J012uGm40gl7KstEsWbZ00ogKez22iq0oR1E97rjU1QxIKZWA67Dnc3ROnKCYn63Cdo5bKPAZiA+tb7zEtuSanen61pcRprJXGasd+Hhm0Zek8VhkG7Yhj4Y/c9dDt+b8+rnw9dLLyTgmmACHBw14G3UkOB2qzwC57rmLi/a92LH7jG+qczoa0UiqxFqaUefFw5NHtjutNz2rZAYZaLajmxq7CuFTagrVttS5SEDHEaYgB03eYYYBciIcjx9d3zPuDUAZUk47IHyWX3Aw4huF6w+LxI0zfEpJOsHOkiTtn1RuDcg0pdNJZKg1GJphYC74nHI9sf/QDptcvSfOMqg2DRaFk2vWrsauB5Xvvs9xcyd9XZdonT8/LtLTIWvvhqy/Z/vAH5HE+Q/tVrVQtqU9zCIScufngfW4++QTrfNOAamkwtT1PL5U1TA/3PHzxJaoKY9QPPaUUpu2WeBwxXcdyvcJ1njALDcD3C0n4Upp4HMkpY7SWLYZR2KHDL3qR6igtprHKGx12PfWjRVb0OYJxGGPFwFfbqj4XaapLRCtFiYkQm5RGVVTV5CQNsMoZ5Tzv/tInLB/dyOe5yoYB66iSO0qdJ9kYxCw83JTRzshhLGWRBFiN7iwYJdIE3/+k36uXutSlLnWpt6y3bkQ7qzCLJVpLtjPWNmi83DTzNJHCSDlp32zXsCwIp7HdWGqtHG9f0m2uKUcBsWvVkpQa+0+BNClK4RZLutUG3fUt7z7JyrNVVRqcI8ZAuPsaQz1njJcq7tsTS1NW/R1+tcL67pysdHJfnFac1XpqFF5p2O1EwtoctMpL7F+eg7BTu4E0T4IsygU7dKhaJe89Ss71YrM6TxsX12tcP1BzJYZjm/hCjUFu1M6Rc2XePjRXvaAMaaaqUmpbm8J8OHB8eGA6iL5NKYVRSlJucmUeZ0oudMtODFTO471jvzsQk4D6qZVSC1VVEvIYQ448Hq54f/OEq+U1GMfr+xeEODGFyHfyAuyBX78O/KabOagKIcPrBzFMOQ1ThvUCfb2kC4l3fnTL4ruvJeqzPa/a+jylIObMYQ68vNtzterw3nONwQ9gm7xAayO53y1aVCmL8v7sylbGYBZLlJHGcdrtGV/ekmZ5HbTRwrhECTA+S4ym7iz9o8f49fqMvlI5C+i8vUa1tuvDe5mwN4200pZalZiTakZ3EsW6f/mcu+99lzpNMnNWbaKq2rWdMjllhidXPPr2p/jlmjof5WDXoj5FECw66TjP3P3Wb3B8+ZLT8UEpMRiZNo3PLQnsnc8+Y/Phh2ilqGGWRrQamdC2Rhit2b98ze7rLzDWUI6pHfwqYQ6kkLH9gn41oFQlhRnv+kYkkElomWdI+TxZLoBbL7G+O5vNjHOiG27T+NqQaLUUOXSVijbufE0opYWrmoTvi1YYdNskFFRLtHLOkotwbKsCu1jw9Nuf0A2DTP7bz6fhs1SWyNlpvyOMowQatM+VHDCaYcsbdEvuMq6Tg4vtfoKv1J/zUuqNPwCg1P/Y33qpS13qUvATNKJutRFMU3OSqihg+JwT6Xgkx/mcFa+Mlj10RRyxhyArVSuTKFUh3t+hlT7HNVaQtX4qKGsxywVuGLB+ON/EaW5laLI9Lau9uN1T5lkCnxZL0VdOEyU1V3nn0N5juwHbL1ElQ4iy/lTqTXNrDFVr0nFHOu4pc2i6O42qGjDn3HnlB1IuzM+fo7JMitBKEmRQbcomIPZqPd1qgTWGWiJpf2gr8QbrL6kRZQzz7kA4HqWZBGk+K9RZjBmm95ScmXc7jvcPzGND1liDsbLSrLmQiiChhkUvJhwtN4icxCGecjl5iIX32iJGEwWjLcZYQqnspj29G3hy9ZQ5HNjPB2qE78TK+y+P/Np25NdXHb9tFccQSVZDKNSho+89T18eePrdF1zdS9Z9qTIRO9N+oMVrgtaaw5T40TdbKhLheYVGrxY43xJ82sHHnPi1WsmKth9k4pcjJWSm+y3TqzvhsD66EmbsGEhzwJSMMh5jwC0X9Dc32MUSVG3udiUHnNKmaLWA8uheomvJsjKu2gicqLSgBGOoqXD/ox+x+/zLsxNcKZnMaWSNrJTCLzrczQ03n3yK6ZYSnes76JZycdf2s3Ng3G558Xf+LsSAH3pySOQi0gatJId+mmf8csWzX/iM/uaxRJtWwSsBLUEsA9IU3v3wB+y//op+WDJuj2g0xijSOKGA5c0VSitSmNHG4DuB8pvOUaqizOG8ZdBO8GJ+WGBMi/K1BqoizaIbVlYiM2XSmaE06oBu8o8W7VrbBFppcRnWMFNLJeeMQb4vAHKubTVv8TfXPP3sU6xSzZTWyWcqJ6AZGI0mh0wMAdsNxCmIEYl8boK1s7J5oGK6AdcPb6QZl/pPLGU02js++pf/DI//xB84//r/99/4t6gxSWDDpS51qUv9A+oncM1XuVmWhLKWiiaNe+btVoDWVvLnldGyoj9FWuYMuTRXsW18xubgbm7bEgO5Ad3NYolbbXBDm1goJUaNlKClpKA1pUI47MjjUVauzknyijgfJIbQO7AW0/f4QRKbaM55jDtPQTBGkn/CTBqPjQCArHtrm4aaxuhsmdvzdkc+HhomSMv0E1rTZ7ANjq+sFa5hDIRJ8FamBQBQJFpUGUPOhfH2jhIixrqWPgUpF4l2NBptLeEwMj7sJFIyRqBirTjFa6nkIAxE631zj0sDWqkYa+kWA4fXB+bQWKRUSpV/shItrkZhjBh8SoGQArWFEiz8UlBdY6GYwtM88iePM/8Za9jlwj4XjjFzN4108y3DMbbsbtXQRdKcZfklrIJl7xmcYeEMVitSTGy3R3abI5tHm+bolimlOmuShfNoOkmbKvMEMUh86es74jhjvMctBrQXoL0qsDscUV2Pc5puNTA8foxxg8ghZPR9HlvWlM+8UG0NxFmMQ1Yg+VTVMEoV3XXM48z+yx8Qtg+S7EPDCokzCa2MyAmMY/3B+yw/+FAy4WOiphnVLaDmFuQgeuvbH3yP2+9/H28MfrUQrbHVGCf57XGeyaWyfOcZjz/+BN8PMgVFnPAy8pexcy2FMAfufvBd5ttblDWEdthCQVHgNqtm4MrkHFAUtBbwu/YiwykxyGHUNOOTAjcspLFTWnS6tUrowunwWOsZn6ZKlY+1t00Xjhj0cm7NapYmutICJrIc4uSZEFsMrjaOxc0NN9/6Ftb6RivQ1BJFNnF6H2MgT4E4z4JZq+B63+KHpRHVnZcEL6UwxmF8J+v9nM/v36X+/lJG4x+tuf5j3+Gj/9I//ff9+z/yP/rrlBD5O//d/4Ug+e72P4NHealLXer3cr11I3rCAGE8ORfSvCOnIA5zZREX6kwJkVIq2juMEzOJ0kbYhqcEF6PQDfWSUpJpUdfjlyvssEB7f+Y1SomXXBKWImmaSNMoaz1rpTksmTweZILZdSgnNxO7WGLcKa1JCc+ySFoSCMalVkjHHWUeqW31V2t9MwjJBWqiGEOaAvGwpabYzBeVnCvKWTQSI1mMxSxXON9R5gPpeBSkUUnos1lEUbU0PdPDjjge0VW1xBrb2I+iS3Re9J6H13fMxwOlNONVS6opgCoSOWq9Rzsr8ZZtzQkV6zsxLxnDFBIx5jYBrGQgi4hPWn2lKFRSyRhTm6TCoIu43Dvr2bAgTZloE9lHfMispkg+Bo67iauG7lFKJsr6tHo1GqsUzigW3vB41XOz6umswVlJNFouejarBTfXa7pFjzaqNfwObT3KO2kOnegd83GUKMyQCA8PlFSwXSfNODR+q2ggV9cbsJb148e45dCuiyKT6XyykzfuqrborpeJbZIITlpyT80tnUcpCorj3R37F99QQoO+W5ks4xTkSpozKWf6qw03n36Gv34k0pYwU2NE+UH0ryhKCUzbLfc/+iHji+d0RqJN5+OMdoZ+OaAqhHEG69i88w5X773f0rwaruvUULfPUEmR48OO7ddfkscjtuvIVUmCFIoYZsGXdVamljUJkN/69rhk2ptCBF0bnlfLNbcY5PBklPy9OQsV4szmVeQkgQq14dKUAlWKxNui0MbJpH88tuv1xF9VaG+oWYs+22iMls/x4tFjrt5/D2MbJst38l6mJBNV5JdTCMTpeN7W1CLvt1aiB1UtKvYE67euHYKbnOBkVLvU31/ds2v+0H/vv/af+Hu0d/zqf/+/zvTNHb/9P/k/MH19+7vz4C51qUv9vqi3b0QV1KpI456cJRte27bazoUySRNajW4NiDjPT5pS1bLKqQVSc3GLVRm3WuGXa1m9akmhqTm1m6qm1iQSgGkiHfaQc0t3aXnSpzQhACuIJNct0M6f0UUoWfXRkoiUMeLYjw24XkG5Dl1P+em5oXoqORfyPDWuacJqTW0u3VNsoaKxL5cD/XIlOtHdnnjYi3ZQq6bps5SqBbt5PBJHQWBZ51BtYpZzm5RqcZ5P40Sa5vProW3Tv+VKStIQ9YPDDz26YbNsg3DrKilBFdGtWg9zkGSbN/pHmYie1qJoTQZSyWgKShmqUnRatHymOHpT2KSBuI9MQ2SbZ253M8dJomCdB2dlyrnsHN5qjFL0zrBeeK6XHcvBc7NZslr2NOkkxnr6xUA39PTrBd0gWCattax822t4akLTOJGPE2mayNNMrRXjvIQBaEWOYmqjVuxioF9fY7v+nBF/OqAIoakIAaAqlPUoJw5rksDp0aInJOdz45JSZr6/ZXq4k1V6EoST7TzQrp1c0J1j9egx6w8+xK6u5JqNYp5RvpOY0CrQ+sPLl2y//BHpsMNaS0ltqqjAdpYYImUS/fHmgw/YvPeBoIbO2ml9lsCghAF6uL1n+/VXKFVxy4E0JolIVWIa0k4ApClESpIDk2n8zFIKOUZKe/6qVGrTf9pOYn61lYl9jvFNE4qEWqR5Ik5TMy8BxpBTlmSzKrKSkmRtXlMSl3qWQ6s2b/6d6MblkLt48oTN03cw3st71bV0qEyTNsifD4dDQ7iV5qIvghpDYZxM1VXTHhsjWx2azpwWDFB/TJN+qTelrOHqD33y1r+/f/eGb/+rf5Fv/ub/k/GLV0zfXBrSS13qUj9JstL2QVwzRoE1zVRQqSE0HFKV1KHW9CmFYIlaMtAJPYOSG4Lpe5TrsMMC23VtgiMA+ppCg8MXckotlWii5izTNSvZ4iXmlmoDuh9kFTsMAj5XZwVkW3WmH3MsB4HEy/5dnL3GyZ07J0qeqcZSlCbNE+k4UotEciojRpKa69nkpLRFO4/1FuMd+bAnHUbyHM6T1QqyYkZRQiBO8rppo9GuoyBmE3FCS3M/jxPz/igZ8lrj+8ZsrEpA4FUa2G7Z4ZxBGtA3051CocYiTX85OZYV8xhRRaFRnBLP3+gZaXzRQsyRVBQL7ym1MOcZozRWGYy2rOyCmiq7/cSdPbLpHY8XHd4YrNMMneNm2bNZdPTOMHSWobcsho7eO5x/k1leWzymcV5iPJcD3XLRuKtIE9OmkapWakqkkIjbA/FwlImnlVjPU1SqmGIkNMAtl/jVEtdMb1JtQt6ukVpUwz6JNIKGvOKkBT1pN5HmLBwPxIPoiVOaZc3cTEY5ZdFQVoVfr1h/8D6Lx08x/VKuvTBTtUJ1C9Fel0w47Dh885z9i69lrY0GDaYzuN6TQiSOM7UorLV0yx6dhYXpFmsx8zVGr9LyOQzjzPH2NWH3gPWNdxuTNL601XctlJhEny1yXZlwatPkK5lU6tlZr5QYloz3mFOGPYgp6cT4VIpqLSkG4jS1KahMR0ut7bURcUhOkZwzlCQazVopqaJMSwgL8awjdosFq2fPWD1+LOtztHBBa/usV9Gj1hTJ00jc79q1I01nbYY/EQPIVF0b3bStTibccW5c0fbB1Reg/d9XSvHuX/zH+eAv/1M/0R9bfvwOn/31v8QX/5v/G9/8zUsjeqlLXeonaERPkwgxDBcxF5RCbdMPZSxayQq2KoUqMqmrbdRVm95L9z2u68S13nKtxXWcUVpA0rXly8fjgTyNchOzBtNurqds9dqQLWYQY4H1nUy6ahX9aaH9cGm3SkmUMLVGMovOTzelZD2tEjW4njzN5OlImSdxa/edJOmESFUVZa1ICJyXm7ICVRLx4Ug8yGOuDVljvKNaR4qJHEZUSeiq2sqvUqpMh413aK2Ix5Hjw15wT7VijMQWauukucoFrRS273DLoRlYZkpqzVhjZ+YgzbyxVniLSmGMYRxFPiF4m/+wybWiGrcxMZUiMoV5DyUISUspnHF01uONZ2WXvBczi6Vm+dSwHDqsNThrcd7Qd45FL2597wxaiY7WaC3SBmUakok2AbPY3uOGTg4cjZNaaqGmNqnKhRQCaZrFUKbUWSOsbHNBNwaltga/XOCWy3Nk6imOSda3TUcIqMbP1CdtYWvWaHG20DisOTE+3DNt76khUKIYg8TopCm5kmLGtMnd4t336K4ficM+zpTx2OQqtpl6CtPrVzx8+SXT7b00X6VirKEbPLazhDEwH46gFN1ioFsMWK3I+x1zCuT1I7on70hT2DTS4909D8+/gThhnUMrRQwFVaXZq0rGptpadAsAME1GI4irAiq3SF8xcRkr8ammvd5am/NGooTQDjxyLeV5EsRZ+36gbUlKThijKAViiGLmUu0ABm8mp40ooZ2j1oBdDFx/9BHDZvNj3F8rjxMtCVRWCAJxv6MkSUeiHexq+06SYAvQVuQexvdCpqiFIv9CvgtKBevemCUvda6P/qU/zTt/7o/9p/7z17/2Kdtf/yHHH774KT6qS13qUr8f660bUT30ktOd8tnEUbXCKHHSnqYHtWS5ETZeYy3irjddjx0GWYueVuXNxEA+TUc0KUq6UpomSkjSuDjRyNWapblUYjCywwK3XKF9J81DzoLYObFBdZX7SZKIzBLms/mkFMnMJkXQGq0ttShSlISnEgKqZnRrTsSgceINaTFVLRdyw8yZvD+Q57GZupM0JUpu6Klk6iGcUSZKmbMxQxuZbmEdOSaO213LlBftrDKiG0Vr4TUajVsIzF8Zi+28TA2pGK+wXm6cMURUAe07WROX0hiJluMYBF/0ZmZ8NizJzLiSaiGXRIyBpe2pJTGGkVoSVltWfmDdr1j4BRu9ZOUNjz+0+N5jnUzGtVYYrei8xVjXEEj5bFjCSKa3sTJxVNbgOi/rVgU5RuDEeEwUQQuQGxFBnUgMWol8AKhBdMdaK9yip1suMX1bxZ9NYrWleWkqjazguubUTlClUZUEpdiMUYqqDPN+T9g/EI578jhR5vhmDW00JUkD49crVu+9x/LpO+hhKddjydTQ0rGcGNlyyRy++pLd5z8iHscW3gDOOfzQoajMu1EaW2vwnbzGWkuDro08n7C9o5aCv7pGG8f9l58z3d1Ta8JaYemiFbZFz+YpoAykKLGsZDEEWdeB0uRa5HpolAOqwnRWNMhGJonKOJm2J0kpyzGgvSeGQA4BfSJOtKl2TjJhls+/OOVLyRhjZbORy5nuQG3yVqXJFfzNDY8++pB+tW7fFZxlPOQMYTpLLcYX31BjQDuH9k7kErU0j6JtBxZJxLJ+aKgn5ICrDWpYSDPc9LV5vBhsfry+/a/+RR79k7/8D/V3rH7hAz7+q3+O7//P/22mr17/lB7ZpS51qd+P9fY7pzBzyn4uIVAqsppzkt5Tz2tLJfzFFpmonMcvljJ1UOq8MleqGQyKgOxLycTDjrjfn1dptnOyAq9iLqAW6qkBHRbydzrf/Canm5MWa1ObeqbpKHpT2u9p0w3t2rSr6QFTKqTxQA1zMxYJ81RpYaCKa7ijUHGLhWR2l0KeZ9EpjiMlxtYwV0zfibP/ODXwuTSJWmlSW0UqpcWcZRXjds+0awQAkClmW7HLFEfhF0Ob4hlZnTZdnu08joESMyXNwtg0Cu8XonOsCGcUcU4fj9NZU3uS1lYk6vP0i7lWQprIJaEq7KYdJRecVjhVCCmwmw5shjVXwxV9Heg7g3UyMaNWjEI4ndpSS5XGWyPGNa3QtuMEEzVd39J6WpOSJDZW0Zr/osghkKaxkQyMyDx0k3RQ5XE3QHm/WdKt5LpTtpnVquCZzrilqqlWY5wXIwvIhK29TqSEakSGXGC8f014uCdPEznM5Ck2IxeN3aqIMbF85wnXH32Iv3qMtl5+bpHDEEajWqhAipFXv/WbTC9ekMMMFGpRuL6TrPhaSXOg1kK/8GirzilcJaUmv6CZoyw5HDl8cyBlePWjz/FDz3K1EEatEgSZ8ZYSE6aT1KcSEtZZlOuxTcdclUJl+WzIqr9KSEPnWtqXRVknQPicz6Yt7R3z4SipYNRGN7BoZcg5ck5VapzdlFObkMpnW2SwStKbinz2YogMz57x5ONv4TvfQjJUe9/b5Xpax2vL9OqFoJ6cHN6KdLOi5dbSFNvOgrLYxUq+p8YjeliIPjhO0twaSfWKuwfm7f1bf03+PNT1r316xuj9w9Ty2+/y2V//S/zW3/jfEm53P4VHdqlLXer3Y729WSnJqje39a9vU6uSJDlIWX2GdVMqynnsUjR5Wou2D2jOZKAKd7QaTzjuCfstNZY2bRFMjKzLm/60Fuh6+vUGv2h59cDJbIIuLbmmUIomj0dxyip1duCf0DICzZfGMqnC/LClhumcWX/uznKm5or2HpzHDn3Dv2TyeCTNsqrPMUJMYJSkJRlDGEdqCMIObxOgWotMOL3BdIJ4CoeR8XZLPMqkzLk2XdaaFBMlR7reY7oO07mmZTWgkamjkxjC2uQStYJ2GtN0t2VO0tzK6BYqbHdHTtGe56lolUkoiIM+lswxTjjd8TAfiDnglHBgjVF4bUmlcHd8IKbI4+GalNc4Y9BaYY3BaNGtyktaZOqklHhAlKLkhF/22L4HWtNdJf5RNMMF4y05FeaHvUSjtrWtVjRZR6XERG7XVb9esHz2FNP157ACcV+3ideJQ4tCDwtMc/bTzEpyrRdKimgqyvcSHHB/Rw0zOYhxrOQsjZw8FVJK2MWSx5/+AqtHN+heJv81NQ4p8hulKa6M93c8fO97zNsdKWdiyBhd6boOZwwlJDFaVYQ52jl5fKVSkWYRe2oIFSpXUpgIhwNUWC47UkrstntWa3meVE0Oog/VDkrOuKETqoS1Ld1MUqx0qWdGq/Ve3ssKyhvJdJ/bVF3R0skqx92eOM5YLYlEJWaULqQ8twk05JhJJUvUaq2SyBRk6lyqTKpPGulUM+tvfcTjTz7GKCFjaO1kXd7OvHJILcQM0/MvqONB3P3LpSDlaJKbNgHVRlGrxrVJaB63aD+AsU17LppgZS15HAnHPVX/wzdd/6jUL/23/yVJyvop1fD+YzksX+pSl/q5rbf+BojHiVqVIJE6h6qFmlrO+0lLVyWX2l0/ZtjcyGq5aRFrQ8lUytk5G+dA2O6pubEzfUM2aSU33NQSWJTCXV3Rr6+afq0lsaR8bh5k6ifauDhuKfPcJrKOkoKgf5w4pW3fU3OVGMPDXrBLxoqeNdc3jYM2KOfRyyVu0WOsFv3q4Ug8TpSYxS1stADSF0vCeGS+38pa2nXyVFpsqGoOe+0sJc3Md3ccdkeUlkmVQjiIVMU0zlin6BaCktFW45dLtG5r/YpEXSrVnMrScLqhwzpLzpU8xfbayMIdBSEE7h4O5/WmMF0r5dSLIUalkCNjjji7wBTLBNSSiFQG1YFxSPRm4WHcYSJ8y60ZvBHzGebNY80J3WQKqEptUZK+mZFKymdWZ41B3PFaGqd5e2R6eMAomVJRZZqtm8EnJzFjKWNYP71h8eQJynhKTK1XKTIRLyA2nArOYbqhIYTSGc9TYxG0V5ilUbaW8fVzpvt7UIo0ycq5lozx9oz1qinRP3nC9aef4Z1Dadc4teXNpkCLOxul2X/zJfff+x5xtyUXSC273jjBlsVxoiolWtnON+d4FDOP8ZzeOa0MKlVyDqR5lqljC5XQWmEbKSKEjB86jK4YY6UZVRprbfPbKfkcaeSQk+S1M15kHye9pB4G6f3SjFIVU2kpV5V5u4Npkl9TGpnra2Kb6JpmKCpVaBi6vS65MUFPmClaNnwFrj/+iEcffwt1EplrI5NdEGOhNhAT8XhkfP2KMk3CLdUW5lles6HHWN/eZ6AqnF/K+3vYUcZJfp5WaC/sX6yTLcf+AWMkuvRS8Iv/xn+R1Wfvv0Fj/ZTqD/ybf4X/4L/1PyMf55/q33upS13q90e9dSNqnBeDjRWeH7XKF76WyVWOkTBN5DmQqmJYbWQidPrOKllWftYSppF8PJBiEJe0t6DE5FHaGry2m5zb3NCtV9K8Jlnj11obaLrd8FKgxJk0jQKWty3TuzlfdbeQhxAj2lim/YG03wGCqAlz4Pj6BWE60g9rFsu1uPqHBd3NFbokWRGnQjqOhN1B1ve1oJTDrdcUpTi+fk087LHGorSTXHdVhTSARmnItZCmkTSNxOOE87410UVkAFUy57veYTsxL9muEykAWvSuBTFKGXH1lySNmOl7tLakcZLpYWswaslt3ZmZkuS6n3V2TZCnmrPs9KtziZxyeQqiF1y4QSJEnSOXxJgmQqkMqsevDKulxw8LYX2imvnFiiTBSPIURuGHDjcM0gyEIHD2ljqlh4WssWMgHEbiccb5jloVuVScFWpCyYncYhv9csHyyQ1+vZZpYUytkW2u+aqoShiqgkpSkq7VVrbk1A49uUlFpLk93n4jjWdO7eCRhBfrLGnOqCKHqtXH32Lz0bfRKUo4gnWnix7hCWmUdpQK891z0nErgH9rSYejTMI7I2SCMKOAfrGgWy8wKGp8gzorCtAW6xxQiPPIfJhQSrVUIMgpMR9HNBrnnehaQ2C5WaNqadelkgOkVgKmp8Xd1kJRYvYz3ov+Uyn5PGgNJcjns3FUS6lMD/fy2dIaU9X50BFioiRZ/ddSiSFQwizpVsrK94FWuKEjHyO1VnKp6M7z5NNPWD95IoSEZhITrWmFOMshUVvmaWK+v4VmTjOLRUtUq6iSqSGROy+GQ2Nwq2s5EJQE1mGWjW8cGuGiX5KPI/nhFsjoWvH+MrH79K//Jda//NFPZSX/Hy3TC/s4c2lEL3Wpn8d6+2/YUqHlrFMRTE6tDVQ9k1PBWIfvB1KM7F58w9U774urHlmNlRQI+x05y2rctGZKwPW1OVszioJdrOnWa7TrpDmYW0ScOjV3skarYSYdtg2VVNBWQ27u6pbCIw770vA3DzKdrBJ3uX39irtX33Dc3qOBxeYR9d2PuXr8mGGzQpWA7NUhHg/MD3tykEmj6jvUYsF+u4XxiEbRLxZnDd0JGaWUaPnmeYaasEbQOMaJc1sbK8kvIZ3dvLbrcIuBru/QKOI0Uylnfio1k6fmqncyNaupkuNRTGPIylqf5BJa0y0WrBY9j9+5Jv/dr9sEVMwxlSq/l0pB0E2lVlKeSTmitSPkyHW3orc9UOm0ZR9H9vHA1XtP6FarM7VA1SwHgYb0KrUwHY8snzzCrddtkq0ww0IakOko0zAtE7s8JsgIXaGhm5zWrbkUPqcylsX1muH6CtMNLflKozsviUfxdM0ARkkTSkVF4bHiHVRpViTRSOInw3hk2j1Iyk9IpHmiUjALQUPlKAYdM3RsPnif5bN35Rr1tumjpZmVD4pFKUOeJqb7l+TpiNGGzeNHPOQiLNIghwlpWC3dsqNbLdBIcAHKUI0WqYpWGCs66DiOhMOIvGuqxX4a5mMgxUI/eGKtuE40sjVEXN8JQQHks3cmuALtwGI6LwzRCmroZWJcG/f0pLVVilQLcbdrRr6K8p0YzyqUlDFKEotKjmIi1Bo3DCilCcdZGsKmx1VWy2vgLdcff4v1k8cyBTUyxVauo2ot713JoCzjq9fMr55DFhKGcp58lPdKWStNNpkaJlS/wG9uhFRQIsp56Dwqy0FFtOuVHCPx4RZKFJyTkdf657kkItn+jjShp/q1/+Ff42//tb8hB5xLXepSP1f19q55pYQj2BJUKtLYCUDciQYNJciUlETkv17j+iUlZ+LugbTbiWvWe5Rt69B8Ws3JKt4OC9zmWligpcA0NjOCl+lrm6yVxgksYWpMULlv1WZy0M25XatMWcP+QD6OZ6TUfBy5e/El24c7cgN4Z6XYbe/prq644R35+VWTYyJPE/E4UnKRlWXvKaUw3d6iSpEoSedQFaoqMpXJiYJMeUpOqFJk/YwS1JJx2E7WyCcHfQWs9wyrJcpaUhKgeo0iWchaJnkqF5Rt5p4iBrLaNHdojUpF3NGAXfSsNmvR+hnNx9/5gPrv/F3gbFBuk0/RieZaiLWQqaSSiDXTmx6jiqx2a8UqTe86Vt0a+1jz8S+/g+t8M+9kStXtuUIMsjZWCg4vXxLHA5tn72KdhxSI44E8zvI4jpMcUoyjNCezdg7TdGmlJXz1i4HuaiPT8hZcX61tq2Ras9K0yc7LajhLwpJEX2ph1Zbcrr1Emkem3Y55GiEXSk5NA63QaGG3FtEv9tdXbD76gP7mhhIiSFq7TO1tY5Mi2tSwvSXubt+wNKvoWzePrtnf3TE1vaRzhmG9aHKM5tpXumkjRbqgjaJkmMZRjHCNPCGyYsMcInMMeNeBc3SdO7N3jfMt7742jS5tXU0zEUluvO26c8qQtpYSAnmOb1TFJQtd4jhRwkwpsno3bbMhq/0CtulzCy0EoPFVk+TdlxTpl5LnrnTFDAOPPv4WV0+ftPepHSaNbF5ULTIt15Y4Hgn3LyV2tUjjSZK8etW+H4x31Jqx3ZJ+sYIwUxjRvpdUsyKyCmoVbJNSpPEg+uN+IddOEl7vz2uZZc+3/st/hus//OnP+qFc6lKX+ke0foKseZnMYARxJIafUySlNFalJc5Y78mlcLy7pd9U8jRR57FhcnxzQcukVDjrGm0dbrPCLVYCbY+xTROVaO6cE9NLjuTDSA5TaxLeMAfFjWya01yTo6wBU4PH55SZw8jh4Y6Hu1fEeRK3szGEUDBGeKK333zN+uYGjaS65DC3x2ixy6WkPI0jdZ4xWmGXS4yTzPAUYzMm5QapF7OEuMFtkzQAzkOM5DkSxpmC8Bw77+mGAa1bpCE0SYNpU05ZldphQLfknxJbhKUGZVTjvMqK06834h7Xkqudc+FX/+DHPHm64fMvXv+Hpxy1NaMVYs2UpvmlagKZtXbNW66xWrixdtB88quPubpZQy4S3doavZwrYZ7OBjBhPxrm3ci0HOkXQBBWa0mCCjoblmoQPJVzYESOURuyya8XdNfXmH5o2uQKVkD+5ARFIiSrNijXie42i/ufZhYinRorTQ4zcTww7reyYm4re6WtTEKtJqdEPCaMcyye3bD+8EP8+gaQJkoZ3db+VpJ4aiWHyPz6BXF/39LG7OllRpWMMprl9RUVSCEx9I5u0VNyJTdXvNbC2zTOtMCkSpiPzMdZJs60cIV2uElzwDqD7cw5nMB635KkpNk6pRXVNl0syMRZW4Px0vArY4QfGmNz3YuBrqZInANpnFFUMTN1gzScuXByv59kNlUVtDjLyFMQDFcLg3BGoY0izhG/XHL9ySesnj6BKNP4NqBHVZGS1BYYEI4j8e71WcuqWkqWMvrspNcVqjIY2+P7AeJEzkm+f5p0osaWSe8cBU0+HCDO8j4auZ6qMZTDzye+ya4XvP+X/wSP/8Qf+F35eetf+ojtr//wd+VnXepSl/q9U2/fiFoD1pCT5D1bOwifL0VKVuCs6ACjZKAbJ5O5HCUWE9oNw57WfE3H1S/xyzXOS6a1rEpj04BpmYooRYlB+KLz2BibyEq/0NKJDLrryClJfnWt5NBufDERxiO7h1v22zvm45GqFM5bSq6EKOlM+TT4SBMvf/hdxu3I5voG4zxucGCtYGeOO3H8ejFAqdY0lhCouQiDsSRKkwAIz1AyvWuUKUyZA3mW5yGrVoPrOvqhF25pa6yNMaQ5kqtMlKxzaK1lDT3PZ+MKQM2VogRx5Vcrus0G6xs+qDnGa618/OEz/rk//0f5X/6v/x3GKWCUkQkVlVIKsUguOsBJKapzQdmON4szhR8s7/zykiffWojPpbnCcy5nwLusgeUQ8eOpWMf7O+JxR+etRLtXzolQVM5xniVFiIJQMs7hVwvcaoV23ZkJq1rUrOTBtzhOZc5GG3XiQ6pTxKM0YFUbSgrMxx3T9l5MT1XW3DSXdomZXCPKGrqbK5aPHrF4+hS3XLfkoYLqhvYWiDGKUkkxMd+9Io8HoS7UKqP4Nq0tDQ2miIJYykU4pDnLWts0c5duYQYKwjgR50CcQ0sgEv2uZK23dbhtSUFaY73FWol8rahGr4AYkqzK20FJ+xbVaeT1l9CASs7zG5h/Q1/lmJphS/Sv55SzIqYnYwwpJlIMoMSyJA1s01Q3ukb3Y8EB3eaK648/YvnoMe3NlxW6ViLD0UZ04CkSpkh4uEO3Zl+5HzuANBc/WpOmgLIdw+oK0wnKyaTYmlZFnUb5/daRixJWaGtUVbtuakNOqZ/TrPn1L33Isz/za79rP+87/81/kb/91/7G79rPu9SlLvV7o966Ec2lYFIWeLw1lHl+Y1pyLQ6QSrUCF5epZINCKw2N60dzEttuwPQdZrnCatN0nOnsMAba+jCTDnviOJJjEOOEazpEFMoK1Fxpce/GOQq4Pog+M8wjh4dbjrt75ulITunsUUm5Ms+C/rFG0fcWYzRzLHzz9WuG+wn3K7/CarEgxUjebZFceElTEtOGNOM5ZZk4pkxKMmkReLbBGC054kUSo/I0U4I0R74XN74A6uUfQLSMSpGSTKyME/yMMqYBupuBA0lmOq1bdT/gNxvcYmimjMbhPCG0qrzOf/ZP/jJf/egr/i//7m8yjwWj3wDtUymkxjPNtGhTpcm18VkBtzC89ysr3v3lNd1CNKoYQ87SxJrO4TpDDoEYC8aLpKM084/1HlUqOVa0MufkJ9GUquaolrhI6yRpyS0XuGHZdIMtGemUxpObdlAbtLFyqEmxmd9kkltbU32K/kxhIowS0ymNGW+Ys0qaQgUUbVg8e5fl0ye4YYnyg6TvZOGMnpFftZDj1K7XCWJoBp/apvu1aZyVGH1SpMaIKtJol1NDZ4y8XlYc3CUE5nEk7I8AZ/1mqVWMQBpKKGfzlrGWru9FX4sGK025UghNoCQE0qUwnRfdqHNCpFCi2SwpNSe7aLdTDI16IaYmcZKXZgis7eAg1/g8SaIStZKrkiArIxzPQkW3GFtlDf3VNav3PqBbLs9a4Nog/arkxnWFNB6ZtgfSYS8T1oblUm19fvouQitSiMyHADMoe8/ynaf4fjg3lHUc2wbFkXIhzyM653Oy1lmwIhfC76g28vdquZsVN//Yd37WD+NSl7rUz0H9BKt5WcmiVTMnyISuKk1tDSaAVubMdqwpUq3FDL047Cso57D9gHOnRCDOKTnnyM1SKVmA1+k4Mj/ci4Gn76WpQsm0xYqTtuRyBn/XxqAM857d/WsOu3tiOErjkev5Bh5DIdeK0YrlICD2EAuHMRJjlsbUBcaHb0QT2PX43mGGpdx0q0gRSswSN9nSZUrKkGRSZDrfBmWlxXvK1DTngu17rHdY68/mkXr6v9JYmsiq2nbduaGUVB4ntIATmB3QfY9fb/CrlUxMaRNj1dJnanMlp8j8sIUw8Rf+9C9jLfyt//fnvHi1k5tyqURVyDVT0URkpe7QhJxZOLh+t+ejX77mvc+u6DZDSxTKDeiPuP2taStYg+la4xQCWgnsX7V8b9WuLdWaUKyViWHTU7rFQLdeihTBtMOMMudpJDnJgaVkWSsr0RKK/rNNs2qhRmlSlDWUlJjuXxNjEH1xqSjjZFKqpQkuSWJk/fWG/tEThsdPMb6XFXWt1DBRUnjzuJUmTjPh/jVlGjmfds5wAn1SjVJzouRTUpdIL0o5xYyKkx1vUc4Rx5l5fyDPs0zJtWkr8Np00JDnRJ7F6NYPA76XNC3dEsZOWfYlRWrNaFPbwcfjhh51ala1PqeQ/Th8PhyPbdoqRsF6OmS1iNpTBGsOiRhGkQrk2j4TJ3mAQRuZrGqjUd6zevc9ljc32H54swFRWt6/IrG8dQ6Ew555v6XMQSbvqMbOTdSmUxdtuCKEyHwMopUuhXB7Kya0p0/wi0GwUQqwXhBn4xFFQftO5C+lHepk199IF+N/um/X36dlVwMf/5V/lus/8tnP+qFc6lKX+jmot25EZVJQqEEQGxW5gdKmn6oFmFByMyBx1qTlEDHLJX65EiOEqqgsyTWcG1BxrdYYJbUmRnIMcvNpulOFTGK0s+fc8JQkc7wNmag58XB3x+uvPidMe4yuxCQ3QKNgCpkQMtYq1guH85bDMXHYBkopeG94fNPRdfK89revub8d+fCzX6B3C0xD0ZxWqPPxSJgnQGOsIGKU1bJaBWmQcyHHIqYO73FLh+860XLmjKIZMqgyWU0JTqEBtXJirwpqpyX/5EhVBeUtXb/BLZfCYtXmfCMVJFKhtmlWDjPT/T3xsKeiefzkEf/Mn/hFPvvwht/47iv+3m++IO4glMScM4ZKVaCUYdVbnr2z5pNPHvHxd25YP17g+46qNCEEFJKNXhsEXVsjm2hV3rBErayMjZXnUIqQrXSLXTwZbwpgvMP1PX5o8ZxNm3qKBZUmNEjTZA2mX8iqu5nEQBogjGmrZWmswu7AeP+KEqdmIpMJ/WkaSBWNrdaa7vFTlk/fxfoObb00PnE6pzmdDDWlZOb7V6TdTh6mMW+4mAK9RDtLrZk6jeQwS9Sp1i2mUpor3T4zylmUkcb28PqOlArWqrbWVi3qVdzkKURJJ6JitMVZMRuZTpK3lPUy4ZwlBakWYd+65QpjvehklUzkSz7JSzKiKdHEURpg13kJTUgZbZw8n5LIUabz43ZPTQntdDvsNfNdbeao9q1hrEEPHev3P2RxfSNhDyfvfpsqkxI1zVQUaZqY7m6lgYXztV1rFZlLFooHWjHPM/NhRimD9qYZIoXBOt/fE8eR7uoG169I4w7mEaOq8GmtlfcqRWlqlRgj0zwTw/QTfan+fi7tHZ/96/851r/44c/ghys++9f+Et/9n/4ff/d/9qUudamfWb09R9TqlgfdYvOUErzJjwOmadNSLQ7d0pqE7uoKt1hLxB5VUlaKsApVWxvXFEmHI2k+cooBrTGhrME6L7rKLE0oxpBrIc9T4xnKBGv/cMerLz9nPuyQFCFFCG29WGEOkhpztfFoq4mxcv96pJZC5w3LjafrLClV9ofC7jizPwRifmAumu989jH9YkA7T86ZebcnTmIaMVajadxSpSRedJxbvrYYgFzftzW2sBbrSdtJS6LJEm1o+l5c4s0Apr0TDFUUvJA+NaWup1tusCfG4+mGb8x5cifaPph3e+btPeUMjDfUAo+u1lir+fDdK/7xP/QBL5/vOR4Csa15O2dZ9p6nj9c8fnpFP1islwCAlAvzeACt6AeZcior/05bi+qNOMoTVCfwdWM0Ct00odKgqYaGKbOs0m3v6VZLeV40mcapWSiFkmZO0bDKO1TXS+JSigKZV9D2waIxbtfSvL1jfrgjhVnWyDlJlKiWSV9JmRwTdrlg+exduvXmfM2eV/bGn19r5Q0lRuatTEGNl3SeFAK1KmnaWgJSBQlZCHPDAWlBGuhTPG6W3HgtgQbxODHvdpRZ0EhYj9aWOEdyrNQij1Ub4Yf6zuF8h/XuzNC1zrXHguTCE0Ep3GItmKwY5f1wVprVGETikIvooaeJGiPdMKCacU1rQ9WVnBM1RlJMjONMnmdsi6OtSq4BquhRqZVaFEUpzKLn6sOPGa6uURRwtvFLT81ooeYA2hLHwHR3K58nkOb+pBuvlZKFtKGMYR7ldfJdJ9dFm37XKv+N1qRxIsWXLG+eoMIk8hdjwbuzsasqJZNnMnF/JKf5p5ok9Hu6lOJX/jv/MsMHT35GP16x/pVv/Ux+9qUudamfXb09vqnviOMsXNCKrOZaUtL5ZqqArm8TL43fbOjWa5ne1DaVajnOKHHY1looYSIeDudUpZLa6lFrqpHknRNbMxeI4yiOXWfIKXG4veP1119z2N5itOj6UqpoJdq9uU0jF72l6wzHOXPczlhdGbxmMfSS9z4VHnYTcyiUXIg5U6oi5crzr79h5S2Pnz1DaUUcxRBljGlxk4UcZHKZq8CQKopShQvqtJI4SWslBjRGacSQ6VlKkVJ1Y3HaczSk8SeXryCzaq5k53DLJX65lOhFpcRpdUqcUhJnijKkNDO+fkUa92czR21ua2UElr/WFkrlelV4dvUE58SEpU0z2UjAeNOoShTj2Iwz1histaJ/TRFXPPM8YjpHd7ORCWYqZ3NXaVGr5gS4r5XSeKgohVsO+PUK1/UyWVTSuFKrRK4qOVgo61HeNplEPadsCcpH9KqC+tKUeWK8fU7YbSkpk1osLVmaGW0KKRVyzPjNmvX7H0queZibvrmDfhA2ammmGG1IUyDcvgQySluJ+zxxY3M6q0jImTwL6ujNwa19FnJL02qIImqRdK7dvhl8ABSqKsIhECY53KhmRjLO0nWDbBqcFah812G9Ic3zGYaf2+q665eNMpExvTRtpRTKeDxPFwunlTV43w5EtWCslalpFD1troUwzygKvvPkFCm5Ch/XKOLU8FhKkXOlWy65/uhjhqvNWa+pWvytnDzFwa77R+xfvGD+6kdoZ4TCAO1QVSU6tx1ksoYwjmJabIB+OWQUDBo7vGEVK8QrqcJBXlPtmxTCgGqr/qqhJuI8keMoB8Afs+j9I10K+vcf/6wfxaUudamfs3p7s1IUN/Bp6iENjZHpZoqC31EK1XWY9TXDeiPax9xiJk+NR64NNC5NaNzvSdNRbvi1rVP1G92ddpKgoqxjPh4p40EYo8YwHw7cfvUFd19/QS1iHDkcC86Cs5oQJPll8BprDTHBy9cTCuh7zWYleeR3u8BxkkmTtwqvFdXCavDEXLnbJx6tLCXe8eqrhNUDvvc43+DymrMcQYD8imrE3GNsiz9VGrdYYKwlzqFNgGSik2vFDh19N8j0pyTBylj3BjWTW3LMMODXV9iuP5t6qJVqvcQbKgVa8ujD/oHp9jW1JJmwlgxTyz5XCoWlFFlld0Zc+77vMF4YlCpXKJFaNVXbBh0vjNsDJSf6ZY/1lpRkwu1chxv6NsW1lBCJhxmtDdY7cVVbJ81jaVrYGChzxA49/c01frWWyefZjKKlAa1ZZHut8VbOS0PVGKAkmfbh2kQwRUiJcDxwuH1BHCdKSKL9PEGza2talLj0h2fPWL/3Ac7opr1V4DvoVvLaltxyzitht2V+9QJo/aOyjSqRG0pLNzd5EXpD03XWZsbTSmO8OU/00OJsnw8H5t1eHmvOKKMYVivG7ZF5nMUIpyredXRDx2K9ks2EtWAtbhDpS85Jpt5GIO1KaVyLNYWK9oOoC3IhTzO1cD4opN1IiYlutUJlmVDWKsY1pQBtmceR+XhE1YKzDlUF7FVKIaeMLpqcZFuhVMWt1zz+9rcZbm7k/W10gdNkG6VQtgPrOL58yfzVD88GvTMw//xZsihdKSjSIUNsBIveNb0oaOS6VqlJOeYZ6z39MLSpM+17RlBjYgCUQ06OgVISZhjIMUL4+eCI/tH/8b/+c2nMutSlLvWzrbc3K4Us7vaT/6LSXO4yaaje4tYbhuvH2OVSGH3p1IQ2w0wz11RVibsdYb9vpicj+dNajE+6GWxkDW8J40y8e8A093icZ+5fvOD2my/Js6CUchYj82ppmObCGCq9U7KCT5WHvUzB1r2hXzhSrbx8PYppqRS81RirMBqskxzumAvjFHhy5Xn8uKdWxf6wwxrFsOwYlgLZzyFSGhdSzFOyYtfGkEPCLQb6zbrpZeVxlFyEa2gt/fpKtKcN7aQ00EmiEEXcy6rvcIsbfL84L/RrOaXxiMFDuIdifDl8/UPKPMq6VwkPsozHtubvKRVqrqQkelw/DOjlqvEjFTmL/lEZL6tka4njRBxHrNXoxRLjZGVqvMdq0YfGecZvVlQU4ThinRO97I+ta2uMwrEsMsH0mxXD40fYYSWHDiVmNNU4lqXMMllVTvSUbUVPruRSWtyrmHJkuCavzeHujuPdK0op1JCpMctzUeIEL7THpR2rD95n8eipOLJrkQZ4sQTtqNMe5SRhqOTM4flXxJfP0d6j+55quzZhba5yeYMFddQaZKU1paWDKdVc/bmivazFYwiEcWR+2MmBDDDWYjrHuN0RZ+HTamNw3jKslyxWK5x3FJToZK0RrmwV7bXExab2+rd4TOebMUdT54l8kESrEzoqzSPUjOs7+aw2fFOOwnWtWsu0MMxY0w4zIUEjWKgsuuJSC+iCVobh+orH3/6EfrM5fw9wQnWd4mBrJc0z41dfML14ju1lWokyKFukaa2VUyRpqTBtD+Q5SZRwrZKQpRU1y/urjCSa1Tnhuo7u6komplY2AKDIIYg5SovmNoepSTcU6Rjk95t/tPFNyhl+7X/w30D3PycShEtd6lK/p+qtG9FaiqSRNOCmoGYE5G2WS4bHT/GLlYj9Q0t8acw+Kmd2Yzweme5eU+cI1smkrMUC5lOzYB3aDaQcmV69Qpcs05qU2N/f8eqrr9jdvsCaNxB012uOUyKGjNWwGiyxwHYnZopFb+i8IaXC7UMghoyziuXC4pwmFxjnTMiSGpRzJcbC45uO5dIxTplxzGgDwzCTciDlTly8WkviqJaX03lNmBNhCvSLnm61kGYol+bwlgbM9R1utRJD0tScubY5w2OUSZ8xmMWS/uYRxjpZn7Y/j1Ko2qZKxlC1JuwPzK9eUGPALgagGaZiRBmL8fJrOUbm44EaZnzfge3OOr2S6zmPvGqZ8s27B3IudIsBZQypFEKIUCrGKlRvG1BcA5oSAr7vm8ZSmsSas+h+Tfs1Y+kebejWG4noNPqNe5oqphWlzhB61XWoE6sziclItddMaY1K0rCWXNh9/RXT7kE0f7FQZonxNFbWtKWAcjJZvfrsU4b1WtKqGokJ38nPiSfHdJVr5MWXpIdb/PUVZliem73Tmp0YKDFI6EM+kQ5OsZ/qjHMSCL8YqdI8M+9H4mFszZY0lcZZYgikkDBe8t1741ndXOFbVKbyDmu1SDbmSXSX7bOC1jI5z5VaSoPia1ROYnBKzdTlLLlk4n5PzVnW/BjSOKFUQWmH9h25ZFSK1ByaA150xsrKY5aEMHEtlipT5/7mEU8+/Tb91Vrey3yK/JUDUa0VjGhox9evmV6/FMe/0SJlsBKAUUtDu2GoKjeZUBTSmzp9R0kTLHGiBtt3KGuxxtJv1iJzKUU4xcZS4gRpRneSZJWmA/NuK2v8ZrjT3p6fyz+KtRkc3/43/yp2NfysH8qlLnWpn9P6CVzzRm6mOVGKrBftYoG7eSS6RqXFnV2rrJRPSKdaJD5xOhIPe+aHreR0d7JaPTUvp+hGt16C7WT6djyggaIUh/tbDq9fsb17RZjFuR/FC4XSsD/I9HW1tJQCx0k0nt5rvHfkVNjuIzkVFJX1wrLeeFwn675aYJoKxzExz4KEWa8cnTccj4k5ZPreoo1imkZyUlQUq9US4z25gncSoVkUdNrQLyUvXqlm9EKSkZRRdKuFGLpiaq74xsSshRKCTFT7nu7qWpJhtKYqIRecHdm1IEgtTcqZ+HAnrNMKWCepOEqjXQfeU6tgpNJxJIVZpqjWgXKQJVWqlNLey0rRmpQj8/GI8wa/WIKCFAKibtWyKraSouNMJz1BKFhtUUW1iayStCMqVStqyzPvrq/wi5W43U9xjrJvb3pQqG0SqoyW1XgRnaxEcgl/UxlJMyraEvYH9s+/Ih52gAQD1CxTSqUUJYkjWhmhAfjNBr++ES2gzY2xqSVwAfm9NWfm/ZZ8FOi5v7pphjDexHaq9t6lJCa1nNFWwgdO6/jmiMG1w1ccj8z7I/NRNI4iRQDjNNppcoPcDxtJ8zIohtWa4WoFSNKX6pzIQvIsz8l14s5HYbQVzx4V7eUzqajkeSZPkzTFzdA0PeyoNeO7npoqJYupSllHikmwR0AIUV7/2nS7jXpwej9AmMPaGpZPH/P425/hl8s3k1Bo1AFBtFHF4Dje3TK9+kYCG5TweeWajPLYW3JTyol0iJIwVmrTYMtfW2qlziJDUM2Nb62hv77GdH37zLSfH2cIk/CNbU+ahX5RqO3sLO9ZDpF8PP7EX6y/1+vRquN64flX/vN/hP/7zZKHn/UDutSlLvVzW2/diArgWlZjeljirq7w63XT+0mTpVrCyxvIeCJNI2m/Ix2PLelIXN+il1PSGDot6TPOk1Ii3d82XWBlPB7Z3r1id/eKEkdpghsSRwGpgKbQ9zJVneZCTgXvFMvOEXNltwsoYLWw9H2Hc+KSdl6mbylkxikyjYkUEtYqhl60mcejoHH63pFzYZ4z3ltqmZjHA8Zalr6jWwxoraglinvee9G3Vsg5N10mdMtB4kCpwl9tDuqqOLuHMQ6/XtKtVg1eLnxRUmoTpcayVNJopcNI3G9hnhrsXV57rG2gdOS1j4E0ThJjqfU5w5vm8j/JLHJLVSoVckl0fS+rXCROUimNcR5sxXbyXFQFVWrrIQu2IYhqRSa7WqGtxWiDdQ5/tRbkEg3f1YD4Mu3MP4YHa0DxFOQ5GQGznwxJSksmexhHji+eE7b3oiW1TiaSp6a11EYSoOkRDb5fYmpl+8PvMTx7n365QGnXtLbC/SwpksJInsaGpBLMkUxrm9YQICViCKK3rBXjfaNR1TbRK+fPjzBXA9vnrwnTDGic91jX3julCHNEV3HEa6uwfYfrBvxiOJMJUIoSJUlMG4SFxWmi7VozhuCvjGn4JclmxziqKqRxJB4O5BSxDTuVc2OGamlCa66kkkknSgXqjNqsuYLhjFVSxuIHx+LpU26+9ZEke2l9boIr6hxYUbOs/I8vX5D293TLhUgYUqJOsfWMp8m8ppTAuB2pGTngINeaUpqm2mhbGM0p2rRbLs8BACeNbgkTNc5o16Gsp8RIHA+ibTYS/KA7B1k+WyXGt/2a/D1fVwvPL7634Z/5Q+/zJ3/5Hf7Pj9/hePrO+BlXrZXt3/nhz/phXOpSl/pdrrdvREvF9AN+c4Vfb2TNlXNrDtwbDmSbmqZpJu62pP2eEiQWFC0TRaXbjUwrdNdL1nNMxO1WEDJAnGd2d6/Y3r5kPByE90jzBll9JhU5K41KSpWcJNfaOPn345QxWrFaiFveWUnjkb6nRUjmyjRltnvhB/aDpCvlUkkVMAqnVEutAd/iFguFaT5gXM9iLV+iuSXxaCvGrJKL8CJNy6n3DeJfFcpIc6KatVoCNsH0A3ZY4PqW3920bJyc3ufpmiHPM/GwJY9jG0ZJLKVSuk3ARKMa54k0TZAiWoE7cTwbSuukSURpUk6iu0QwVNoYlHcy2c6F05YyzUEmclr0ms5ZtG3TuZpEyiHWanH/G4/tOlzfy+rXemE1niUcoFoSkmxgBZiucmy6Wd0ON1lG4C0FJ88zYffA4eUL0mGP671MKmNCCQSVhjVoul2N9h1+OUi0aYyUeWI3fpf63vv01zcNUSRpPmk6oHTFOEeOueXdIzra1Ji5pVBSpDRTkPHifj9JTkoz+mnVmKPTKBP/mNDO4KyTxrLRJ1JIEufaN+2p1oKz6noJcVBibCrzTElJ4jARTbJxHUq316uRJ5QRjNbps6WdJZdCngNxt5MpOE1+UwvWWmGsRjFZlRTJMTYgvkx2dZts51xQqZ51sH7ZsXr3PdbvvCOGrRYreopjbY4m0IZCZbq/J23v8OulXLMnyD9yPSsrDXQ8jkz7qYU5adolitZa+LT+xNcFqHTrBf1mjXZejE403miOUJNcc9aSw0ycj6Q4S/hCY9pW5PBWVW0c29+/ZbTiL/zhDwD4+OmK/+wf++j87/7c6+fYWtkb4aj+7c0j+BkZllStfPrv/X/43s/kp1/qUpf6WdVbN6KLZ89wyzWm79sq+wTktm1KpdrE7UDcHwi7HTXFhrCRNfZpsoEC7T3KO1Kp1N2OOs+UXJimkXH/wLi/57jdchwniZjUCo3EBSrAGiWpL6mtXaFpL+Um6a2m8xpjNClXxjFzJNN7w2JhwUAMheMxcjhI7GfXW5oRm1JVm+BUatVYoyXmVMvzialAiYzTFr8VfaX1Bus7MY80iLrWGtsNbUUNtTUGpCBrXSNoJu08tutxXdeaklOz3fSEtBQbpcgxkCaZ0tU2ranNLCMQbwGJl5iYR0nlURXRHWpDQbWmAonD1IpasyTN5HoGi1ejUEZSknIQTWFFNJbaWcF0VdF/6jb1OukfawPxowQn5JdL/GohbvfatKTnP1PO6KVa5TXSVFSam1u+8X2MEBTE/KYIhz3jy5cyDabgFk1zWGUNL9eKTJtzkgbdLRa4YRBHexYgulIKnRLHrz6npER//Yg8HSnTEVp8prxXRsIUtH6TV5+iMDXLKXK1kR/aQanmLH9WSxM6Ho7EeUaj8F0nP9to0YomSSuzQ4exFtt3aCS/3Q1DM+/IxDONo3y+WtCENRbbCZXBdp3EzRZJYiK3bHklTVwthTKNpHGU16CCcU7W4tqQo8hvSsnkFGQ7kUVXW06Hp9rekyppXMZYus2a1bNnLJ8+lcfVkEy1nJKQhCiB9aQUCQ+vyYcH3HJAGSWPM2UI7fChNHmaiXNgOszUqnDNTJeyvMDmFPFrTnpV6FcLuvVKptstVKOeIoRzbBQOT5pGOcilKFrszoBzMrFOSbZASvBrv1/rr/zJz/BO81/4Jz75j/09f+ZW6A8VuPqx6e+Lruf/t77+nX2AP1ZKKf61v/DLrAfH/+5vXSajl7rUz0u9dSPa3zxupguZ0OnTWrexIMNhz/z6NfFwlPSZ2nLTlXqzVjZG3LD9QEmJeDjIuhLhcu62t+wfbpmnvUxgSmMygty4vazjYqrQtFynBlQjyCbnJGI0piqr9hbr6YyWqajTGKOY58z9NrQsc0Optd3cpBkzbaKUSwUjLlzdVsXy85t7t8zsd69BKRabFcZJ4otxDuM7wRVZeUwysayQZmm8GkDbDQt8g9Kf8SnltNJtEZ7GiaHksCfuHgRNo2VqWWo5c1xLKSij2iR0pLSVq26uYIHry1rfdk7+3pRJU2xNBi1ZRtzwJRWmhx3kjO09oOW5WSfr+PZPKaDa4zDOtL9DSeO3XktTddIOK3FMV9WoAK2pQOtmZMqSvIVuuCaa7tjK9VAL48uXHF+9pIRZMGG1CmKsKjByfRpdySkJLUzbBnxv7MyURWZwTv4RnWu8u0WrgpKuixJlBGx8d76eS5aUopIjUDDGkhEMklKNsctZQonSWsxh00yMokHVWkkKUYEUs4Q/KPBdh/EW6zqMk/Ww6T268w323jTEc2j6TIPtHL4bZMJMQSuJ1TUlEw570jxjtKIWRc6JMs+kcRI0EQrXy7Ra6ApJJspVnp9SUJQmpUStjddQIUaR2Git0EYx3Gy4+vB9uoXoV2nQ/xpz41s1iYSxzPs9cdxSpqO40qFlxbepbJJpdi2FeZwIs9AhjJHrpjTygbFWPpMYSgLjDG7Z0Q3LZngr7YBgRBpzcsdrgfWH/a5NPcEuB5S3bULeuLYnJmwzdf1+qv/qP/0LPN30/KlfeRej327CqYA/dffy/L/vreM7hx0A/4/rx3zVL34nHuq5/vLzL3DW8Bf/yIeXRvRSl/o5qrc3K6GhaqpG1qO1rSenI/PDHfP9A3GcZcJzQi+VlqBUCqpzuGFBzpl0HFExnbmXh4fXbF8953jYMk0BqBijCEkawWEwOGuISUDzRp+iDoVT2HuZWIRU2O4iORdCqoRUiLmwGRzdQrNeWazTEum5j1QqzhmZykLDKtUWTSjNmDearESRWuoJlC/rrlqlQY2M7Pf3VKWw1jKsVtiul3Ulp5VnbXGbVVKVtMYMvehArX0zRVMC8a85Q5hkCmY7wngU/WOcW4SlzIFrMy5pZ6XhLxDGA3mODatpWxOKNFBthaucOJNTSoR5puaCsW8MNVQk3edwBK1YXa1RzlKywjTQfWtLBJWjKlWDMgpVJWLRLxb49UamoBIH1fLElXSuKbfJqRLTkVaQw9lh3kZ4qLOJCUoMHF694PD8BZSMHTrRcp7wRk7IDqqZY3KqIgvwXiaZbf2cM+0QJHGzuSSB6S97iIE8ThK16Tym68+TxJPWtsQAKYpbPGXy3LShTtKVdIuCTaOgmebjKIxRJRPrXCu6SKM8HiestXSLXqJs2/VdU8YY+yZOMwTKnJrTXKO1xg8D1ovBB62pxqCtk8NGEpNRjZG5odRKSuRpFEapNvLnuxYDWgqlChIr5yRNplLESTBGqgqWrFY58IgWXLF+8pjr99/DLdfyHmohJwDgRHd6IhyMD7fMr1+itUJ5J4exWs80DpB+sWrFfJgRdKuVlTyyiaktHKNmRVYarSu2t/RXG6xva/RaqEpei0qF2LTYJZGmPWk+UqsY0ux6je6ENJDHGVUkZQtVUScj1j9E/Qvv/yL/+69+8x/q73ib+rN/8D3+/B9+H4DvvLuh929P5/sH1XWKXO/uAXh3Hjm2YIH/1fufEPVPH2n1h3b3KODRuuOv/flf5t/6P/29n/rPuNSlLvV7r97+m0oBNUPMwnZUlfnuyHR3JzcqFLZF6Z1ML8o7ai3obiXu3Gki7o4yxTCGw37P9tWXsoqfIjlnrNGUopjGROc0y4ZhGseEdwrvLTFJRri1kle+HxMhFIxRWKPpnMXlimp/x/XasVpJDvv9NpBSxjlNyZI4Y7ViDhLHaJ0+r6dLFsC9LOlBW2nQnG6rPqTxMMYQ447paHj07CnGNmajjAmp9dTYKlkL9gPdaonru7Z1bqNdLUaJmqOk+HQdOWXi7WvSwz1YJczDKmadsybVWHTnidNEeLiXLXZrBpQ+NagyjdLmpNNTTMdjM9EIs1JpJbgepThsj6QYxXW8XIg2NCusdeJ6d6atlNthQ4EqBaUMdujo1itMt3jTRJ4a0FMTETM1BqrrMIsBXVq045kI0JrJthatKOJhy/7FN8TDUSZi3qIQ3addypQ952a4ilky2V2H0VZA6zmjFKQmMLTOiLTBKrphid9shEk7TU2/PIiEBCg5UmOSiVmYUPkNX7M0PJJ2TqQnRpBX6TgTjkdiEFqDPLUqYU3OEqeROcyUUnHdAr/o5dCgBMJujMEuxO2dpvmMPqpZfpZfDtK4KuHvKi0T5FIrNcyUaWp4LUNp7M8wTWLk6Xr+/+z9Waxt67qeBz1/2VrrxRhjFmuutXZ5StcVMcaAMbFJMIoAiSAiUDAhKELIiMIXcBFuuaIIF0SKkECGC0v4DkgkLBAYWVaCCBCcyDhyXJxyn733WnPOUfSitfaXXHxf73Md42Lts8/x2utk/LJ1zppnzjF60cboX3u/933eMG2w3sqKvkswSG5MFoJQ+ikX64cwH3Qgl7CQdYbdJx9z9+knhHHzQc2XC1SYr9eA0CrBxad7QVz1jr0ojeaD0tprFR/tquQIDaMZ7yQMZwVjZZrapYNcb5u7W1F1tZ2K3sR2EoK2jnXaupKXMzkvYCy1VsLNVvzaWmdqjMFGvYmulbYk/PTjoY2+u7nhv/rd3wfAr8wH/tJnv7lq3+/8xi1/9j/9e7kZAzeb3xoW6Ju0AkIr+W/88t8U3JZz/Llv/9xvytf/F375b11uXRi842ff7H9Tvu7zeT7P5yf/fHmOaM70kmi10tYkv9BPJ2rKkoaOI5oUwFhRhVyM9BhJpzP18SDrRyDlxOnxLY/3n3E8LtTaCMHinSOtBW9hOzlKM5zmyjQ4XLTk3CgpMwzSpX5exMs2jp7dJuKswNzntdDoxGjZ7wLbTSDnzrIuUoFoLbnAoIic1lQZLbqGtZZcBB9UesMZp0EScEY9lM7ijDShtyytLMvyxOHxgeC9pqaNKj7yqdlsIN7cMt3cyED5xQ/ui81B6xOJG1lhPr6FddFU/SV84wUD5a1+H0s6nSjHI6Z3CWhoqqiXIsOgdeLjNIZSCnldNUTmdZgBmngd87IiUPPItNmKN1LVTOs8xhtw9mo3wMqga2Ng2O9loNMGIn12OoPq9FAbrSTMMGlyXtq5uChjiO8UJ4Nmb43zw3sOn32fuiblJUjNpw1eVtal0jTkU3KlFcO43WGtpeSkj1W+vgvhyrR1QyDe7gjbHeRMmWfstBEvtMLMe060vFIrtLRKAKvpk3Iea1VR19e3pkxeEmmZZX19wTKpbdIES84LeVlpHTbbiTBqYKkLd9S5gAseeqXOK1iDGUbqsoLpxGnEeyEqXBlmRtTglmbautBLoTbFNZVEKQVrHMNmg9/vaClTllnE6VyBQskrTt/ruiYtXtC0u2rgxsggevPpJ9x9+9vaIqUhujBoCUOGBr1malpI5zP1fKLXgotBSApN28hArlEkBb+eFkoRf6uo7I5WGk5tPq01HYQtLjim2xvCOEom3xqxBRkJf9XlhEGG02YauYmvNs8LfrsRGtq6UteMHQI2Onop4o+tXXmtP154xxjDC+X33oSBn9+9vP7f/tVf+5t8fzn+hr7ufgr8L/7r/1G8tWyGH0/9/FHOKw299Qz//b/91wH4a/tb/uKbb/6Gvt6/8Mt/i2+uM198lX/+0xv+O//U7+F//hf/+o/7cJ/P83k+P+Hny//28p6ek3gUz2dyKjhjCZutrDrzqtxEUb96COTWKA+PGqiRNPV8eODx3Q84nU7Mc8E7w3YTOM0FemG/8TJkrhXnDJvJcZ6rrNi3ATosWQaa25vIdhtwCgZPSXyfa6pYa3h1NxKjZ1mKcB2toRT9EDOd8ykTBlEvSylsNhE6rGvBWqTOVFfypmlwyUr7kqSMO01X+LUK2PztD38R5z23L1+Ij9J6Wqm4YWB6/VqYoDqQy3pbBtuexJJgXKR2Q3r/jnJ6wpT0QUk0nu4D1CJcRCvQ73I+0or4UkGGJ7IELYzzwum0okKXlLTyUQJjLkYhGXhHXUXlNsayub3DOI8F/BjFT2kFnYQ1MuQkrUW0luFmx3Rzi5smeQz1skvV8JKqfK0K9NxOW/VAispyrV1sfAgyIa/p6e1nHN+9pZ6EbUlwuBCUcdnkBqkUfIwCKzeezd1e1Lta1MQgq2fxbcr/Hncbwm6DjZF6OskqfBzxUWoye9OhuVbKkujrgnWeUiWVbr1UStY1yQq3VFqV6yKdZ6E7VFmlO++oreEtrKcj3RpMdGzGSW7afMQap1QHi/OAKdRFQmUuToKjwjC+fEnwGvK6QOKtBVN1aE6CRmqNskrYpyPeVRs8brMRXqrtkhAvGUOj5CyKbO/kZeEyeFrEItO7bAVccOw/+YSbTz8V5udFEbcXJVGqMsWKsrCeZ8r5KKOsj/SUrv7Z3ht4L8qpQaD5zmERX633g6zx/cUSAN4Ld9bHwPTqJXG7xcSgvmIEcWoMPa2C7WqJRhXmrbNS4rDdiOJ7XqU1yljxBSdRxGttYskwnh9vDP31xxnL9IWmpn/mW78LvY3hX/nb/xbtggPhmne7novV88//t/9xJl27+6+w9ckAG/Ww/5HH9/zhx/cA/IVv/BR/e7MDLveVf+9X0PTOf+V7v/D/N4SCPK8pqtf6t+TRP5/n83x+Us6XHkTz4Z70dCCdZ133eUER1QK1yVregAlewgznRStAhcV4Pjzy+P4zTodHcioYY9hsvCbXE9uNNKDMa5P2osFzXgqlGrw37DeRZZVferf7wDB68bBZUeRK7dw/Zs5zZjt57u5Gcu48HtbrL/DeIXjH+ZyJwbLZRuYl44PhZj9SSqOoNyxewNoIlqkjntirsKZoHIDSOmGIOCtr5/vPfhlbK/vXr3HOEW/vGPc34sEsSZGLsqa/8EVNCHTjyOcT+elRWmXQQcM4GSgvg8EQ6EA+n2jzDBjB9ijuqWn62oQoapyzlNYp57MoUcZcBwgXLX67kfBOKYw3W/HWOQkGUQrkKmidLsnwWssHdqzzxJs904tbHWIQj+fFanD5JOniUW04/GaLoUnDD12VPEE+WQXFSwDuwPndW8q8yGOw4iW13qlSWTCmy2rVREptjNu9oMRqo/Uqg2/v+hpaypowXQoFwm4LGPrpjPEBt9+KhbNXWtHH3Ap5mSGtGKzceAxRPJmtAbI2loFHges5Ya0T6Pr1E7YzDIG8iJrkfZCB11vitMFZHa6tvczgV5SV8ZYyn3E+Mt3eKnpM/LgA3Qh/VQDxnV4rOQlxoKRETQvWGglADQNlkWsG08kpqw/XEN0gXfM5Y73V8gWLbUbuhZwQEG4//ZTdmzeABLeM0c72XqFIOKk3CWClNVOPB2lkMo7W9TF2oGkAMEvNrijX8toY26Q1DP1ZMVZuIvX1cUNkfHFL3O0k5GaNbOTVvmCsF6JHL5SWqS2Lct7BjaOgtNZKWVd67bhtAK05bdbhw4Dpouhe/a6/BceaD0rzf+tn//D1z3+wnvjffU98pdKQbPgf/hf/MD/3yf7HVmh/K45ExuT8s7/2i9c//5d++ndRzN/79fvPfvY9fmo+/X0H/T/2O9/wX/uTP8+f+7/9zd/Mh/p8ns/z+Qk7X3oQXe7fs54TplZBDBnoreCCcia91ATWa/BF/GanhyeOj+84Hu6ZZ0E0DYMEaFKSNfw0iX+z1IbzolrW3thMyjssnTWJr9N5y3murEtjuwvEwZGXxuEpkVLhdh/ZbKKoqLle2Nk4a8i5sebCtPHKHq1sNxIOSWsmNwlCxSFqgldWvSHIF2l0WjWahIaqH5TOWSwNbwylG3pPPD29xe93vHz1mmG/V8wOgBGPJEhTEGjNYyKdj/R11hAXdDRhPgQoDWPFTpqXlXw+Y1vBeQkCXbiRzWg6H4s14m1dj2fSPEsdqxPbRM0NHyIuRGkRMlxVT6lC1ER5GIAuWB1raamo17Ljh4Hhdk/c32C/oF0YRXQButKVAd34SPRB1vBXHQgN/SjYXj2Q6/nI8vRIXrTK0QCD8GqdDqutio8QDKZ1hv1eVvVZet7BiP/VCg6rloSLnuF2J0p+zvSyYkLAjZOkxY34hqUrPlEvao0N11CNMVa9j+p11dBVXhNN1dKSkna8G4qG8qx3MkBFf11l+zAQhlFCNtaIEluqDlRidyxzwQ+RYbOVFqmudICLtzItOmyLct6a2Gdar0JNUHpDh6vS2ZVw0LoRSoAGUXrJV1+nH6OosK2JF3q74ebjbzDdvbiyQI3wpMA4oSDYi10jsBxn0vt32FbVdVGFnWudbgI6uUhavl5sMarq244opegNTJOfYWPBbyLj7Z5ws9dapS5htVJoZcUOG21/apR1IaXztdHLIMN0XRJ5nmUgdR0XA3ixAMgQKr5WO8arxeS3+nxxwPx03PHf/Nl/DICf+p0Dn35XvJ/zqTFt7U/kMHo5X3xk/71f+I0HjoyRUpLN4DmvXz9ywfN5Ps/ny50vPYiWk7AohYfZpeN6iCKAdUMtWdU56L0yPx043r/n4f4ty7JA7wRvadaScsfaQhwETJ0buC6J+No63gmwe11F3RijJOaP56oNMIa7u4EQHcvSOB5FZbq7lYrJw2EVJccAGJw1rEmCFtEp7sm5LzT/SALYG8Hq+AsCUdfFF4zUtUWq6weaM9f6SIDapbHJ9E6rR9L5gV4/hpwwBHABAVNWQFaSrXXS4Yl0eMAaHSYuX7GL2msk8Eunk88z+XgUbFIIH9qC9HHKgOKw3pLWlbxmGSQUAN9qFbbpVuH6oMDwhbpm/DRdAen6/2T12jt1XpVNaZhubxhv7/BD5IrF8XJDYXT9fknH996xwySqla6q6RIykoHsouxBzYV0fqLllbYm6roIfsoFqpGyAIOhpVUVMGFYhmkU5E/u4tmtjSvr8oLBcobx7gY/behJWqrcuJEBWIfn3kRR7HmhlkxH1DaaqOBYsF2Gs14UpwSUtIpPtTawXYJQrVOS/FkYIliHD0YG+eDxIXCtGxUXiIDna5WbDqU5jDc74iSr5EuIBidDYKtVlGr17OZlkdYnBdF7H6SCNhdqKTI4OkGi1ZSkTrQbeV+7tD+1ItSCUrXdKDjcOHLzyTfZvHwt1IZL5axRf3NXe4BeB+v9e+rTe2lr8k7wslmqc01rIvP1oil4GaqtlhZ0pQk4q61al+Q8HTcExhd3xN1e2KFXX3GXm4rLloFOzSvL8YnurLYoyc83uulAvc/WW3lNSsOql7qt6zX93+tXOwT94t9Y+cW/sV7/+w/9sS3Oi0p9+/IfnTf0qzh/6g9+k1/6/Mi/+v/+5a/6oTyf5/N8fovOl8c3WYPHYIPDxoCJgQYyPJ7nq98xLQvL4YHHh3ecT0dSKtA7zlioYE0nBvnQL1WG01I6uVZRFp3VtGxnGiVU9PSUOK+FJXfutp79PjIMnvOpMC+CmXFOVne9f8AvgcLpS7uqKRiDw3GJ0XTE5+mckTBKl8AERgfQa35GPqgN0gUO2rakSpQ3lt4qpVR8sNhmOdx/RtzsePWtnyZahzGCzJEWKkteVtaH99TzUeDwlxWWKlvdNEy/9KVX6nympSRrczHlIR7Wpkgnbd2xnZwT6bzIhtxrS5ETlZQGPVVaN7ScJYVsLXG3w3lpOzLO0VYJ+VwEIeskoRy3G+LNrdR8tiZrbw1I9ZJkCLyUGGhwzdClj7VLoESattzVQ9p6p6wL+fxES9KFXkvGT1IWUGsBGwAJrJVccS4SxhHnhAzQcsEEpwzzD9dAbRU3RobtRlqx5kUe17jhyrnVwFPNio/qMrC3qr5Sowpu7XTblAYg9oZ6PlNTkQHOWmL018Gqns5XLBJqiwjjJOt1ACdaci1ZGpguAa8uCfhhOxGmjXqE+xW7dGGGQudDI9NCRxBTJSfcKOUI0vq0yoVsPUVxVd50TKnavdDk+s3abIVgvnDQcOy++VNMd7eyJbhco1xUWFAvBt1a0uMD5em9DOwXbmzOGthywr5tlVIlDGV9xBmxPVyqu1qXOlm5CZE2MzcOTB+9Jmy21+9rdKBsaaYZbVBqRiwGZcXtNoAR1XvY0PJMz0l+Z0RHyw2rTWzOOIztkLPYP1qnr+sXthk/Geev/usnAJyH3/2PfWB7bveO3e3XF77/9zs//fGeV7uBd8f1H/6Xn8/zeT5fu/OlB1EXo3j0higr6laVwyj+pfV85vD4ntPDA/PpiZTFB+qsofYPmCTjrORYlCtYa5cqyeAkQGMN1ktl53wunGdRUYK3TJPjdh/wwXGeMzlLpWcHWetbmXUwMojUKuqdtQZnrXIzm6p1l82mDEZi2zS6ruz0yrVFSS2dV8+9QVTVpgOctaLMtNp1RW6leaksvPu1XyaOG27ffCrqkAvUnEiP7ynHJ2hF1VkngReMegtlwLBhwITA/O6tQOVj1I7zflXMrul1A60WijbDeO9VMRX/IkbQO7UJ9klwUqIGWmN1zS+sxZaFiylKmwxVYT8Qtzv8OF2HSOPch4GyFEnDWwsmiK/VWEy/sB/19VM+6MUr2GojHZ9Ip0dhZRZRwjFG1GBj6EZQVCUl6Ia42csat19W2U0GSC8VnvQkCpyBYbslTKPaDTpWg15dh3JAIPE50Vu+wLrEIoG+thhVRisWGdYrnbyupCVBb4ISip5WOnEzyNe3VhipGhTyLlyVzIs/sNRVWazmesPgx4EwTer95arKuSBA/t4qHUutah9wgqLq2krkRvGDiqqclO8pZIjWK96LnaHVfiU71CzqrXEGHzw2DpRacVjaMpPOnrjZiPqJU2h8pyM1v6U21ofP6MsRg7xnLRdaEXarDLaG3gp5WSi1Y7ik5aVBS38kFT+mxRl03ODZvH4ldIOLr1IftzHa7tU7vWRKWqlVaB5G279sHK+vY29dm8JE4W6lSZGCslvl5shcyROU+uV/o/4jPLXAX/s3z9f/fvGR59XHH36lf+tnBpz/yV3hf9nzT/7+b/Bv/q3P+b//e5991Q/l+Tyf5/NbcL70IOo3G/XlFZr6uqy11FJ4ePsZD5//gOV0FFWldvF0ea5pW2MMFbQTvQsjuktFX+8Cym4dUmqCVMoVJ7MVPjimTWAa5cPufJbVr3OyyrNGGJ0d6ZGXBHsjeCetO0bnpNYp2g0eonASjTU4Y2UdC9cPOWHASyLeI4N0R/ygkiEyhCjrUaMrdee0W/wylBpY5xM//KW/jQ0juzjRj0+U04GeF1xw0IQ7aUMU5aVUakt0Ywm7O4bNVhTF3jl89kO8gszbteNcqhC7KqjogAzaXGTUs4mobsYoF9U6wfR4o0EodXmWfPUnGmsw3hOsJW4mwjjJ0G3MNYzUW8V09WOiwSofMT5qHkbWvXoRCPBejH/iWZxn0vFIOh2padWBmcsoKAUKIOlu9SKGccQHLwNOrleoPxhtTBLGp98M+M1GrpNSRAVVcH7TAbibRsuFsi70VtX73Om9YrB07HVItN5hLiv3JVFSouQiaXQjr28tRZqWVi1MGEesEyX3UlrQmvwdY0W5q0VT+M5ivCfutoTNpMisIC/EpQoVxG9roORMPs/0VrC90dYFusFtBBXU1K9tnKOpJ7qWFYv8XJourFzxz2apQcVoKl083s56wjjQzyeSkZ+ruNmIrQJkWHNBoP3vPpfWMMRre/3B07VCr5XeiyjaFawO5fJg+/Xmq+vvFmOkFjVMgc3rl/hpy+WGq3e9PrUu1rqJ1irp8EQzTe0eWs0aBe3Us9AVemvi2rDQuxFl30BbPtRbSsOU8mH/EXlEf9xz/3nh/vMPNoLzseGcvE4///t/PBbqV33+k7//G/ytHzzx+dPyVT+U5/N8ns9v8vnSg2htjZZXgZY7YTM+PTzwdP+O49O9dFLratjYSqudtDaGYPFegki9d1nPg96pC0g+5XodHlOW9Xf0lgqMo2e7H7DGiOKyKt/PK0ZJk8NVUUrOO2KAYvp1CK21qVpprgxEY6xaGDvdqM9OV62SnJZ/b4yhZBl0hyEAnZw1fNEEC2S8pMWdDlCt9Wt/eF4qrT3y9nu/SE6JcZIhyo0yaAB0K73wpFVWr8PEcPuCsL/FNlG4httXNGNJj+8xl7pF9cKVkq/rdIOozQ1J9Rsrg1NrVf29FosR9qv32ClCM9qJXq51htZ7jLOEacSPEz7Eq4p4GWyvA6AO3zj/AeGloSOVXrlA7Q3qN82Z+fhIPZ0py0pO61WhrUnwQ2YShbb1RlszzkfiMGGD/3BDpB3ovctqmSpqWrzZErYb4UEuSR7XZdgHGYRbpaZETSs0GcJau/h0ga74JSs+1Ityl84zNcnQefEU5nkhrTObm72k51MCGnYYsdZfn3fH4nxQa0rRGxmpTLAhMNzeEjZbubnpirFyDpOThn3kJqGWwno6igLdBayPtZhhkJu6RYZQLHQnjUvUQk6ZoENvTkK1MK7LUN8EzdQxciMXIsZJgUGj0U9nQS+VRHzxSlVLJ6D8+/dQVvwoPfeto+E3qZdttdJypqRC6wYXPc6KRaau+QPpAQnUGSO0DRc904s7CVvVCt6LFGi0/rWLJabXRHp6oOQFO06Y4AXL5CwGqUVFa1uN+pPLKvYOi3hzxbttBfNlkCG5I6HBr+H5tV8U7zxGQk6X8+pjzzd/eviKHtVv7PyRn/uIITr+x/+Hf4fHc/6H/4Pn83yez9fmfOlBNB2esFaUgfnxzMPnP+T89CDJZQRlGKMEMdJacd4yOumHbl1qMTFG2JwdTcJnSSj3Ti2NUiWoFLzFO8MweWLw9NrJvZGrDImb6HFOKzdrU5anJUZ3DS6AKKOX/925y4r9EmLSrazp6Oc1FwXUWVlF59wwDsLg0RgFa5IP2Uvq13lVRa2s/UutDGNknkVhCt7hLMzvf0CvmVff/CnCOAIGfMA6Q1lXBZUbws1Lhts7XAj0luk5AQ4TApvXH+OGkdOv/KIMRa1Rk6iRNnwht246PgZakS3qpV6zd/DOXxFIxkUoTUgHcPXnGe9x40hQFRRdk+qEfjHeXlft3TlsGGXIa0UV0Korenv1gRoERp6XE+l8oiwr9TwL11Qfd6/io3RREuc1N0quBB/wXvyi7cJBdZ7WBSXVapVh0zTCzY6439FSoqeEDVFWvKritlqouVCWhbqcZajhC8Ns/7ASNk4G6Fa7BJLUS2q72FXSunJ8OtNaIURPzYWcM701fIw4FDGGVTyVlgqsC92IZaT3RpgmhrtbwrD5gELSY3qjUa9J95oS6TzL87twSocBY+X7t5yoa5bB1EjdrjNWUFvDyLomXK9XPK3tEuxyUQkYXRBKLgR6r7TSaLbjceLt1BuJePdaVuGP7+k0aVKjy7W2zvQiDVCSSCwy+BovCrKTrUM+S+tUVx+5tWr1oBJ3GxlCh/HqnUUVTavVofROTwvr8UCpWTBjNLEp1Ibx0lR2UclNE9pBWlYcBtMr7ZxkK+E9NSUumDL5GTVyo/d1Ph0+/7UPz+HhXbkOqb/zPzBxc/f1CDz9ge+8ZPAO+Jq/H8/n+TyfX3e+vEfUWXJeef+DH/Lw9ofQ0nUdbugEb3RdLKt00DyBwq1jlPXgPMvqdAiOu7tA77AujXYuWNsI3jCOnmHwpFQpGjTqvTNEHTZbl975Jv5S52VdXat0ixsra0hvBffUaqN18IrTaa2Jp1QrQS8f+a2J59Q6K0NxDHinK76KJO8NjEFTt0hzUtP1orGd3gxPjzM+WMYx6Ie9KLnt8T2b/S1xs8GHQKdRzok0z7gwMbz+iLjZYlqBnGRwcl7T9g5aYdjdUF6+5ul7v0orFWssIUZwjnSeCUMk3OxEYVWEUe8Ga5wM2MrgpEtLkHgPu4RfnGCtwmZi2O8+wLyvnEiFlNci4R463Uep8mxVHrMTBNMHxUoGdmMttXfW0wMlJ8q6UM+LDFyda+e4UcqBwVDXQjeWcZhkiC1qyYhB6jSrDI2GTthIMMd7i9/vKctCrxUXR/WkauK8SGf78vREW1cByVvx2Xb1Alov9IPe0K7xSsqrQtIrLkRMhPlw4PR4oOSC15ugmgvT7R2bTz5lOZ04/fAzfAwXl6mm3AvWeWqtlFoYbvZMdy+lScmqp7degl3IzUgXtS6vJ/J5pqWLRabhhglwlGXRZiF5/bEWGwPBOlrOMhgbR9yMvL9/IACuVToeHxxN808+RvUtG0yTylAXA8bb6w1Yfnqk5SQ/mylBkOdYzprab1W8uM7RSxZbiCqRYs3opFUsPnJTabVcwdNSIm4HplevsGHAxvBhrV4yxocr4qrXRF5OrKeDhvI8dZGfHTsO9FLol8Y3VTjTecbrjZUBzBAhRPq6imJqFY9kDWnNgsv6bXTy2snKZP63//WT2pDEbvQf+VM/mZzSy/kf/ek/wp/5X/4bLPkn07f7fJ7P8/nRz5ceRH/wa9/j8P4tdXmS9TOWoJWaApoWv1Wt/eqZrB3panee0znTWmMzOfZ3IyEIRHvJcJpXvJV13Th6nBWs00VldM7itQJ0WSrWdP0zTy5iA+i1Uop4InvteH9J56I92jIIGfWiXUK/FyXWmA898y2LkmmtDF5Vk9PQP4D7jcFaR60dr965ZRV19mY/yCDVZQhtreO0Zefd934J6zyb/R3eyYf88OI14+0d1nuoqoJa8VriNL1bpcUon86c7x8kCOZFWao1k5+k09x07X4HZSzKYOWs1JHKoKhr/VIkhOUcJkZsjIRhJAzjVfy8glhb/bCyRpBFJo6Cherlw9AMH5JdVy+pp+TMcnqirjNlXmhLxsVAzQ03jdgQaDlpil/GfO8HUdQMMoevRXyToH9PBwxvCdtRGrPiRDkc6BgZADX803un1kY9L9R1lpDY5bnptdCNvX6/XirWO1pv5HXB0EmnFR+E9zkfT5wOJ2loigPTNNANTK9e8eJnfhY/bdnVih23zJ/9kE2U9qBapXJVrCCN7UevmV6+EkzU5X1TRid0DcyIHr8ej9T1DF0G2tq6vFfOsZ5OYCX53Zq8zyY6ohffMV2qPnsX3+rrj14zn47MhxO73ShQ/FIYowz0/WLxpONCFBUzeozp5HmR9iNZc4jlRtFMUt9acJutDKFZmrxa6xgfRGG+SPftQ4DNx4APokiGKTK9eokdBjDSHtZLoq1yo+NClEBdmil5pZSE1RuB1uQGycURVr1GvCTve6uk4xmDlXCk87IWCQNUqfXEffDi1jVTzgs5pS/7a/Jrd9L6Rf9r5y//a49MG8sf/SdvvrLH9A86r/cjP8Fz8vN5Ps/nN3C+9CD6/vu/gEWUi454M+tV7ZIwj6XjFZ3UEJZiKaIS7TeeaXT4KAEig+F0rhyOmZwK4+iIQQa7VGRt6L1hHAQ9lEsjJflAtd4KMD9L8rUDKavCqZgmtdLhvMX3D4/VWVFQWzes6pELQfA/pYgbzKvyU0sjF1FJiwh3uNaviKOcKxaBgp8XYT9uBicrVCMKrWyDdR1bG21ZePsrf4ebl99k/8mn3Hzz2wy7HdRCz4on8VEULSOBql4S2MD57Wccv/crdJqoR8ZS1pXltFByElXOelVRRd10CrY3posi2ASMT5XWHxMUEh8Hhv0OPwx0VY5E0Ww6BEtQiFZpSO+580G9lpKaNi6KmtIEWI+BbgI5ZdLhkbKeaEsSos/gaesq4ZgxitJairgDvBelsiHkgChoK+u9IKWUcykKfGG83eF9wA6jMFa9F1VPlfSWs2C5sgwvzgvrtBojDM/ONahDyfL8TSdpF7xFbraGzUSvldPDI/PxjDEwjCOb/Q7rLOH2lrvv/jTWOkzr+GHi5be/zbvWOL/9jFFDQFiDobL/9JuMLz8W9bMWsHqRGSMhr1okLIXhfP+euizE3Ua8qd4RNiN0w3I8CK7Jekw3VGPwmxFXZYVfNdDVEZW/G7Fo7Ld74rhlmU+YnIkx6pZDle9upBAgGMwYJfwkSSK8titYp+gupO0IDHYaJdF+qRu1DhON3lB9UMBddNS1EMdBr4fMsN2oEhqlPWs5y3tYKt3K9+utQIOSCqVkFYBFAW7rIqv8y/WkYb2ODOKmdVyU1qVujNQBzScJIFpDv/iqjZRO9Aqj1lX+djl/d9HRH/0n9mx2Xx8f7F/47/5J/nP/0//L1a3xfJ7P8/l6ny+fmr/0YNsu4aIsqmTvqP8PgcJ7Q66WmqT+cDM5Ygg4VU+k7x2Op8w8J0pp7LaSZE6piqfNGayFGD25dAHOmy7DgrGsa2VNInVaKylfMIyDFYWzd0JwWAtr0g93RTgBwi3N4mMFUUGrthkZJ9Dr2mTwNdaqj68LH5IvpKqNYVmlpz4OEkhJa8EG8fhd+KRCNtLh2hnm0wkX3/Hxi99FcJa+puu6UiZXUf1QtmNeVg4/+AXW+3d4L13htM56nClpBTqbm73wRYOnW4/pEBRJY2KAWmW7m4sMA9ZhhgEfPGEnTUMoUFzeS/vBb2utDBElUzG4OAn3tF3qFIMquEbUNwPdipK7no60tBCHiKWxpCQr7ipp69Ya5bzIa6+vtbURQ5dVcAwaRtG0s6poxnaME5+mURtAnWd8CNgoTNOi0PoGEqbLGa+e494dzosNo17UPEUBYS15WWhVGo0ahuF2T0uF+biQTjPeOUIc8NHjomf38cdsPvpUrRgdgqeXhG2VV9/+Nschsr57S2uFOI5Mr14Spu01eMOFLqCIKAFbynM/vf2Mcjrjp5E8C1kgbEcMkA4zNAhObl6qccTdhEkrZVlIS8Z5jx9GWi+4aUPYTEJcsJ5gBF3l4+VXQafVomK4hJpcjLR1oeYkITc+2IYvvuJuLWUtQk2w0udeloWSpDveqCKLhrNyqoTo1GbhqSnjh4HxxUtBUbUmmwGtBZV1ufyM9VwoKbGeTtSScdHhfaDVLMGoyxrEqaxvLDUlUUJjuKr8xgoto9WG8RJEFKCDKPx1WQlDUMzW1/OE+Osf+8uPPb/vj2y/okfzm3OMgdsp8nD+7atUP5/n8++n8+Vd6gaWVHXjarDukjBGfV4SAjqfKtbDfhtw3pBL43yueGcYJ09KneM5M58TmyngNvG6Xg/R4625MgVTUkC9NaxZUsQSkpdfrk6H0G5kQK4NXHTSeawBKGuMVDciqBqrIScfvXxg0a7peOftNZ1fapc2F9PpGIZgryuh2jq1QtJqzFGH0FKbQMTp1Fx1HW4kTAVXXI4PntPjA5/9e3+Nj3/mdzLdvQRNpWNlhdtrpnXD/PTI4Xu/jClFOa6e1ir56Uit0r3tp0iYBlrTgFZa8MHLIOe8VHheOJ5qCDPBEYYgKui01b7yqqlyo0GQdgWd91YhjMRhwrR8bde51gI5CyXJn/uRWqEcH6EkwU3ljLOOMIys5zPiS7UfbmYUH2WtBXNpavIf/I7m0mnuVB01MsQYGZ5rFpWwGx0sa9eu9k5JM70WQohCSagNnMF4Sy312pyFugmEQWnpNtK6IW4nainMhyN5WXBWaAIuBsbbG/affErcbOWGLIwS1gG9CRhwrXHzyTc4DxPr/WdsXr1S1U5rPLm8lmqZ0HBTXVdOn39OXRacD5RlpbdKGEfhwWYJbfjgqbVT6Gxutji1xbTSiONImEZqrXg74vTfus2O+f6BfP+OYbuVcJZ6gK08KGwMWCz5fBTFfZAVvTFiTxFigbzOhCBNXynTTwtpmSmpiu+1iSpt1bdKk82JC0JmKCkRNhPTy1eisne90XNeyAz1UiAgCndOM+vhqCQIj8FTVvGsm+DlMbSGVRZqbx3blPGLkZuma52sYLZ6LUK60PIIMAybjVxX49cjYR6iIQy/fvD8o/+J/ZUs8tvlGGP4c3/mj/Of/5f+r1/1Q3k+z+f5/CacLz2IzmuhNYhBU+ddWokuQZDaOpXOtBHv2GkupCSsyO3kGUbxrp3nRG2N7Vb63NdU6BpQcZdfmFcFQqDtc5K1e2ud0rsKnAajQ6iEpay2IonaaZBh0Wk4opUPAycgTT1YQryW0QOy4m9dSS9Iu44SSjHS80jKXb2rhuA18GAtQ/CUqg5abYgyVnqzS5PXy3rLacmMwTI//ID3vzbx0TASrYMwyJq4ZtLpxOntW1o+yfCsHfdlLYrFCTjT5IPYSYViTQnnPH631cRzoa7LlXt6xQUEaf4J2y1umCRwplDw3jW5XutV1e3W4oZJ8Ed0BbUbjAsarkGGqtboLlJbJz++uw6yNEHzCOFpJIyQ1wWq2BpkCLUSELoklhWWfuGPin8T6E5UOg3HXLi0VrmctUhq3KtqVpkAAQAASURBVOhQVdUH64ZREEVVHovzQa+xJoqqc9RWSWlRC23DdIMNnjSvpMNBwPWtEcdI2IwMd3fs33widoYOxgeaJJY+XMcXv6c1xGnA21fCrVTYvrFiOaAjIH8FPaTTgfn+XtfhCGPVCPOy1U5fklzPTsJy3Ro2m4kQvLBlvWXY7yXoUyvegIlRUuPecT4cSPf3DMOIj1GZqroRcEa1QUjLmdYq8faOuBV+aMuZpuB8MNgYMTFKo9M8k1fx+hrppVWfq9HfF4L6siFol3xj2G0YX79WUoFRxJK/YpmMvn70Rkkr+Xyi1yq2ACsXgXh75f3vuWq2TxTanrJcJ85db6TpXcJe+jZ1K78TeslQuyi/Y8QEL77Wn8Dz4qNf/+v7k+8EvvHdr8fQ/OMeY+D3fuuO/++vPnzVD+X5PJ/n82OeL1/xaWTtDsLJrNrmo3QbDIbz0nk6CbYIYIyW/S4yjf46IFonIZtWJTxi6ASt2OtNEE2tS8OS0SFkHAUBVK0h5Spr++Dw+u/MhexSm4SHnASnpPpSBsbLcFtK022zhi0uNKLWyKlqCAlMbwTrcNqT3Vql50Yp8kEavL2+HsaoZ7VUjOlYrAwk+lr11jUZLCvJ211kGALHU+btv/s3aCbwyc/+PB5LzoX5/XvOn3+GpWJjEGZlytA7IQ44b4WviXhIAcEJTZN0xccoH8pzlTBG69Jo0zs2OOJ+T6uFPJ/ww/RBBe0dSsYoEqjkRHOOMO2wvQrs3sj3xskwK7WVHYyjdkM5Hal5waFs0Qugvqoia5Ce8BBYHx5loLb+OrACijkSPE+/rH+LrNjjZoONUXnlssq21gliKF0SzhLg6srptEG8j7UjyW1rtJlIVUvvqKVQ06IqqlyjOENeV6pyWr13rEthmkY2H71m8/INfhhVSZW/b66hLl0VXGtAH2GdpRCgFBm2nJNAz6U/Xn8G0vHA+nBPK/Va72qdx4eB1oXHab2FbmnWYYbA6JxEmmqFWmW4NYaaFe90IUZ0WA4nWBe2NzttHpI0+6Uq1FopBiil0AwM+xvCMMhrk2SVrdR5Cfw4R0uJejyR50UCi8j71y5WjCZvvvfSMCWe4Ep8cUvc78UTKj8w15/Vlhe5BdTHU/Mq2CsMLkYZTo20vVGqhI16w3pPRywtnBZ8jGIZ6BWC+p41wGW6XEOlyvVtqtwWGSVi4Iw2fX215+61Z9x8GIitMfzuP7z5B/yL397HO8u/+E//Qf70v/yXv+qH8nyez/P5Mc+XH0QRRauZrsl4o2tM4VnmtbGURq4N0+FmF9hvw7VLvrZ+XRG11mlI4CkGSbf3Lkim2rpyp7swRw2aypfKzss63nl7XdV1DDk3UipqEZBEfgjyvZdV2J/TIP9OVtqXxyLfKxX5APTOYA3YEKQP3Bp6LoKAagLij9aIl9VL6r01aedpCtUPwXHpuzbOYL0lJxnCb28nwPBwv3Capcv9h7/wN4neEvcvKccz5XQUddBY6jkBHee9BknQIImAzjEGZx1uCPLfvWu1pYRDZB3ZwDviNOLGKNWYJlLmMyUtEtZqXbE7hZozZcnkZZZmo97x252unCWkgqb4pdLUkNeFfDpiWhWlGriwQ8UVoAOzF06laQZng1xZWqUq4aymqqwoyzJnd2VtbsQT6qzCzy81klmh9MIgzYpusur3bPq1kC+l8HTxP3bTaSVJT3tteqUbsXFYR5gmQh/ovbIczvjRsn/zMZuXr6SlySndoDdR2C7mSWvBRXrO1PMB0lnW/xeV2Mpz6DnRjUNA6oX16YH18YmWMq2Kd9UPA84HUft0dV9Lo1lHGAacNbSUKSXjnMMOozQlzbM8Z+vo3tEqrOcjfc3EccD6cK33vA6iytukC5Rs2O6wzokNoOl708A4I6q0d7RSyctCmhe96RKbBw65ZopU7V78oBI0g3G/Y7i5/bB2L/UDa7VljHUY66Fn8ulAKQWsww4R552EqYy0ZtUlgZObJBcHeSxVbjhx4er/hk5Lq6jjgPFGqk3VOmK0ktVNkU6HUtU/+o/u+GD41s/GX/dnn3wrsr357dcj/+OcwTv+qT/0Lf7iX/3Vr/qhPJ/n83x+jPMjkYxl7jHUi1eySm95rR1rYfAG7y3TEJhGaUdJij6yGBkokQH0UrPYO6ylSiBI09qykoeiQ4mzH8D47soG7Vz6y6+qo5G6z1w6y5KEOaoezSH6a3o9BC//piNKSJOByaky6LUaNOeqwHxR9GIQjBRG1M0GitFpGCy99mufPa0zDI7aIK2FYbBstgPzUnl6nNWXaJimwOAKD9//Reqvfc5m2jJtBu18lw/PC86q5iQ1q81cXxMbvFR0qmrUu8FY6famqQg5RPw44Ifh2gKFc/hpKwPG6YAft9ClNWg5HIXZqQGrXiUFP928lOrD3rS7XNmtKdFKkmYpRSUZY67NS9Z5aY9qnbImGbJyvXoSm5WAmHHQmpXhLVesl5udMA1Yv8N6q4xPo75RaLnQc75SHGqW1aqxDrzV90US40a9ularYUvOmqZOlFTEgvEhhSO1oPoa11QZdjvuXrxi8/KFDKFeQlrXNW8pdC/DGc5Tzif6fFC8lfaiW03OtyavqxNPbE2J5eGB9emJmrI2XHXiuJF1/IWHaaT5xwxBrBXW0JaVuq7iiVT8VM2FVosqu46cMvl8preqLVlGvodz15Bar1W+Np22ykpciAuWVoXbaXQTYn0UikGrEoo6zRoaEwIBRuwswqC1ghrzjp4LboxsXr4mbDbofYYk3C/Ko7N066WuN62k+SC+8d4x3uGix1rZhpR5pSUN+xmDsUJpoEMYJ8FMqfWh08RWUFTVtVbW+LXitQHKOCdcUSvXoY3iK/6tPD/ze0biF7ydPhg+/lb8B/yL5wMwRsc/94//HEOw/O//n7/8VT+c5/N8ns9v8Hx5RdSK//KqiBjwVlYkqUu/fPCW3UYrAVu/bI2lclKRTpcPemuh5s6aNYRiPsDMUdSMtBvK6tBb8etd+rlB2pkuQw9GfJi2w82NJ+fKslb2u0FDSLJuN8ZfP1iaBpokzS5qae8dawTlNM8Fa4wEY7wMwL2B8RKaaqr+WuPBSLd9Wis+gA2OdZXk9nbrGafI8Zg4HNbrmjcGy+2tcCDv3z1SywlevyFEj3Me6710qncNDjlPTau0DMWAG0dM8LRc5UNc19i9dREAncPFiB8GDQEZ9SQGOkYVPCMDbq2UNTO/f6JkUeN8iIQhQuksD49Y5whhkgHQOIXGZy0BEPW4KSKqdUlSWyvfs9VKPs3UJYn/EkmsG705sAKilaGtdawXsL5T3mOvTT2h/Zp6lnWv2A7KsqoqKtedU1RSy4VW5N92I+o0VpqNiuKiatIWHidBOefEt1nzynpMxJsdcbtjevEaPw6CyIraOFULray0vOKGDcQRgHJ4oC8nZeqKV1LQTdLE1a0M873J0LmmzuPbB/oqQS5nLXGasN6R1xXTq3gVHbhpw7DdCDoslWurlA9BbkCWgu1dPJTeU0oln84Yi9yMqA2j6XrcBqeKtDzvXot4JJ1XG02hrUnKEJS1ap2nlkJZZvK8yjWAJc2rDPshqOVA28eso9WGHwKbly/xG10rd3Qor+L39opVapWaE8vpSYgJxmO90YFeyAQtSTOXMVYYpzEIVaBUvPMa/tNihdZ1OG8YJYDUXDC243yQjUephBgxMdBy1hauLtuG36Rz88LxM797/HV/dvfaa+Xx8/lRz24M/Ad/5vXzIPp8ns/X+Hz5rvkqatI0OIbocM6QSud4Eo7fZvKE6KQW05jryu+CWDJW6z0xLGthiA6LQOxb1ZpNmRaF42nFB1V7xxp79aQ29YE2hcgFZyWsgKEUw/2jpPFFuYQ1N5xVD5yTIaC1Sm0SlApeVrTeO1FYacxrZ8nSFhWdrPlj8PK9L603oM1OVpL+BVqvbLae0jqHp4yhcnc74aPj6Skxz1nRVJbd1rOZIrUZDu9PLEtmv/fQF1KaGAaL6Y1SigROWqPOiWi9KE9eUU0XLqj2xaNrXxujQt4vSo/wQo1V9UnDRdZArY3Tu3vKWihLEkXLGawp2O0GvKyrl8dHeGHxw5Z0OkNJOPXcNfU3osQDnPSGG+uoayIfTtRUtD0JbJQBWmwHMqSIIic+vuF2T5xGWpWBw1pzDcZdwibSrFPEYrAsMsgaCTKhw2tTXJVxsubtxlBqFn9ykyICsX0oMcl5whCxm4F2quTDmZubO6bbWwnTOIvxUcJQOQn7tYPxA2aYaNZT3v8Q27P4Ly/IqUu4q1YEzuloddXe9ZHRg3/xiuOvLYyuEzcTzsfr++usl8F+s2PYbeV9W5M85nEUn3TVTldr5ebID6R1JS9nfPDa5oXWj3plp3ZaLvgolAW8EwD8ZotzjjovlGWVGzlrQZXNVjPr6SxVol2sI2VJ9C6M21ar3mzIOrm3RthIW5IfJ32cTlTk2tTNoDcPaaWez+T1LAzU3rG+aTjO0UulNmn3Ml6+frNWhmVjMd5JI9ZVlZcbFmuge7nxqUumG/Fc52UlLQsuOLzd6u8BQ8sFG+wXgm2/sfMf+if21//de5i2zyv238zzO75xy5/+4z/Ln/8rf/urfijP5/k8n9/A+dKD6M3OE6PDewkPrAlWRaZstuFS+0wIBuccOX+Az0sASNPqpTEq1L5qato4g22N4MVLuKyNoOvCy+ldWJ+16J9aQ8lNvt7g2O0lkCKDsHSeD4MjZcEleXdhjBZKkXW695YQvSpx0oo0zzI4TIMlBl3VqT+1loZ3lgbkoqqthpRCkGH16Zg5nTNjMLx4ucVay8PTSlor1hqcs9zcRsYpsp4Lh8OZUjovXwk0++npgVoNdbphs5+Iuy15XmgpM4QgH9ZevJV1WRXa3lRFBrwnTJGw3X1QHuOAiQO9VVpZIefrh3SeV9bHgyhkKUvK3Dn8EIiK/THd4KKsudfHR+oooQ4s1yFCKimroJiUFtBbZT3O5KejhHNUyb34R2WCM5R5uYaG/BTwmw3OB1EptXaVrv5SIyvWXgt5mQVpVDK2y6DShcgl/spSdMUt/tNmunTTK8bK9q43TEAWK0JN0vgkCqrn1U//NNPtC0xTxqjz0ESFpBVVRwecH6mlUZ++J+Kij6LslSSA/25kaFXVj7zSrMdvtrCccTRefvRCrB6HR7Ez1Kr4qUQLATttmTYTFO2z7x0Tg4TLcoZgsdYLy3XckJYzdZmJMcpq3KqnVrvdjQ71dvLi1vBWcEfytlDXhZKShr3ABGFq9iyg/HRaFMFlZJhbs7xvXcKCgkRzdBp+iIx3EnoSaVs4q602zOXrGwspUU9H1lnS+hhtUqqrbivkx79dgmfeCsM0ZbyPWC5r/qxsWw+Xmxw6OEsthTyvDMPIOp/JSdBow24jPnZd7RtnsCGQj8ffyO/W69nfPg+ev5Vnip7X+/Ef/hefz/N5Pj+R50sPotZIiKcBT4fCMoua6NW7Gb3gl2qTYdBZA11UU1D/pjWE6Ci1S2OkNVdIeefDyo3eSamKUumEJ+rVGmCMIddOWbIk0XVNWyusubLdRZa1sNkMLGsheME7lZTReDPjFEi5ysqwK0O8dVJqBG8JHkCwOFYB6r1XQvRICU7FO/U+tsY0idJ4OBROS2WaHK9ebWil83RYNfgCIQR2W1HcDo8rT4eFEAx3dxNrqsxLYr+JlHTgqTS6d5TcxTZggrQFhaDsxowNEtjoWp9oDfjNRNzdSO87BhMjeE/TME+vVQau1mlLJp/OUCu1yGDTe8P7QIxB0t3eY9wgiKD5RBwVZu+g6SCBkUYaulW0lLyH69OZdDwLTql13GjAIgihKsD6SyVjB+LgiVuB9fe0ynCroR6r7T09ZVor5HWRAbbLdWTjCBh6aTR9jnTxitoY6DRqy/Smw5rpVAVz9VYYttJnv66LNA/5wM233+DjIM1WYYQQrql0AGMHiBETR2oulPsf4qKExpr6ji8NV/J8CiYO4mO1gbi7oS8nWlowxhGHgU+++y0e325Z379jDFYh8Ba/v2Vzs6euM20RkLcJ0uCEJr8FO1UJtzecH4+k9/fiy+zaHKVpcuOMIseM+p1FoTbqRW1rEsUZI4Gg3kWNbBImKjmR54Q2+cr1WKUK1FpzpWb43VbU3BjYvnoh1w1d0VhdsErDKOEzDHU50/JKKuUDW1aflw0jGFHH5YjHG+ekUtQF0Pali9fcBQ1j5UTrlY6VytZ5YdhtaGum6hAagsePYpPpptFrw08DZZ5Jy+V7Pp+f1PMnfu+n/OBh5i/8G3/nq34oz+f5PJ8f8fxIHtHcDIfHRM0V7901zR68Nhbpih0DqVwGTGQNLyFuZXwa9ZgacoPWDeMog1Qp4tErubEumewswSn43BjWJbGdHPs3e3Lp3D8stG44nDLBWZ5OmSF4TnMmBPnAlU2bsjIVoB7Ch1V8x1EqTIOXgaVKN7wkrhvWCqeyNvWUKtO0t8ZuN5DWyuO7ldYqt1vP/m6k5c75XKhZfKybMbDfD1Tg/v2Z43Hh9nZkmgJv34ov8PZ2ouRGrytxshzf3WNvb+gxsr3ZXz2PvTV5HspgNcHho8cGGVTRgQdExera4S7JrkpZkwDAfaDZJniiKo0601bxT9bgw0CvjZpWXDAMd3eEYZLhpcow1EDUTpA1rBeUz/LwSEsV5wzOyZDYahMV1znxqKZ8RUqFwRPHkV4ksS1c0ooLG+w4qDVhofdCmVfKul6DMH5QPFPRznsUv6Rkh5JWSZTHQO+VNK/ic62N4Bw+ONwwUNaEdZ7xZs/m9iUuDHQaZtzqxFUVs9QliR0jhIm6zPTTewnFgKhxim0SLINC062V4Wva46Knz0daWURl9V5QVN5x98kbDjHw8At/B2c6+49fEmykLbMomOHDc+tZqAqX8E64e8HjD39IPx5VSf5Q3ViLKLnGdMw0Ct2gVAk5dajHo4SXvJebk3nBWCfeV2/pq4Si1iWJ0u6lGUvCSVatIVpuEQLWQ5gmhrsX+GmDockQXjotnTHDlm6scGtLodPJ60pZxUfsQlBPs7v6aaWVSz3e+hr7MAqa6rSKikyX97qW682t0L7k+gteVNlcsyi0PeMHr2q+WEtsDOIjXjPePCuaP+nHWSkdscZcbVvP5/k8n6/H+dKDaMdyfBI/XBgEBePUt1eLrGdjlHSxJNI7xkJ0krytTZqHvALga2uY7hgGT8mN+ZxUmZBV9+mc2W3F6ylVmjIQfvRmYggSRjqe5ANLC46oHRwGbzWsYrqmgXU6RogynUYrykE04bpatwZqM7ggSKKaiqwdK9jWKFU8ldSuA7jj4X4hrxVn4fZuYNqNzMeVZWnXWs/9LjBOgVwa9w8z0Pn0kz21db7//QMxGF69vmFZMrVWdjcTx3Oh5yNT2TLuZCVaU1LlyWtoTIZiYYu6q49SBm4JnbRlptdKXbOu5rMMI1aYn37a4Loln2fiuMGHKIqStSL8GcO438qqvwvq6IIoMgbsxWfpAzaOpMMT6/0D1jgdIARt1KvwX/ul5OmK3qoM04Y4bX6dAmpcVFuEpJfzfMYYQ0nC9bRh0HyNqnpKQTDGYqLT1bpWjGo1bL3YRbqodnlZ6NYw7DeYVim5sHnxiu2LV1zag0ychJ+q9g06ELwEvlyknp7o60kS4u1CLbiocpXeivg3rdTJuu1OOJpplscSNgrwN1o4YDA0bl69IJ8/hjTjnSSoeyrYIWDGKH8rF72GjTQb+cjjr32f/HQgRCEk9N6/YJVoVxyUdZ6OxQ5eXqss9Z/dWOqyyH+HAT8OmOhpJZPWlXRaxIepAUEQ/3Ut6pcODjtGehWe53h3h99MMuCWjjGObsQaQldPcyl06/T6lhsQ66yEAmOQUongaEunpPVq2ZGSiiDXekpyHSjztRfxeSpATKw9OeGHAWpnOR0Zxg3GdXo1+O3mSuHoHXpayTnj7IC1z4PN1+H8F/7DP83372f+z//O977qh/J8ns/z+RHOlx5ED8d0RQqV9kWvVsc78YmlJCinriikS0dz0UCId7K6xRmChpROp6QeUgkkrSdBsey3Ea/Mz1wr+53nZj+Kh3QpHJ5Wcml4HVZKabTW2KtX9BKeMRcck35gdzotyweirPob3oty2kBU0NYpVbyEthnFOvWr8tu7eFsfn1ZM74yDZbsfGabI8XFhTZ2UC94bdruBGD3HU+J8XnHesr/ZknLj/bsj223g9nZiWQq1Fra7gfMpkVPlxQtPLidKGqkayjDW0E3HaKrZe4dXJqS5DnGWlmbpWe+K5ckrZRV7gjFd0T6BviZqLfjtJCnrC0eTjgmG8eYWv91gSqauRZfo4v+UoEnBBPFDLu/vaaezDGVKObhYB1qVta4Epjwmr7gA4/YWN27k6zmnbTlGTYoKRM+J3ir5km63TtbeOniK+aMLVaFBM1JAkJZVSxPMlfNqnKGmSq3iHzVTxEdPWhKbl6/ZvX4tYHgNzvRSZOBTDqmNg6ywu6UeHzBFBjNpD9JH0q0OWcKgvFhPnNoaetM7pzgIJ9OowfoK9K/keWZyDaZBfbSzhKW06KFe7AHOY7ynusjTr/wKLYkn1Hovfk6gd2mYaq3JEDpERapBXRYMhrDbgZNh0BoL43hV1+u8kNeFumSclQCWkBxk6KYrBUrRVa1WwnZi+9FHYqloXe5AEH9sK0US8l0S7LV18umB2hSlZqXf3o5Rr0loKUnL1+X3ThYChniJq9IRMhi51bzgmrr+vNac1WvaWI9H4jAQtxMlLbKSNxKUpMtQXnMhDCPUrnSG5/N1OB/djEzRMaevvoTg+Tyf5/Plzpf3iDrxd1mHQue7Mh2hG6nGXHLFdAk9XNTS3i/KKeJh65ac5YPsgvahdVoXjJPUfMoHaCmVWhsvXgxMo2ddK+e5sC5FE8664q0N52ETBUtUSxPkknNYZRm2Vq+qWTeOXBoxOPGdKZLKGSPNNZrUN4qQytqNLb46mM+VlCpjMGw2gWkXwVge3s+sS6H1xjA4druIdZanw8qyJMYpMI6RwzGxLokXL7cMQ+Tp4YxzsNkMnM9CIXj5ckNaCzk/Er2Xnvagg6b1+CESooDQjfWSJtahvKWkGCVoJVNzoaZEr7LudM4DVmojG4Q4CLtRXyOsJWxG4n4nyl/OUhWK0ZV2kUCMKn2tFMppFiajrv+Nd9pedAG8y2MzCuEfhomwmXR1LIPaxQ8IgA4Pgg5apNmqWfEq8iHo1DRMdelKb7XQjGE5n68VlN0oMaEXXfk6himS15VhM9CNZ//Jx0z7vaSsnZAJepMBh9ZEBR1GjBPUTzk9CHTdORksdV1PzfLfzkuLEkCIeD9gaLS8ivXAR30auupvwn7tpZBPR9LxKCv4DmVZMEYGTqueyAshwFhLaZ35s+/he8VOk6i/rYlv91JzKhUS6smWIoK6rJghSI/9Kkq3GyLEQbBQaaWuC7VUSio4q/5JZz4UNnTRcP04YLyRfvvdjs3Hr3HDqNYEIRwIskFuGLrfyxbjfCQfnyQFr1glMwwSwrowWmuV5qzWxZ7SOnhHcF6u9bwKo9V5sQiUJNeV6frvqtxAWMd6OhCix8eBsi7abuVpXfrle6mS/B9HbJfGtd6fh5qvy/kv/bGf4d/93gP/1i+8+6ofyvN5Ps/nS54vPYjGYKlFahGds+CVFKQr1tY7g7fXDwppL1KlqhtwAqE3dKIX1THnel3HdyONSt3I3ym5Ukvj5magNXg6ZGqRBiSr36Npc08MMqQJVrLhgwDne4NuZTVZq/AcjZH/9k7UUbo2RSFBGtpFAVGsT9exuItSM8+NlCrBG7bbwLQdqBVOx5WUCh3YbAK7fYRueHpaWVNmfzPhg+fhfqa1yuuXG7Cep6cZ5w3DEDkcVpy1bLeR+ZTodIbR8/7hLbXBdrNjut0RpoEwRG1NkiGvdyT5r7zNjqXVTElZ4eSCdDJIp3arDTsO8nyLJt7pmOAJuy0hRlnpl/ohGY8GnuEaEqlr1vpOo0MZXBqvzGVN3ZrctKgy7ccRF4IMtE0GSmOtrNoRxa+kVfvomzZF6RBFvmKUepXhzbugFIBKWhZpFSpybRgvKqsNgruS2UyS6GEaCfsbht0tw3aLNgjI1+IDpsvEiB1H8AM1rZTjo1aF6o+PqnBSWylq5+XnAu+lRpVOW7MOuk4HOK4qKEBNifXxnnKecXEQpmcpWOWaWmv0OSMqrLWkZSEfDjjAbbfiIVZsWinChwVzpSs4b0WlTQXCIMD2kuRnw3laaWAapkulprQlIR7UVsU+oIQuo3YCF6N482ol7LZML19ifeRCK+gt6WspuCVjJZxUTo+sT/fyM2/FA25jkOCU+vxqaWKNKFXDdJLId96LF7eLyg4NqhGEFRIu7N3oECrr/VIycbfDtEpOi6z9h4ErJqA0Ua43O9kmJPH2GvPM+Pw6nT/ys6/5m99/4rDkr/qhPJ/n83y+xPkRPKIXduclHd9xVtTR3mQYBMi5XdP1KUvwSEDwEvSRI2uwrkl66y1p1U5sAz5YzqeMBc5zhaVigHFwxOBoDSlXB0Lw0i7TpEbUOaSlqapqq3WQ0lQptgGjNoHWGjlL6ttaQ21NF7Ci5JbakcyLVD7mVbAum8Gy2Q1sNpF1rZxOKyVLn/xmE5imQMqN81m4incvNnQsD/dnnDW8uNuyzJmUVjbbSOuG9w9nYvCMmyi8UQs+eI5Pi2CA7Jk1eyazF/g7RoIk3uuHs/gXuzHC7VyTDCVF/HYuCvKp5YLxVpiSrVFXUUVxFj8OhM2IiwM0TZ63rvOEqN+XD+3WmlYjtg/94Aql130oXetWu+2A8D29F55pq+WqzBkjcHsQFmpJiTTPtJxVG3eaom6YrjWUXUZia51cWzWxnk+kcxJe5AWTZJxggboEp1pv5GXB+MD2ozcM+zu1XiBcyyaWDuF/ymrdDhtwgbacqfNJeApOkEcXZbI18eBeQnG96QDrvAz5F2uCk5rPy8CEPtaWVpb79+TTCXNRUlVxdkY9pFoRCmKJyecz9XzG0AnD+AXqgSihIMqhMVJFGzcDw2539eJirQzk4yBDqDJX6VUCXkvG4KTEysvr3ZQ+YZy8Zy5EVR4LYbNhfPVKrh+Jr4la2bTg1X54j+s6sz49UGvV8JWgmGzQmlrxlFz9uXqRY7By/RcZMswgWwdyptVV61ONttAW/Che43w8C1t3jKTzGRs8boi6YXD0kqW5LQThpCqPl9r+kVd8Pp8f7/xn/vB3iN7xv/pLf+N5Rf98ns/X4HzpQTQlgZYPwZByo7SGsxI8staQS8cZGcZyFiRPjA5npe/9koYXeLh80HitBF1XUd1yaQxR+J23tyO5NOWTisrXGgqEl4HEGGk46k3+3kVVuzQn+eA+rCmbQrON/YCz0ccOhlxl1eytoRpRt0JwOoQifeUdYjDsb0bCEFnmwvGwkkslBsf+JhKjZz5nDseV4B27/ahD6cy4iQTvOR4WUsq8fLVjXivv3x3Ybgf2e/GHhigf/oenGe8dN/uR03HG+8q0nwibLW6QhLWcLin6XEgpUZeFPCescRJick7ZkVU4pMbSSxVUT63YEPDbiTCNVz/lxQsqngVRI2UQRZuXmmyVLwObvPBiDWj16smt2kfvY1QrBdJTj75fXfyYopwVYVcui6T8LyGza/DbKn70Aq4XJSzNZ2pu5DVTcsVZGZK6ckG7c/hgKRbSuhLGid2bTxhv70SB9dK807Nii5q+pj5ixw0NQ326x9Sk6pggn6TCUjBWXa0lHUO3ATcJuojeaesCoEPoZcgqOgwayrKwPrynpSTd6Ebk59aklrSVihuiqqGdCiyPT5hW8N4DntakvrLXIj83GhYCrbi92RLG6aqotiYbizhO2lYmgzK9yRA6J039y42Ic15uRC/KtVZi0qUKNe63TK9eS/Wplge09SyqpfPgg8SGSqLlxHp4UN9wp+WKHYMQF1pT20eTwVufl7FOvrauzwGxHrgPavR1qG9CgvBDvIb2pOc+UJdZMGfjoIgtRIHPWbzL3ku4yzts65gQ5aJ/Pl+r86f+4Df583/lbz0Pos/n+XwNzpceRFvrsv7WtftlrX1Rx7w1rEk+KKcpiGKTKseUpX9+EtB1WgvWNDbbkdoax1PG9M5+H+lzYU2N2jPWGJyXYE0pKBhbBh/nzBXJdHkMPojCWXKTLnusJOMponJ2UU3pArPvwBA8Dsi14TDXNqcQxXu6zNL0s66FXDuvXm64uxsxxnI4JM6nFXpnt41sd4HaDE+PK/M5MYye7X7kfM4ss6zmO/Dw/oih8/r1nnmtvP3syO3dyDAGDoeZIYr6cnic2e5GhiHw9HjGB8cQOqfDA/HmjsFs6BdvpZHBIs0LZclY6wiTQOFplVqK+t7kg7mmBKVQS8YNkbDZiCqF0dSyriovAQ4qBisFBFlCS3zRr4dV5fJSv6p2jVJxwRI3W0E2Felch64qpQxFBmg5UdaFmpLeIMj7163BGL0R6R1rpbZUgnON5Xii5CRKaZfaSmMsrWRyltaeGDxtiNRe2b96we6jTwjTVh6K0waeul4T11graexxS82Zvh4wrQm8nq6eQVEUuTT8WO2A9wNue4NFeKPdXkJmGqKpVWwMWquZjwfm+/fSa2/lurv2spcsw5Kx1FXg8c0H8ukEJeOCv4Lvmybiey20Dj4GrSkt+GkkbDb0lGVQzlkCQcrwvAayWqXkRDpLgEm21ZUwRmxwtDVjrHivQcH4pjPd7hju7tTvXTFuEKj8Kmgqo/WyvUqgKC9nsdUouqnmQlREF1VfI9OFe9vkOvJD1OcqA/YF0WOMoeu1TC20rnSOjVbR1ozzETMGWknKLBUsm+ChxBIh6roFxaPhHUbxUbTLJuf5fJ3Ov/hP/0H+B//b/xelPt9IPJ/n85N8fiSPqOCIBHPUC+TWGEdHyY3z2tlsPCE45rlwPidK62w3kd1WVtUlVcYoK9qnY8L0hg+CgqoddvtISpfkMNB19e6k0aiUqslwq5kWUSmtQdFECtfGkFIiKnDf6LDcLlWCTpPxpV5ZpyGK+il5CsPxmEipsGYBgH/yZsfLFxMpdx4eFtKasQa2+8i0ieQMT48zy5zY347s9iNPDwvzaeXu5RbnDG/fHojRcXO35eFx4fi08NHrDd0YDo9nxinqQFm4vdvivJM/HwOb7cDTwxnjCtP+LXEYGMwWjKUm6fzGGsI0QLfSqU6nl45pEjZzMV5f2JITcTMRJh1oO6pioql5ZJhAQt15XQV/pL3gqBOVJrSC7sT+cGlI6qbjoxeV9aKSas+7Uf8qPkhfeqnUdZFhOegatFZa1WBP0xQ79qpy1ZRYjidVeQ15SZQizy0n4U2GEMB3HZzg5s3H3Hz8BhtHvX7U8Xphg6olw4aAGbaUZda+ePFD9ktGCgm59VauYZxaKkxbwmYrqmmW0IsxRoJJF+XYSRofYH14z/L+naiKHXrr4rf0UpRQc9abAlF/G4bl4R5nDXGcoDfBcRWtBDBgvcerF7jRCfudJMuXRbrTc1YrRJD3DqSVqTdKWclnxTNZp8xRRXmVSr/8/DnpYO+mM97sGF+8kHvC1jDquezLCYwULdBE4bzUsdY1Yayn9kStTR6verd7+eAblvAchGkjlZ1NB1Qbfn2DUpdrvJRMA8abG1pa6UaHbWNFwTZgp4G2VtmsxMB6OskmJER6lsG/65bADBKuFGn7+Xzdzu/+5p2SW54H0efzfH6Sz5ceRHOu+OCopUnTkTdEZ5iPCR8cL16MlNp5/27mNGemMfDRywkfHMdzxtJlaK1Q1kz0YI1nvw+8fbewroVWZRj03oK7zAaivKZUNXXfrwD13iRIUGqlVF2zdwnHxOjFVqchqdrAeoezkIuC6b0MbMF7am24IDzE43FhXgulwn438ObNhu124HwSbFRKGectN7vIMAWWtXF/fyKtlVevNsQpcP/2zLomXr7aEoLl3bsT4+DZ3254/37mfJz59JMbcjM8PZwEdl8hrZm7l1tqg8fHme0mEqPj8f6E9Z797cjn3/s+OcGLN5/QaqOtAuZ2McjAVJqspDG46LE26jDYqfMC1jK9eKnePLErEKXXvNeuQ0W9KkF5SfLnXfPtxqqyiUDGS5HGojCoomgY9nvxpSq6yagH1Cg3yI0TOE85PpGPJ6nvvO7g+3V133RNawAfR6z3rPPM+nS8WjHyWq4hKVpjHCM+BrVTNAiOmzdv2L56LX5C7ySY0lWBaxrwcQ4XRhhG8ukJSlJlUm5YZNK2EoS5vD6tUVvDbW8J2x3UjGnSY07X4VVT/kZfGwMs9+9Z3r+H1nHWUbrc8NCbAPJVWZYgV6dZy/n+gWmMV3B+zY1WmtgRvCiY4WZPPkvS3W8GXBzpRdbO4iNuYIMMi8ZdvZa1FtK8YJ2XG7UqQ70LAeukmctgFWIPHcPm5QvGF3eycq9ZwPfO0ZaZts4yhOZVroHWyeej8GDFXA6tEm93ohZbI+oyFzUemnGE3aSeW7FMWO8xQ9T6VuQGRcOSFSs3VutKbxU/Cu6tNaljNcZS5yz0gTGSDkfqsgotQRvCWsn03mjFYGrDDgPmS/+WfD4/aed//Wf+OP/lf/kvf9UP4/k8n+fzDzhf/ldsh6rD4LTx5FRYlsrN3UgMntMx8fA0s6TGy9uJ3VYQOMeTgOpLhfVcuN0FhmGgYzgcC6Ua3rzZSqBgleR2A0oWtmLJFYs0IbkvwMtLvaiknSU1ausEJ1D9jpVcBIZSG2opw3ERsGRQNZpuXpfMZhuo3XA6r+Rcid7x+mXkxcsJHwPHp8TpuFKyJOb3NzKEnk+Fzz8/0Bt881u3+OD5/vcP5DXz6tUGZx0Pb88M0bG/2/L5ZweWJfOd77ygNcu7zx+5u9uQUmM5i3qac2dZEi/uJkqu3L89cvdyRxgjT++PhNFT8xOf/dLKGDbsXt7Kh33OtCTrTIIik5JULLbWyMuZMAwMNzcysNamyCRLSSsU8Xaivs1SBCTv4yjBkSZd8jUlTVBbHUqdIJ6sIw4TYTPiY5T1aau64ReoOMqX7YpAqstZVULBQGEtLTdpfuqi5FqLrmMty/FAPs/KmxSv7yUMY43BhgszVhixbhq4+cY3GXf76yB4SWGLp0F5nGHAhoFuAvX0iKmiXspNTwfjJTSmeCpR+TrNGNzta1EoWwYLfU2ABS8BMfk3nY7A+dfH95R5xQ9RV+IdH2SNXot4cq01MhgPE81Y0tM9wzheV8UNZKDC4GPHh4gfHOvpTCmZYRxx41bqVC+Wi1pFCQUZ7lvWnzUJhzk/QJfBXny4Buug5yKpfRfoQMuZ8e6G8dUreV9LhjCINaBk2nyW97qK7aa2Tp7PlPl8tRpAFx+tE+W1rwl6EauANdRccXEjlo5a5bVXXFsvVZ6PFX5rTSulFCE9LAvdWfy0kWsmF9qacVOkLlpL2ir5fGI+nNm9uBM/srPy/4NYGuhAFitCK+XH/kX7fL6as5sCzkq49vk8n+fzk3l+BEW0EaOsuc/HxBAdb95sSaXz+ecnjqfMED3f+XQjAaQiKfPaDaU0hmDZbUdabTwdCrkI9L3kwjgGnMsyBBldCyuayVorvi53WYcq89NZWoN5kXXazX7UTX2TLvuGpunFPxnCh6CLM444BJZZOqj3twMpw+Ewk0tluw28fDEx7QZpQ3p7Yl0qpTWmwbG7GbDOcf9+4f37E947vvXdF9Rm+P6vPVFK5dWrCTq8/fyJcYpsbzfc389Ya/jGN+84LYXj44EXdxvOSyXnyuuP9yxLIS3iKU1LYZ4Trz9+Qa2N928fmTYDcYgcH56w1hNuIzWJ+iXsUBkaTOUKuC8p0VolbrbE3RbnHK2Lv0/qEhu2XxZYEkhJ80w5nvEx6gBarx3uvYpyJZ3tXnwawRP3G4btHhOjtPO0JtQCp01QGIzx9NZJpyfKcibEEe12lZEtCw7KGyve0BhwMVJL4vzuid4yzjpc0IGsyIBszQfgv7VgnGe62bD9+FPiZntVasmKUFJ/scHI8BEGQV6dHzE9S31nVU9riDr0AKUg/tBGw+O3d/gYpVUpJ3oRVBbaq45+APYOdV1ZHt7R0oINkZbKlS7QFJVlrJAGbPD4zYaUG/npkXG7oyVhwnoN0YnirRWlcSAfjyyHA+N2ix8nCfGVfPVRygOpqkobegvUNZOWRTzU+ngkICWp8Y7DD1FUwtYwvTHd7hhfyjq+laxWA1Ut17MO7wbjIx2oy1F4pClrWK5ip0HsBqVAWsQj6yzdyNrfhhEflSPautgagnw9cgZV/GvN5HXGRwvLAsYLkinINYgO0W2RIJhxjlYy67yy/+gj6qpoqdagIZgvpyq4EyJF4xnf9HU91hj+wp/9k/wz/7O/9FU/lOfzfJ7P3+d86UF0mhzLIviiV69Gpk3keMi8e39mTpXdLnCzEQXo6ZBl2KiNITp220ipnWXJxGAZR8vQIcZIaVxB8/rZp869Logei3Aykc/0jqEiH5Q5tWsQqmnSGRR12JA1ZxMovdPPkkuv/bxkvO2Mm4F57tJ6ZOHF6w23dxMuBEEzPSXWWZTg3S6y3w+U0vn8h0cenmbGKciKfa28f3cE4KPXO9Y1czou7G4mxu3Aw/2MRfrkn54WznPi1esthyfpbH/1ast8TpTauHm5Yzknciq8fL0jrZl3749sdiPGOM5PZ4bJ42JgOR8w3Yk37naH8wNtXulWkE2tZHqtDLstPg6iYBlEZSqi+kkdZVc2aGU9PtHWhAuRVgrWeIwzmGoBWXFesFg4ix0HGXDjgBk39CQ98DZGXfPrO6PqFdaypgVywll/9SH23jHa2mWjw4RR/YmZ9XiGWqS6Vdt2ShYKgNWQ1EXdNYNnvL1h+9En+M3uglu4qpjiZpXAmomR7iMVQz28xzon6/eyaiBLBxNjZc2saW7jN8Ttrfz9vEJZ5GsHUS17zeotAYyh5JX18UHYlLXT6ioDq3Pi9azyGK0XddhMG9Yl0+YTQwwC9a+CODJO7Be9NroFH71wV9PC9u4Vznt5PdOqa3MJU3U1uXYnN3w1Zcq64r36IxFGby0S6LO9E7oo2GUt9F4Z7nZMr14q8kiujW6s3ASWpDeDRoNshnQ+UtZFFExjyKt4k533OiDni3NBlFEM1nqcsdRVEG6tFKyqwQL9b3LTUKWm1ZpOTw1jA36zwYzh6mW2UZqbUMoGRkL529cfYVqhpCRtTRVsDDKgqxeaXkmnmfjxt37Dv2Cfz1d/DNK49PnT8lU/lOfzfJ7P3+N86UH0fE5st4G7u4nW4LO3C4eDfNDdbCPbbcA7w+lcKLkSB8dujLr9rAzB4YZ47Zx33jGv2n3tnQ6ejVpl9e6c8BiDgDzlQ945ShLETq2dGC0hyFOwl9xJ61e/qLGyEr74Sbux+GBZlkQMMAwjh0Mil8xmCtzcDUybCFjOx1X9oJUYLdvdQBwdKVXefXbieFi4vZ14+dGOdc68+/zANEZevN4JvulpYbsf2exG3r+fMb2zuxk5nVZqa7x6veV0lgam/W7i6SAK4s3NhvWcaEXqPo9Pgnra7UbxQy4Lm+1Aw3I+LIRQOJ0NfjsxtkrLXXrHsZIydw6/2WjS3AgPszX131r12DVdh2by00nS7t5LWKTKwGOCU69mxw6yqm+tErceF0dJJgMsEv64hI4u/eZ0DeuMG6bblwy3tzz+yt8hLzPeeUmvWy0YVVB6q431cCTPi/bFf1gxCwIJCaIYYcOWUhn2I/uP3zC9eI2xwko1NKkLrRe/qQRQbAzgBlrttPkBa2XdjwbYsEZ8jgb6MksASB+rm7biH82JnhYZ1L0k2K8Km0Lta0rk4+GKt+oVeQ21TalVIT2AeCVtjKT5BLngvBdAf8q4YZCbMmvEeqG+07LMlFKJwySrZ2M/9LZXUVmv7wXKzE1J1uTWYrRNywXxzjrvNJ8j3yMdz7SamV6/YHj1ESDtXdevq4l1SlbkU5WVfzpfm6SsNTRvcSbKMDgnYNXAl9yISsWrNFJJe1Sje4eNUuVZa5FKUmvpBkpa5cbFydbETRNmCHRN6NtRGsNsyrSu738zxGmSGs+0yHtWKja4K8YLJ61MNTXiR59y883v/Fi/ZJ/PV3uG4Pif/Ok/wj//r/yVr/qhPJ/n83z+HudLD6Iff7xlnDw5dx6eEk+HRKmd3ejYjF7RTpI+F/6mRE6Cdx9W5LXqgCmr/t67fECVRr0MjFw+ww3eGap+kFqgrJKy7VXamcBQsigtzhoqInp57/BWBl4DV/ajAXIqhMHRuuH+/owxcHs7cHMzCiKqGc6nxPFpodSuGKZI8IZ1zrz9/MQ8S6Do5m7D+Zg4Ps3sb0b2NxMPDzPzeeXubsMwRZ4eZyyNaROY50Trjd1upKTK4AzTFHl8FCj5OATm04x1lmETOR1Xem34GKhFAmBhI1zS3jJxlGGv1Znl8IB3lmG3xbkgr18MhGFQqLn6OUHCG5eUvDW0Iq9tejqIL9M6GaAu/kiAJrWndhhkbU0nRE8Yh2tAjKrYm0uFaM4ybCnawO9vCLtbjLUEN3H33Z/l8Zd/gbpmfNDwU29QuvhTc2GdE94aTK/yDhqnBABLLXLT01snpUzY7bj9zneYbl9eJFjQIfQCqUdVMeMC3er6Np2wxihiSbFVGPUKKl/UdPAj4D70uCe5eTBemp5UDtR0t9w8lflMOp2k116/tNALhBYg6+6Oj4FuLd1YWk44C3YYpHCgtw84LG2vwhpsCMKCbZ0QI6ZKjacMoTrIIeq3tQL/x3K9CbFUqoL25edD/o/GWsIwCHc/ZaCxefOS6dVHsqrOWewfVmtiiwSACCNtOdPSStGqVb0HwVojNydB2atroqyrMEq1o94GuQkUTqiElqz30l+fVtq6KuWiSiWpqYRpUPYq4OUGQ4JVCGe0fChbMMYSxkFqQZNYFcyl+MBq2YOxmCAWgeHVGzZvPoX8rKR93U/0jj/0Uy/5q7/4/qt+KM/n+Tyfv+t86UF0GD21dg5PmXUpMlAi9ZzWS2jo8lkPnTFYWrfkomgfq/3xVcILl756uISRjXjEWsfp2jclgeCbJn3RpfYPf08T9ZKKvbBNxRdqaR9QO9p0Y6zB0HHRkVInLysxWkUtRYx1lNI5HVfhg2LY7AKbbcAYy9PjInimVLl7uRGc0tPCPCd2+5HgreCazisvX27xUeo7jTHEMXA+J5wzOOdZ18o4BXrrHI4zwcuqeV0zIcoQeXhc5MPbO4zpbG8mrPUsS1IagJMaVcQLuq6PmIOne8f+xYY4baQ5RtewXV9DcxkY1QtaloV0minnRVQtK2pQV2+eoeNDwHQdVmLETQNuGHDeXX2aEqJXr2BtgIabasUOkbC7xQ+jDrYyZPhpx813f475s+9Tz0dMl2Ehp5l1ngVa76yij6SVyMcgymAVRRY63Rg2r1/z4rs/xXizFw+rFQWXLO1WoIOmtdIt3jr1+AR5Fl+gXLZXbBjGSoilycDSjMPFCa/c2q6rZqsq6HXi6k3Yl61QljP5eBQfq5HB3w+DDKCrKIWXIdFYiwmRtC44a8Q/WdtlahTnhJeftd46Fg2N1YYLXoZ0L8Eeo1xTdGgUiTqK/7IVGbpKv4LhMVKvaayEpLqx2lzVhV/78iPGF7dCTihJQkPG0LKE1swwYOMGWiEd3pHmM91Kwv6iiBsfxC5QhNXWdeBveaXXShxusUgDFJqSl6pYQ8+NuqzaqNXI60o3MOw28j7VhoviHy2ns9Awhkhdk95UQafirCi5PUtbU2+CcjPGqB/YKtS/429eML16g9VWrOfz9T77KfDP/4mf58/+b/4fX/VDeT7P5/n8XedLD6K1dOa5sizS3AId7y3eGXKulAZjsARvZT1eOvK5byhV+sydfuA6Z7Guk1b16TnlgnYZNCUt365DZNdVsv3CUOW8Nve0TlnrtaLTWUtXZccHT9VmJu8luT/PhVYKu23g5uWGIUogYV0Lp0NiXQvWGqZNYJwCtXaeHk7i/7SWl693bDZRGpVS5fZOQkkP9zPeGV692tI6PNyfZdjshmXORAXVt9YYN8JLzSmzmaQxp9bGOEWhCywFayzeyg2Ai4E1VagrMXpKESXLXVaj+iG6zg8M+x1uGrFj5GrQrDLwtNK00lAUn/XpQDmfZbAxFlxQ9VKGf9OytDdJ8gszRNww4Ieo1aIKkL88jiwwdYwomK023HbHcHN7hevLYCVJe7owIu2bTzl+/1fIp/PV9yePtWtoDUyI+CFIFWVtUCulFIx33Lz5mO3rjySgcxlCsaJk6orchChr7e6oeaUvB6gSngGjiXjxmNKbhI6EsCrb2u1OV/Er4BSrpJB6RVmhq//eG+vTI/l0xHZt+jJgJy+e06ZeTQzWeUywVOdp66qVt466JPH3NnR1LzcIqN+zlEItCee83CRYTXor7gwMtTZab1LnCtSSZAjsVaHxasjmYl1pdKeVqSUTxsDm1RvC7a3QDxDbxwWcb3zAjpOE0Vonn47kZQXv5HoCAdA7bc7K8rPXq968yAPGbXb4aSMWEK0+NcFj1d5RV/FRiw1BVFQ/DKJqNkEscWGlYgRZ1Zq+P7IBcOrF7Qqsv9wE9ypVtcZIaK0DYbNjev0JzkJPSe9Ons/X/bzajfyn/uA3+T/929/7qh/K83k+z+cL58sPolVSs2tu5CrpE+tlyIzREg1grPbJN/zgldcp63gf5Vs1VUKNgWHwpNIxzuD0w7wWGU6907Yere7DqHKhq8Nc5cPcdlnTX2wAGBmExyGSsgzM4xiY58y6Zg0MDexuRuIQ6LWxLIX5nMm54b1jmhzDGDidC0/3Z07HBRc9H7/ZE8fA09NCTpX9XjBUD/cnQnDsbwbO58yaKre3E63Dck5Mmygs09oYpsg8ywfrOAbWJeOdIYyBdS2k3LB0QoBhihjjmI8LzhlCjKzzigsOr3WZYj3wtC4syPnxc8rykSiryBDeFdLdOxgfqaVSzmfK6SyewMFfB3y61b8vKpMx0Hol7rd477E+SH3jBX9kLslm6Z2XvvOKsY748hVxf4NFKxivRQQ6ICNpeecs4+0d6XQkrTPrknA4UcKrWACivha1iurYSiUMI9s3b5juXsiQeRmKa5Ow0AUx5SPGBzqOcnikpzNW2FCSbrf6Y6BUBWn0kcAOcaM3ThKUMV4YnMIH01R8k2u+d0NZV/LxkXyaZfirqv7GQSDxWcJjTd8bP05002k5YbuQCNqaycsqRQ0Y+VkzsoGopUCI2M2WZZ6paWGcNjJ/loIYUK3UqLYmoSAlJ/QOvTR1HxhtPNLNRG+Al8E3Z6w1jC/uiLsdPSW6sar+FqhFBugotg9ypRwfSU/38rWcwaq87IYgj02bmyxa++qEJ+yGkbjdYpBrCGswVkJD0q7UJCzWKnlZqWsibEZ6ytIlrxW25IJxDh8HfQ/lZ6PVQmuQ14VgpeCia12vC0E8rPrWt5IJty/YvH4jynCe1WP8fH47nLtt5J/9j/0swPMw+nyez0/Q+dKDaO9wOGXWLJ4ywTE5GaZSp6QKvTKMltw9j8eCM43tRlTBVjveybqvfgG/ZI3BG6kLVH1UwjS14LzVtZpqJ8o2zEU+yK0B6yTUEoIjrRUfGtM4MC+Z6GUAPjytpDUTg+HFy4ntbhDltXWWtXGeK7VAHALDaPHBcThm3r8/ssyZ7RR488ke7zzv3s/kXLi5nejdcP/+SIyOzTby8LBgjOH1R3vWtXA+rmx3I6XIgBaGwHyS+s/eO8t5ZbMdMNZKiKmIwhgnx7gZyLnT8so4BVLuHJ5mNntBYF2GDGvk+dcONc3M55mPvrtCyTSrQ6UqZDYGypzIhycMFu8DzeknNgqs751WC8apB7EWwm4v30u7xdsyS3e4tRjF+rSiqlGvmGFkevFaBoZ+CUaJT+8y7PULw7MVyrpwvn9HazBMG2HUnhY2mwk/WKxzopAaoDVKK4z7G3Yff4O43XGFtBsgr+LH1ES6cQHjI60bWcWnszYlyYB6WTNTqvBF1VtZa8Nsbwhx+EJaPsgq2loF2qvNwFrAkh7fsz6+k++v1zHG4MdRmZaJWgqmCTrLbbcyAK2L0gMabU3kLM1VPkZqLZSSMV5ueqo1jDc3EtKrhYfvfwYuMflLmMxQV2lKsnpzV9YEXa73C+kApD1JEvsZp41lJSdccGxfvSJudrSc5CYwOBluc8YMAyYMyqKt5MMD6fAgVbJVqAfddOw4CRw/JfUKoz4cqKngNjviMMjAmGX9bb2T165mbUIz4KRwYp0XvHWUWfBXYZoIm0nICjnjN5MEz1LS667hvce0RiqNSmOKcjNFLvpchb9alhUTI5tPviVQ/JLkmu79w43K8/nan5e7gZ/5eP9VP4zn83yezxfOl/4N+/5+5XCWtdrdTeD2JmKd4zRX6YpWBe9wrszzym7jGeJAWkURBVmjO+votA8BotoopWC9gSYtKM5KTSSA89JxHjysS9W2R49FVv0otmdJlXHwdGs5HBZubwestXz2+YllyWwnx8tXG7a7UQI6rbMujWUWbmccPNPG44Ph8JR5eHfiPGd228jH39jTcXz/Bwdqbbx4uaPUxv27A0O0jGPg7dszm9Hz6qM9D48Lec3c3m1Y10ptlWkzsMyJaRScTM6Fu5c7aumcTgu1dkxv3O4DNqqn1Bim7cA8Z2pt3Ly84XQ4YawEPIRQJUPu+fEJP2z57u/9fQy7vdRxImtqYw3dQH46Uk4nrJNGpVqLrN6BWut1SHQhCBvSGYabW1AWJdbLWtc5UQjVd0oD0w0pZ8LtDdvXb7DW0ssiw6HT1qTL8Knrb1ohLTOHX/lF8ryIz6/CZrul10oxsNtspMmoVNZ5xnrL9qNX7D79lqxge5OB0hj6MktwJvjrnxknSmg9vKMtJ5m5vRNskqKaKEkGrtokLd2BaS999GVRMD0ffISXQFI3oqo6x/r4nvR4L+tlLL1WRU2Fa4q9piRd7cOA30yUtGJblaBS6/IllbPZ9eelrknajIAGbF++xvVGPZ1xHfYvb3n/g7eY1hm3E2leaCkRhgC1sZ7zNXRlrJE2LWQVb7x4Qb0q5nld6TGwef0KO460mkUB98JJba1ihgkzbaXXPSXS/XvS0z2lNfV368B7tUJ0bdUSxbEWUTaH2xd4+tXjKc+uQ5M62J7LFTmV5yPlPDNsJlophDDJkG8NJgaxgEwjresQauRrOCNBSIxlmiYKhlQbXpKTMvw26GS6D+y//VPE7VYGemvkGjfuyoJ9Pr89zp/4PZ/yS58f+T/+f371q34oz+f5PB9+hEE0pUq08PqjDbttJOXO05OA0rcb8e7dv5/xofPiboQmjUWSgld1pgNWVq29G0oqWAfVWFKuOAc+iiLinUDx01oYp8jpsAhbPDic0/Qz/QrM3+8j69qZDzOvP5YB75d/5RF65WY/8Or1ht1ukgF0raxzYZmTrPGnwHYfsdZwOCTu30sy/vZm4pNv3LDMlffvnmi98+qjPWmtPN4fmUZHHCI//HxmGi13txNvPz+ylsbrlxNpyRiDKJpLYhykPaq0zv5uz7pmluNCquJje/FixFnL8eFMHD3DGDk+nhjGwPb2hsPDkRCjDASm41wgr5mHz+958fGnfOd3/A6G7Q3kCkMUdclYWsmkxyM9VYHQd2h5lXS7EeiqNQ78B7Ws9UYYI+QiM0IQ9qb1H1iLvSt30nRqK4yvXrF5+UradcrKRS00GjxBFVdapdfM/PCep1/9ZZwPeB+ouQiOxzt2tzccnw4sy8w4DORcqFRuPv6E/afflMdekgw8rdHSKsOhs5g4Yaznoq6Xhx/S88Iltm7tpSDBaGCo6ArYUnvHTRvCONJrUu+lrvGt+mUvoHsDmE5+fMf69jMJFE2T8Fn162FEye+qRrphwExbap6xpivySTypvcsNmB8ieV3Jyyw98RhqLWxuXsG6sp4O0qoUI3Gz5fYNnN6+pbZK0DR97ZDXjA3Kcu0dEwI4aSZCfaty8yF+UmLg5s0rnHOU9YzxkWHQfnrvMNs7VVErvRXy0yPr/XtarxIU1NCdGUXlb7kIU5au4alKWxaGzRbnvNzgdO2PRzigOLFYXP5nSZlyPBDiSG+dMIx00ylrZpgkAY8imC5e0lYrIYhdBWuwxmKCxxtDyomH+xP7QZrfOobmHLtvfZvp7k5UcWMx3UAcdVnw7BH97XQ2g2czPKvcz+f5/KScL/3T6Cy8fjmx2w88PiYOh0T0sNsFUjasx4XdztKM43QobDcW5x25NrwVhegSlKkVTC/EwXE6F2ouhChtRyo3kUvF6ir+4f2ZcZShyTlLbY1aK7V1vIWbXeTpkLGm8fHHe85z4bPPj3jXudmNvHy9Y9oMtAYpZeZTouRKa7DdRbZbUc+Op8z9/czhnLm7Hfnk01tOp8RnP3giBMfHn95yPiXevT2w3UbiEHn7/sx+F7i9G3l8WrDG8I2PdxwOC947hjFyOi3EKOgr6x0324GnhzNZB/XoYP9yS0qV48OJ3c1It4GH+5MyQz15Xtnf7kjLKulfDI/vDyynhW/81M/yyU99lxgjbV1x2w02jhjTKaeZfDjKTOicYoAkpNNbkzWuMdgg61cbAjVl2nnhPD+xuX0hw2etWgUvvshuAOMoa6bQ2b5+QxwnQRqVrGBXZGWOtAChieSWE08//CHHH/6AEJ3WNFZZ0QJ1rVhniT5wfnokh8C02/Hmp7/D9OJjVVObBGBKE5Znq4IAGiaMk4R2WRfK4+cyFGo/uwFdtcrA3UsSy4d3NCtMVNMavZcvKLl8AOKXVZ+XrLXT4T3p8UECQw3xvEZPK/J8rQ8CsKcLbD0OlHSWxxQjIMD2rgzVXmUYNw18iLSW6dYxjpF2OlFKxg1CDig5g7VsbvdYOsvTkWokQLjOs6h7DeFkqlfUWA/B0anU0wzWUHKnB8ftpx9p/WrB9E6ZZ8q8snv9EWacdHCXVH5dZvGEdmGT+ihtTyZGTPTiV02VmgRbZZ2goOJuL5imlqWG1TpabYIWc/YDTQBLzZW8zFgfBbs2ToJ+mxfCGKUitTZM1VR963QrKLfejd4EyM1V7w2r3vGPPn7NfF5IywFnGrtvf4fty9cyNHdRWrsRD4FpjZ7OP95v2efzE3f+uf/4z/H508Jf/us/+KofyvN5Pv++P196EL25iThv+fzzM/NcpR1p9DwepXf77m6klE6eE9NgpS1JFcxaJeVurWBygjOsyXL/biYEw3YXRZ1oXaoOq6z41iTp1jE4goMwBkm4AjlXnOmM24HDKTME2N9teXrMPNyfGIKEjj56vSOMkjRPa2FdCqU0GpbdTWAziXLy9JS4vz9xOiVu9wNvPtrzcD/z7t2RcfR8/Mktj48r9/dHbvcDcRx4fJi52Ud2+5HzKTNOA+PoORxmQnDEMbKcE+MYKLXjvMH7wOP7E0UB7eNo5N+fC+tpYXe7Ub9nYnez5XSaidHgbCQtK701ci6ChnIDP/0H/gAvX7/GG4cxnrgfJNzRO+vxRDkcZUDAUHO6qk21dUyXFbCxlpIqPkTKmuilUNdMyYlDfcvNm08lvHEByRtLt0g4yQU2dy8JIdDW+dcHeewlYCZr+G4sdV15+NVfYr1/En9vrtRScM5jg5d2nQ4lSc/3tN1QMLz6qZ8hbLa0vOK0canlJKolgvSyccTGkY4hz0fa6UHmYU1PX1fxOvL2vFw9tK1b3O4OZ6Sq8/J3DKhqvMpwpapqq5n14Z70+CD4pd5FjTVQFqmsdMOkqeyEGyJ2GsnzCSv3Wgq7z1BlIDP62rWS8cGT8oLb3TJuRsrTAeMtYXsDXhmtaJD+vBJcZPjkY86HA+f7B8bNThLyrckKHoSRae1Vze5AyY0eHHff+lRIB6WII7t3hjGynBbOT4/sNjt6E/tCXc7Mn39GOs9CHx0jxnlcdFJMUBttLaoCS0CtJLEY2ODFTtG7BKVqEX6pt4K5yllS9b3L66Y+57CZsM5RSsJ4qT+tSbrjWxXEUjOGYbOnp6wBp65Y1ybXutI5nDPsX+w4kLFhYPfihdxAdcU0lS7PA2hpwXj7Y/2SfT4/eccYwyb65x765/N8fgLOj5Cah/v7xHkV9JHzjqdDZhgs4zRxmguezjhGcql4r+obYKwR+x2iWDweEyVlptExjoOm6BtVO+Jb7+TUiFHYpUZcpazLirWOZSlsRkcYIyk1tpNj3AQOh8zD44z3ljA4Xn+0I0TB/ZTcqEW+h7GG3SYwjp7WDf8/9v7k17Z1Te+Efl85xpjlKvbaxTm3CNdYiExA/Ac0kGhAO1s0yBaiichskQ2yDUaiEI2UQDYGGQydJC1lKjG4wCYLp2UcTkeEI+JG3HtPsYu11izHGF9J4/3m3NdgkSec4TgRN9ZrXfnEOXuvNeaYY635fu/7PL9nv594fjwRU+HV/YLtdsHzbuTTxyObzcDd3ZLnxzNPzyc22wW+85yPM5uNxzrP/jCzWjg0ld3uzLDo0Eoznmes1cTc4PGlctyNNL84/WDpVz373UgtieV2IEZpjPrFgnmcGRaD9HVKkSuMxzPn08zm4S0/+vP/BZabDaoiZiJAWUOaA/PxRJmmxtyUZqg293XNMiFU2opZKCds38kks8hhAq1x/YLpfGL//htu3v1AOJPeo6iklLFDT7fayBp2HgHR7F3wQahL3nqmUgiHHYeff8V0PIlmMWtpyLW40qnNXV9b02Qdy+2K9cNbtHHS3PlewO8xiq6zZDFWdQvJIteetP9EGZ8xxgovs15er+CWaonULPe01ko1FrfYoFWRzHPdrrtN1aC9YdZQ0dQwMe+fSWdhnV5zaVt6U4kXTFVzzC+WVGME51QKFGnUyzi2UAcriUhak0Zpjou1uNt7hs0WcsS8uqem1HClGWMsuUZykGQi17Vc9zngOsFY1QzaCSZLGTkQiGsfSDIJzVZx9+41TmtSTGgt+l3tLKVWfO8peWbaP+KMgZQZHz8QDgd5nnqH8fZzFGrOAoyPsVEaGo+1VoyzkvRUaYeCRpzSRu51ljV+JUt8aNNpilZUUWohhZnhZnulLtSciOOMcpbh7k4OtFpT5tRQcAhKSmlJT9KakpJMelcr+ldvZB2vNdrY9vxliJNscZy/4sle6per/nv/jT/PTz+d+Ic/ffq+L+WlXuqPdX3nRvR4jpQCm7UjZzifI8ulxRjTuJciTSyN3ymTpgabL5XOCVj6eAxYA/26Q1VIMVGak17r1hhUAWkLNlQTYsJrDThiCCwWFmsdYUoMg6z0D4fE6TTTWRgWjrv7Jd4LuDyl2ridGW1gGBzOGVKGx8eRw+4ICAN0uerZ7QOPjyPrzcDN3ZqPn47M08Td3QrrLOM50A8WbQzTGFivJClnDpn1uicXiLngO09MgoQqqXA6zuQieeGb7QJtDfvHI84quvWCaZQ15mK5JIZwNXmgLSlGzvsTMcGXf+bP8uZHP8I5h1Fa3O0lU2smHWfmw0E+eNtUpyLvi1KKlOR99NZQcyLEcJ1g5jBTQmxGKE2tmX4xkFJkPB1Y3b+SD/pacEPLrlcVUmiT0Na1XaagVIHax8h0OHB6/w1xHMWdTyXlREUJdqvpFGszTClrWdzfsX71GtpaX3edvJ7L+r+CMlbiMl1PVYb06WuIE1qL47823Nd1Mltri9ZEXrdf4JYr4VdmkSko4V7B5chQrh0TeTqTDjvKNArgvXE/S2wmLq1F69q+p+k7ijLMhx22InICTeNyiq7yglSqoU3krMWt13R9f5U51DmQY2zQeS2xn+3v2U7e//PjHmKW60kZ7YRYUQGjWuytEgZpmCfoPXdfPGCb61xfduilXsMC0BqVMyon5ulMPh6Ip5OYsTrX8FBCgcgxNP2puPeVUVcdsXYtArY15zXntjJvtNYka/FSpJlXSgkizLqWLZ/IMeJ7CUW4/pmc0c7iNhs57ClpsJWGemlkK4DQJZijSFO8p3/1Fu28fC1jRUBinSDmzvNnHfELwOmXtv7UmzW/8fWO+UL9eKmXeqk/8PrOjahSGusU0yQNxnIl5p45puvUwTstn/UUYpDVm9ICuS9ZMrX7XtbzpRlYchW+ptKaOCesVTIJLVVSmUCSh5Sm5MRy6UhZMU6BxcJgjGG3j4xjwBnFctWxXveiJU25AeLFde68pu8M2hrGc+J5N/P8dEQbw8OrJcOiY7cPHI8TNzc9i0XHp48Hpjny6n4tDvfjxGolZowQEl1vKUUSo/qhF0lCqXinSUkkCfMcmc8BVWXKu7pZkWJi3B/pB4uxlnEMbW1oifN08XVhNcynI+M5YLslP/zzf4abh3s0GqUkKai2KMXpOJLHGaV0iz1Ure8SDE4plVJVa1Cg1CJ60tYYpCk0cPolkUfW9tZ1zLsd1jv86ga/2mC9b9xKWfWDauxHJXpJpZr2MzLvd4zPj6RpJqfSWLIF6yxWy8Quldyg6hXX9ywfHlhst3INxqCck3XyJcsdjTYK5XtUt5C0ov0HiWO0vjVDtGZCOJTURmtQCqxH95IXr+pn7qiYahpX8xc2dgVI40jc76RRRmGsXBsoGYoaaZ5qLthBmuOiLXk84TRoZYSzWaSJUhVKiA1PleVbGodbL/G+o7QUIxKUy7RSy3OdU4tpdY6UC2F/khRSZ69or8vBwGjRVqPlQBRDQC89m3dvm56yXKeT8sOuxZyETJL1ak2aRqbdM/kkprfL666lTVmbE71WWYdrJcYvijzTFwYwSpKyBOdUIFeKktSz/AtNqNJamsmUBclUMsZJvKugnipVg+p7umEplAZFi1JVYI1MYFtwgMBEEyXJ2n54eIsdhM6g/aXhlGtTqsrPSAtdKOEl4vOXtf7V//qf4z/6zY/8/OlFB/xSL/V91e+JIzpPkaEzDKueWispt0QeDcYYmQTVa5gNKCPTi1gkrvISzUnjiLYMbaW0rBetxjY4fW1/sKIIU2K9slRjOY1iltisHFWLPGAcI51XbLYdq5W/TtdikpV8qRXfGbpOGtrzObF7Oou5SGte3a/oF57DfiLMkc3KU5Xi06cjzmoeXq04niX7/OZmgUIR54jzhpQ/X3cISRoSpaAqjDGczzMxSCRqP/RY55jPE1qBH3ox/pQ2GWtgceFUgqYyHkdiVmxff8HrL79kud2ilGkTN01NhTSdSeNEGmdsW5GqNl3OMTWEjUx2rPfy33TG9gO66yjTLHo870QCEGW9bDsvk+55Rncd2nq69Qbje3GON26lIHrs5xW1kfV8PJ0Ynx+JpzM5BFIupCRpRZ1zwphskbC5mdn6zZrVwyu6YSFzKOdQWhKNakrIyl8aQON7irLk8Uydj+LANmKOQmvRYV6SuUqbeGhJWTLDSu5TLZAu01B9TXKS96K2+1YZd8+EwwGNpPpczE8lZ0oQvaZB9MZ2ucJtNqQYyeMJlWVSmEtbVzfTXkltha/FlV87j18usQZxgzfMWUkiP1BaC2s2tUAJrQjTRD5PqCJfF6UEft9ictHq+rNYciWWgr/ZsLi9kZ/BFMUsVQrK2XbrGlVAa+ywJJ6PnD+8J08zFEmUUtpc1/HU2mQDVSaxVjOnSAyRblhcQAyidmhxmUqbzyxWq8k5SxOqVePVNjmBaHpavKklzaE1qTKJdqu1PI8lSxJVi1s1nZeJa05N8kGb4nq6m3tBYqWGN1NaTHW1UJEprJIkB/J0Yt69rG5/meu/+V/9If/b/8dvEF6moi/1Ut9L/R4a0cyil3V0jp8nKEYpChBmabZkDNWyrEvG2Taxg9YcyddTqJZPX9FKoY3CaE1qEGuZOGZKzdxuekqF01kazmHoKQVOp0ScE71X3Nz29AuBrJcs6/gYpanoe4tzmlIVx0Nk/3zmPAas1bx6WOO8Zb+byDGzWDhSgd1uovOK1Xrgw+MZauXN2y1xzuR8aUIL1jTXr5aQnhgkPSmmwvE4oZEEqa5zxALTFOi8aA1jTDjnyCAr+8Z7pzmXxynihg3v3r3j5u4Oa52YPIq4vHPOxNNECXMjDEnzkFJGRbmmEkVXqJomryiJizQtIaiMU5sKyf+dpnAFicuKN+HWa1Zv39GvN3KYyG0CVgWjpbT+nO2OJNeMu0fmx4+kaabmQpyDmMSadjKXSqlZIkLb91rd37K4vRWOadOI1looc0tJaut07Sy6G0ipks87iNN1+qkumCWED3mRCCgQwL0TM5e6xCTUIiirWqiqreLV5+e0pkA87gmHk5COEI1t1YLcqimTQpIISVMljaoXugHzGUoSvmVumwMth4hcxLCjrRWCpvd02y2mZEqYyDFijJGUqss6u8qEsOaCVhXtPel0IseAb5inS9qoslqa5SbJKCkTU8ZtNgyroU0k5f9R6ufnSoFSpckFNNP0ienxE3mc5NqdrPeVMcIk1VruB5L6pLUixsi4P3NJ9Sp9T9eSvqQ5NvI6kMllVfUqZ9BGJBVisBPpqHTHtHQmSbBSxuCGFbbr5fVVOTjULNKX2prj0g7Holft8HevJM0qBpmoVkTLXJvEpA3ML3KB6emRNI7/XL9cX+qPRv23/ms/4v/wt3/rpRF9qZf6nuo7N6LOGdFwtg91rRSlQkoFrS/ueMilEFNCGyU6xFplBac0pYKzwgwdpyDRn8aINk3BHDPWyYRiGgNDpxgWAyFJo7tcWFarjnHK7A6C7Ok6zXbbMwyyiixFhii5bYw7b7FOJpdPzzNPn47Mc2Kx6IQROmU+fjhhjWK96YmxsD+M9L2h846vv9nR9Z6HN7dMpwljwPddS2rypJwRrn4l50q/7Dmf2hRUKYbB4nrH+TQLAaC3hJAwrulc50itFWM11jlQmvl8JoyJzd1r7t+9ZXmzlaGZ1tRmxkgxEY9HyYm/8EARRE5pcs0SJLdba930eBnjdHPQJ5Ru4QDWiDbvsv5tUalVKYbXr1nc3eN8JwaY5vZuofLyv4thp1Ti+cj4/EQ4SJZ7DgJKT0miGkspch3NSFJKwS96tm8lqlMr3VA+7dlJLb+9JJTr0L5D+QU5F/LxEzVLHCXKXA87aHGJ16KuMPKKEld9W82rSwxmmK5NGeriqpeGLIdAPO5I4yj3ySjRK9aK1gZdK5lLI23BWvRyw+n9e6yuTXrbpvv1ekbj4sbXC086B6quOO2px73EijqPNq45v6V5l9hN01KhKqbv8KsNuuvZv/+WOAX8JW/+aq5R6IZSyrXitmv61QpFRkaoRvSvWkEVfWtt+lNlHHGKTO+/lmttzb1SYIYGq89ZEqkuE2dVCbMYEWupWO/QCuZxoipNN/QY54RKYBUUAf3XIoEJSkEaz4DC+K6FQdXPyFatMNbJoa3zmL5vk83GD23GNxSSlGRt+7qKNAeKVjj0dWIvhxNPG/s3BJgFJQa36emRPM4NuP9Sv8z1r/23/yX+R3/l77WD8ku91Ev9QdZ3B9rHQu8N2ii04hpHaZ00ISEUUsxoLRNArQ1pnkU3V4FUGBauTSolklPIOqJ5O4+ZfnBorQlTYDEYus6xPwln9Pamp+8t5zFzOAZKjiwGy3bb03VO+gdtSDGT23U4b3DGMM2Fx8eR3e7M6Ry4uel5927LFArv3x9YdIbtzYJxLFcHfKnw6fHEZrPg5mbB/nCmc4L+CSHRdY6cs0xGg2jjfO/59OmE1QJN73uD6zyH/YhVlb4TAH0/eGqVNavrHKoWWTtWxbg/Y7Tjiz/xY9Y3t/jFUtzDStbMGEs8iRaUIutz5SykQs5Jwn60QRXJ3s4NOWScRDqWkEk5Cay+rbBrLp9TZqqk3ChjWbx+y+rhtdAOplHQQo0FKoOqlpakATTn3UfOnz5IfOI8iZxjjsQ5XidcSolWUrLcYXV3w/bdO7phQKEaUJ+2Um3TyZJR3QI9LNB+IXzL/UcUVZiUqsrJQxuqac1YStIktbhOMyxQJcmq2vSQorilL5Nd01a0bSWbppGw31FyQnc9Rkleu+4lkvKqQUXc4HroUb5nfP8ewoTqBcAupr3SpoiaXBIkhXWW+XyGAp3v0Dmhhx5wYqYxlkq5NrG1CFtTW43vB9xqjdKGzlhuv/wBj19/zXQcGfpOpsc5o5yjZAlQ8JstfrUQKUKjEsg6OkICmhzmoltNqjI9PWOQaXUuWeQ1Qy8Hl5xRtV4xS1rBeJquOmPrZXsi/4MUJpT39LZB/KFN42M7TBnCNFJCFBNcksOBceJy11iUNVQFxir8YiGT5elMjbGNNsWkVEJqpjPVkLOZOE4oFZi+/Tm8+QK3WLWmXjXCQGp/PkkTfjhyfN5Rq6Yf+t+XX7Yv9Ye3/uVfubuocF7qpV7qD7i+cyPaucZiLIWMbqYSyzwXUowYKove4oaOaYzkMGO8YQoFo8QFfx4TVkPnDTFmtjcdT8+BkoRDOs2ZeZzZrD2lah6fZjoPt68GfOfZP88cj4FaM0Nn2G4HusG1D0QIYyTMURieXmOMIWTNx08njvsTIRYeHpa8fr3hcEh8++0zy4Xj4c2G/SnxvDtzt+3IpXJ8nnj9eo21mv3zkZvbBdOUmafIYtURQsJ1jhjlA9oZz8f3B5l0KugGi+s7Hj/s6DqHdY5pnBkWXqap3mO8J5eM6TqO+xPzeeb2/hWvv/iCxWqF9uLGl0jSQkqR+Hwgz1Hc4g0GrsssK25rUEWauAu8PquK7y3WO/IsjEb5b0UQPmFCNV1fafgkv9mwevsOv962hi6izEU/eVld16sLuqbE4cNXzLsdqhbm00mQWbkZ0ZAJuoLPq/kKN+/ecfuDH2I0YkBq2kBZwzcHORrd9ajlGu2WzM8fqeeduLK1pHDVS6KSFjxQjb/I+yzofoGuBchgxIne5vpN02ovmggohXQ+MR/2lJxFN4tM2LS1qCion6sLW2nsYkG1nvnxCdKMtpqcQstezxht0daSEVQTTnM6nlBO0VtPmiP9doO2jjTP6IvGNxWRIigAidk0xuDW25YsJet+azz3b9/y7c+/Zr/fsd2swVlKKqSS8eu16JFjkOeksTlrGCm1oK1upAJHOp/J5xPn9oy6YaCEhM4R0ybKZQqgRKuaQwKtOe32bWNgMb3wGUsuoC22s6iYmD59Ig09fYvRLGGS6au25JRktX+RV1RZsZMzoKjOytTaCKbJGEOJM3mcqTGiu+5qiFJGkpTyHKi5Mk+jbBSspswT55/+Fv71D1g8vEVRYB6b5lem/GH/RDjsWgOqCeFlNf/LXP/Dv/Qf8s3z+YUn+lIv9T3Vd25EtVZYKzgU3Vafh30gxshysAyLjlQUp8OENpWIRsVK7xUpKaYpsVx6YjOrDEvP19+e6Kxms+05HgOaws1Nz3nMHPdn1ivL/WsxlXx4f2S3C3RO471he7ugH5ywEwvMYyRnMSU5J3rTKcCHb3ecDmcq8PbNmpubJbtD4P37HYvB8fbNhvOU2e9O3Gw8xmiOx5GHN2uMdZwPR7Z3K54PAVJkc7PkdJjoekeaRYIQU2HaTyyGnpJmluslBcv7r59Zr52YSkKgXy1JIWKsJ1ctyTLWcD5OTPuRtz/4MQ9fvJXUGOuukzrjeqbTmelxj7EOvxjEqJRlLVpkb0lNont0i06MKfNMt1xgvCOcpmYksQJRr7aFByS8c4iAouK3N6zfvMMNA3UeJfPbXvR9sjK/NIuXeMrTp4/MuydKSM09LWYfrSoYMbWlNnlUpWIXPZs3b7j78sdQhTHKRbOaGhu0GWzoOsxyS7VLwuN7OH7CuE4muaVQkmCulG0JTtMs+e7OkFLC9huZUNaK7hei/bvklBvVmJ40PWMinvbE05maK26xkCj6ccI4LznmVTBSJYtm1a425Arh8QlDoWiRKtQsznBjLVppSkkY7akxMacZOstgPaWCX29QxlJCQDsnA94gGfG6TYRrqVijcUMn08z4OWa0pITSnnd/6s/w1T/5J+yPB7a3W1KYcZsN3WIpEaIpt/W1uNQxNAmAlam2sShr6W/v6azjsNsxT2cMgjcCRY6REmUFnmNGGc35cGI6TnjvsF5SrWKMOOclLjQk4jRhjCaOZ1LMLHo52Brbyc/Q+YzVFuO6lgLVdJpaJCu1VqFuvLpFO0s+nWRSXOXPSOxskgNTLtQk9IhxPFOmgF8v258p5JQ4/e5vk45Hll98iXWScKWopPOR+fEj2hiRjygF5SUO8petLnSHf+Ov/D3+058/f9+X81Iv9ce6vvNv2OXSorWmAOOYOZ8CWlVut/LBcRoTRld8pzieK0YXlgvHeUzkXFitOkCxGGSQ8/7bIzdrx7Ds+fjpxGowrDcLdofA6RS5ve24vVuSc+Hj+yO7w0zvBCG13nj6oQHzSyXMYq7pOoV1Gm0NIWk+fLvj+flIRfHu3YbtzZKnx4lPn/YsBsebt2v2x8jzfuTuZiCmwuPzmYfXW1KuhGlkuVnw+OnI7d0G1285PD3T9ZZpihgjOKtSFNZbVA3cv9lwPCaeP33k1esNIRViSHTLFalNo0CjtTTQ43kkjZEf/qk/ze2rV7ihFyNREQe46Xvm3Z7w/ITvBtFIGgUN/J9DaMYRT4oRvxyEnVoirrMCPh9nmcx5R6kJ6+01jlKr5gw3huXtLatXbwThlEVfepkUVS3aOdU0lNo6wjxz/vSecDiQ5iCxoUC66CIVzXDWVtMKbN9x/4MfsXr9hpJj06R2krwUprZmFROLHpboxYZqOsLXvwlxxnQdtU3MxCVuMb6Thmye0H0PKInUXK3huJc512ItU9AcpYGuVYDlVCqaWjLhuCOeT4JmGjpBCo0S6VljA6Qb15zZoIeBGAJlOqNVbc2paC61Btv3gkzKBaMhzzPzHFi8e4unEg5HFg+vJC3rdEJZh65tutvg8DTDkes8brGUa0lJDiLI6p+Lyz1H3v2JH/PtT3/GOM906xXdakmJgTQFaptsqwJmIRGwuu+oc8CYDrTFLNeYNmlWW3g8jSjbYXQzHuWCNuJez6UQxkDKGb9eQBb6ASWjrcN6f9Vr1tpMTrWg0ozWK+zQk8ZImkZQYH3XWLG1xW3KdRYE47Z89wVKG3IIaG3J0yzXaeXfqdaQlpopuZDbMz4s+kaNynIIA6z3jF/9nBQmtn/iTwu1Ik6E3VMz73mgNqnBSyP6y1K5VGIu/OW/9Zv8X/6D3/m+L+elXuql+L1MRI2mZNgfIjFlvFcMg6cWxXQOOKeJWZFCZTGI+3V/CnQWFoue3Jy+h2NiHiNvHgbmCN9+e+Rm69hsFzztZkLM3N13rJcd85z4+GnidIr0HqxV3N8NDAsnseWlEKOseq1rhirrBEj/ccfpMGKd5fWbNevNwP554rA7slo67l5t2B0Ch/2Z7bojp8I0Rh4e1hJNWArWdTw/iU4UpTg8HzDWMs8J3znmOYEyGJPRFLb3Ww7HmTBO3L+9ISXR3HVDLy5q1Yw9SjSlh8MJ5wb+9H/5z7Fcbn6Bt5hl/Y3m/OmJMs1o00sDpptWFJnsaOeaWzjh+15wTSWiqqyu0zQJmqc58a/8RSUrTKpCdT39dsPq7k4mUZc1uZbmRjo5hUILK7IUQoicPnxDPBwpKVFyIc6R0qD0Qi8ogt3JEqPXr9e8+uGPGG62lDg1OD7S9JYsGkjXUZXCLJbo5VbMTt/8BlplqvPge1RODZRuJUWn/X28pyIyBtsvqec9AGZYinkphTYNbED7lk1eayGez8TjqWGhxDQWxhFt2wRY0+I3kzRZw8AcAmk8Ylo8bW0UAVISD5cxbbKriOPENAXWP/wRy0VHeH5i+fCKSiWdzqJvvWCsmuzhYk4yfYd2gzSdJYF2KKua2UZSg7hoLZ3jzQ++4PT4Eet7yhTIKVJiRBVZwysrk9kLKF/4qUoOJsaJHrUWvO94+MGX7D58lGjNecZoI8inmkklycHGtXhe5MBhBo9tzNQYJlLMWOuJc4QqCCW0pYRECVOjPXTi9Ne1GdratDdE9LJneHgLKZPnGa1Fr1tyBiROVFlx8auL7rkKC9f3EoKQZtED51Kw1kKW6Wne7zj81j9meHiLLpES5xYQIXxUZRQ1v6xs/6hXLpXn08zf/8kjf+Hf+dXv+3Je6qVe6hfqOzeih2MkhIIzis1KjAgxiJbPNi2oRWIrp1AYzxN9b7DWionJKo6nQC2Vm23P/ihr3IdXA13veHqeSTFzsxEW6DRXHp8mpjHQO7BW8+b1km4QTE2tpfFKK1pXnPeUqnj8OLJ7PHAaA67zvHuzZlh4jvvAbndmufQsVj0fPp2J48zN3RKai/zhYUUMhZQTSlnmc2BzsxbdYIx0znAeZ5w3zHOilEpnhXfo+4GnT3u0gu3tivMYcdZg+4F40RdqjWrQ7inBqy9/xKvXb+jXSy6oRWqlKE2YZsq4R1uH6bvGW20udRS56UCplZQSxntSFUd6LXJwSCleHd4CCZcPZHJENy6jXSxZvX6N65shozWdQAPCNjB6SyUqwHQ8Mn78QJ4nckyEkITJ2FSj2ggXUilaBrthdbfh7osv6VdrysWdXBFzSI5grEwzlbjblV+Qjgfy4Uk0ksajlWnXBNp6WafHICt/a6kpgO3EmX1+lq/pe0HzlAY6v7zGKpraEmfC6UQ+n2US3bSZOc7yvZoL+5L4ZPsOrCPGCDEIt7UqYWEW0ZhWpVDWiv5SadI0kmtl88MfMSx7xo8fZVqoNel0Qne+rbpbc1hpaKmMNh2mW7R7VQFzZXdiWgrSPF1s5aTpTM5Z3OUhNMMUcogwGoyVZyQmus2GHCZqyRSbME6egQv8vyDN9Pbhnt2nD0ynjFOFWjIxR3lUysVIJRQE2zlc31FClgY416vxClXoFguMsZAhN6SV6kQeIBNqMLVSrcSx6s7RtejOXCZQhTzJ9NN0bTpdCso4ashkVclVM58nuoWY0tI0X41jRgv3uAJuEIlFOByp9Su61QLtO5mmzqHpTR0lvmhE/6hWrZXfen9gdwr8G//H/+T7vpyXeqmX+mfUd8+aT5nB64b6gRhj414qcih0Vj5Ad7sZ7zWbdUfMlRiT6DjPhcVgqRWe9wHn4NXDglIUj08zULi58QyLjvNU2e1GSop4I83t/aslXS+aupyyYKMUOK9lQpLg48cTu6cDoBiWPa/vFjhn+PjxzOk0sxwc/aJjt5soKfHm7ZbzGFFkVquelGimoAIqsdr0xJCuDv8YEkYr5iljrUYZceajDPvnkd5rfN8xTwHrPVqJpo6G1clB4OHOL/nhn/0V1rd3EpHYGqNaIedInCbRCGrhgmrv2jRMstAF/C1c0DCepQnTFUhi1klJMEAtsUb2yGJQMs10prsOv1qz2N4Ieqgxn66zH63k8bhEPQIpJcbdnvHxI6oIszHFdE2zyblQSsIpJ6aWUnFdz/L+jvWrB2wn2lZjZPpXYxR9gjXSmFqPch1oQz63JlRruX9KEDrSi9vm9Je1uWChMrpbSiLONFL9QnSNJXFJQpKGul7ZmjUEpv2zTL4uufOptHZakqdIWfIxa0MKOc88jpRpwuqGmCoFbUSekaf42fykYDqeKFqx+vIHdF3H/Pwo026lmA8HYaa2aErx2rT3S4Hpemw/yGQ6iWRBO09tq+dLklFDGFDSTEqpaVTlOeAyYafKv6+QpgnXeTDyPiss1g9ApZYklIJGEFBaoZTl5osv2dmO4/sPMM7kkiS9qT0wCgH9O+9I55lc238yGqM1JUf65UDXC8M0pUwtMl0W9mzTBV/wORqUc3S3d6gMlQxFCd2hittdGyPbASW8XFBUa4jnCe9EcytMOZFxKPv5IKIuoH80dtHTrddYoyXaNMtEvyIT2XqJrn2pP1L193/yiZAK/+O/+ve/70t5qZd6qf8/9Z0b0aGX3OocM0aLeSnXKpM8q5mjrGe73uI7iR1UtcV0loZuahn1q4Vls+mYY7lmz9/c9DjnOJwS+9Yo9p2mHyyb7YDvhB8YQ7rGg1orMY9zKDx+OPC8O4sRatFxdztgneXx8cw0R5YLj/eW02mm7y0rv5AVu634riOE3FAzGkMVbWXKWA2UwhQTKUj8YNc7jK5XvWcIga4zoB0xgXbijMdoqpK0nTjP1Fy5ffOWV+++oFstsc5LwkzOlKJI00w8nWUqZIxM1ITbhKqVHKKYnYwFCiHMJITNqmpBVYgpyYpWV+Fe1oaxyZlKxTqHGXqG7ZZuueYauWjFjKIumChlpAltTU6YAtOnD5Iy01bRuSXyXFKhUo6UUjDatDjQgcV2y2J7K9NGuMZOXqanWIfych+U66lo8mlPDaPIDi5MzMa7rLVNHWu5NuNoi+mX0szmBH4Q7WcKDYouU+Sry7/xKsP+KOihpsO8gNRRgilDCWeVxlatzpPCDHHGWdviJyXbXdmWM29SO1hU5sORUAqbH/yAYbUkHg5CLXCOFMK1kattyquQaaTWGud7MWW12MkaA7QmVHiu5XO6Vs2UFEhR9I+15BZwILitWi7ParvvRTS8ZQ4YIxN32jVfmnRldCMS1HYfHDfvvmA+HDg8P9J7f32dwuTSuKGXCXgtUAWdpJQcgFzfSfOrFLkZpowfBIA/zaA0upPpe1VKmtDN5fmEWgJlmpq6xbRnQZ4DSkV7Qyow73cYZJpKbrGxpjXVtTZTljxHtRTscolfLeRv5Hz9OxhDnSeMdWjrfy+/U1/qD0H9zX/8Df/zv/aPOIf8n/2HX+qlXup7re/ciJbmlDZtO1oRJE+MlZgSndc45xsnUlzSIWSsVbjOMU2ZXCo3G4/zhtOYCSHTd5rNWtaUkvMeKDnR9Ybttmex9O0DtZJCpjT3sGkT2PM58/w8cjpNlAKrdcf9qyXWWp4eR1JMrFc9FcV4nuXruY7TYWLoNN3QcT4GZLsqiCJjxJhFlWar5ELMFWMMnVMoJf8cU6HUjNaGnOVDsVSFigHjPKbrmMaJcJ7p+4GHH3/J9s0bcVI397lETyryPDf9m27u8SSaN20oc6CEKCxH59HWEOeJXAuu89KsUsWcoaQBEWmiNGAlZ0oqaGfxqzX9zY3EVBpHVRpl4YIuujZ+KbQJqUzupudH4vFw5WGWKpOpNviTJteKvtB1nmG7ZnF7i+tlCnqJtbxQklRF+KfGoIwD48kxUeOIojaTVGsdS5apoHRqrfnh2iTrfhCSQ2mu/ZwE9XMx81wa61ra2nUkHPakOUp72jSgJQWUtqKjRMm0TmnMYkGmEk5nVJgwTftZFVdWZs1VzFxoUpjJIVCcZbEY6DuBuJeYMH0vq2R90cdWqpKJalXC03TeCx9VG3GAh0luWJxl2tpSpxQXA84kJiGlZLqrBf9EhZoqukXryhSxJWbFhBpWGD/INL5NvpVuTVzrjC+57RjD6dMnwn6Pd/5zRKkC4x226+TnJeeGoZpQSiJD3dDh+44aEynMlJLpFqvr5PYqNWjPkXIOv9pg+kEOaXOkpCDyFG1k6p2SbBuUQntPiJH5ed+CEiTW9vLMqcsEPkRZ8SfZKLjVEr9coRq5Qc44ksR1iW3Vzn7eErzUH/r6f/7at/zGN3v+vX/w85cm9KVe6o9IfedG1OjKnEFXsE7LdPMU0BoWS0/J9WqGOJ6lIVgMlpzheIoYDbfbHucsx1NknjPrlWWxFMj9cR+Y5oSi0HeG7U3PYtmhW1pSnAXWbp2s4iXyM/H4ODGdZ2qtbG8G7h+WpKz49v2RmjOr9YIQM3EODIPwSafjRN9pUq6UUSIYnbvcCo1WihTFUR1DQlvLcuWZj5M4ir1jnoLIFXVzLyMb3DRHfN9jup55msghc/vqFXdv3rC8vRWHd3Pz5pqpVbiMl/U2WstKsRlWyhwE+o3C9j3KWckGNxqrHKoI9Dxrc+mM2oe7lWlsEcexWy0Ytrf02xthNXKJsRRQ+jUHsaSrYz6cZsLxSJ7OlCjpNRXRfZaSSb+Aj6oNht8tejavH+jXa6yXNbsy7tqMVtr3aXnlWGlC0zQ2BqeVKV+SiRZaiAC1XPLMpVGoWTSe2jpIkYLwLAXYLn/muuYVpxI5BebTkTzNlBCvDfSloVUXjik0nafDLleknEnjCRWDTAFzpao2Obw0fLmQUiJMI/N5Yvlwz3B/D0HMYnlumCkF2omBJrfUqAuuSCuF8b3EhWrbGstR0qOcu95LlGla4EJqTahC3PTQkrTae1K0SFhKzrjFSt77WuX7eLmOa/67baxgbT4boVp863m34/Czn0Cc8V1PSkli4q2QGVTjqopZrqKqopLxi0G0mqUQQxBHetfwW839L6a5IsYgwHby80OpV+MURQ5S2gmmq5RGPfASp3t+fMah2z2JGC2mLN2a6JITyll5BqeE8ppuvYZc5FnQXF33RNGdau/FtJRfGpo/7PWrP33ir/39n/HrX+34+vlF0/tSL/VHqb5zI3qehAtpvWaOhXlKDL3BeFlDOy06rONRHPSrpWMMlTBlloNluZK19fMukHNmubQsVo5pLByOgTnIGtxaxWbbMQyugdwrIUhjIfGfMrgbp8LuaeJ8mqjAw/2azbYjRPjq6z1DB7d3S+YgOeeLZSdr35xZLj0hJJkUNZRSqQpNxRnROuZSiVNgsWwffNPIsPBgHPM446whq4tATslkrRSGhSflwuHTI8Z4Hn7wA25fvcIvBozz8uHaGjj6JdOnR1SUBqxG+fcKJTrKXMl5RjuD7XuqkoQbpaXpLbVcHe6lgK5NE2gMGCV55kC3XrO4e4VbLFumeKE23I9qTnxabjpIgzUdDpw+fkRbg7ECcAeJskzTTAwRkGSdmmQauNis2L59S7dYySTK+s/r9WvCEE2PCrieqixpPKJyRFsn19N0nWiFatM3wtgywJVM3XyPVoUSZmlWOyEbyDqYz1+jNds5BsJ4bhzMtsJWCuNtM/MoTD80V718H7PaEMJMnUdUzpISVqo0hpdY1TbRjjE2RmZgePWa9bt3kAOp6VNLytSar+YnraBo3cwzImfQXu6XvCe2mXCaDrLJOEAMXtRKipM0skpdV/Vc4kDbGlwbg+k8KgRqChScpAo53zTH8SrNqO3/19pc1+1KwenpmePXP6WcJ6wRsHyuos21XScyEuS5LumS6BVwi15MhDERxzOUihuGNk0ViUktcuBSTd5huh47DECh5koNgYvMWSkFWbYiOUWM91StJAEqV5SppNgQVbZJKoxIG1SpYI2gzJRieX8vGu5GUrjE1tYqzxfIYVflSnmZrP2hrfe7kf/p//VXeTrN/Pzx/H1fzku91Ev9c9R3z5o3wis8nCLWwGbliUVxPs8MXhFT5XQKbDeOxXLgeM7knNluLMPgCLGyPwRKydxsPYuF53iIHA6RXMFqMEZxc9OzWLhr+kuYxYTgvKwMa1GcT5mPH4+czzPWWx7uF6zWHadT4tPjGWsq9/drprkwnSeGwZOLwujK0HtCzDjnmELCe0WKMh0sJVOqphaJ+lttOuZzgJq5vd8yThIV6HtBJmlrJKozi+atH5aM08Snrz9y//YL3vzKj1nd3OC8v8bHlSQTWL+9Ybh9hemXPP3mr9FdNGy1OYBLJReZGNnlgmos8dzA7Iqm+xNGpaB4NNVojLWUnEghoIyl396yfPUg09RLpjpyLRgrjU5KV21gKXB6fCScjmjdppgFLk1oPAsYXzVMkqoK4w3D7Zabd+9w3dAmVR3K99I8pnhd89YKyoqbPRXI4w7ddH/iFG8RoqblvmtNTbOkIdUiGuXlGqM1NUVMvxR9axEzU1VajC2taaMW0jwSz0cx+OQszvecxZgCV02kvMqCMhrdL4lhghjQl6lYkVSqAp81mkaibOM4knNm9fqe1at7KJk8Tw2vJfKIC3hfUoQE9ZRzEqlJ16FNJ+9PmwqjkGYeaTBrLm3S2SJUqS3Y4GJQKu37iC64xIgdFui+w3SeMk1o2zWDULvX1lAxYsrSbcKrxeCktOH89MTTT34CrXnPpaLJWGfQjUJQsshuagP4hxgw3uC6Tu7/OEEu+NUS2w/NZCb3u8REShlUwa8XuO1WMGWlQErXofblz4qWN6ONJReYdjtUzrJCL6VxSKVJFglJRRWZGMfTRC6ZxcMd2lpKQ5vVIlNpMXMlSsyNpSsHUrda/l5+p77UH0ClXPjv/1t/h1gK73fT9305L/VSL/Wfo767RhTDdA4sB43zjsNR1ujLwTI2aP2bhwHjOp6PiRIjy0ExLDxzgOMx4Qxsb3uMtZzPhd1e/p4zYKzh/q5nGJwYGrJk0lPFNZ+ipBgdT4n370/EEOl7x+3NwGa7YI6K9x+eMRrevL3hdAqM48R605NiwXnBFYU5YI3idJpZbQY0Fas10xyoSENtVWa57DjtR5Su3DzcctrPWFtFj9ZiDXOpKCLWWazzPD0+k+bMn/ov/pe4ffMaN/Ro09aBrQlV1rG4e4VfrlHKsH54QzifGL/6Gd65NjFNTcem8ZuF3IvzDmccYc7EFPCdu078JPFIob00XyUKvmfx6g3L129FQ5qlkVC1yge9k3X5NR5TOUpKnJ8/Mh920py1VW3VmqoU4+6ArvXKCNVa45eexe0ty7fvhEEZJ2lCu17W/yk0HJBcp9Ia7XtimClRIPjiYDYiDyhV1vUli1ogR5nkpUiuCnfzgEYc46ofaJZpkSTE1Boo3f7vSJomwniUqVitsgZ3njjtZXJoizTptkHyjaP6nnk8N3SoBqtgiuCs/PcslAelNHGeieczxlpWX7zBqSqD0jBfOaUosL3A3WvOkopUIceI6y1uWKCNl8msdShaI3bRT5ZKSTPKeCiQxlEOAUaT5hkK0sSrSokz/fa+ucWL6G1LQdzha2hNLQ2Wr50VPaSlaXUNVNF5np4+8fQ7vws1k1tGvUwJ5eBoOwtoQuPHGivGI9dbfNdjrfA4jTGoocMMvTT/Wl8nyWhFThHbO7rtHUrbxnaV58wYK41rk87E01kOCtYyPz7DHFC2HSKspaaE9rbJHZQwT0OUZ5aCv1nRLQZqmikpQhazpchiVGOpNsxVC4E4Hw6/L79sX+r3p/67/6u/yTkkjlP6vi/lpV7qpX4f6rtHhpTIw23HnBSfniY6V+l7x+EQsFbx5vWScap8fH/E6MrdTcdi1TGOlfM5YE1hs+lwznI+JfbHSEqZ3iuM1dze9QwLL5+RUVJRtAZrG3bIGOYA336zYwpRYj7XHat1W8f//Amj4Ysf3vL8OJLmwHozME8J37sWNSiTuXEK9L0jhkDfOc7jjLGGecp0XtMvBnaPB4bOYTrH08cDN7dLYmyQa2tJqWJUvbrav/nt32W1ueXP/Vf+ZRY3W3GJt5SZKqmX6GHJ8u5BBk7no6yqhyXbd18SDwfy8YBpUzLtLXYYmM4j8TxKfnkeJU9eK+ZpgqrQWmO8RxmkKVEKv1mzfvWGbn0j710ShJZgfJSsXRsM/MqfDIHTx/fE00Fek5HmU5VKngPjSaYOqQHtZYrnWdzcsHp4IwaSeZJGqjnkBaB/ccnXFiVpOH34mnn/kWH7Cru5bY2jwPLRyIpdaWo6QxUtYVGW7u6NTC5zkiSmNgm8rLEbT0xW2aWQzkfC8SBr19riaZ0jp9yM3VpCAXLCGC155cOScDxBjGKm0poyx2sTXUtpk2JLToFwHkFbNr/yJ9A5odo9rmGmKkMNCdNZFALDJ2Uq0iC5zuBXy6bnBdV7cZs3NNNVg5EmSXSqlTSdyFkONOKIv9wCSzyd6G62creTpAjlp2fs0NNtb9G+E0f9PDekWKFMMjnHyipfKcB6jo8f2f/spzirqPiGTariLlegnWh3c0yiadaa6TBiO48flnhnG8NWUzpJX6upyDNXxQxVkuiM7eBZvH6LurrTVXuG2hSYC6Ipi1TDaM6HAznMEmebMrXK86O1wmgrz4kSgoVCTIj9aqBbr+S5yZkam6HJtJz5nGQCrkUyUGLidDxx+Lj75/jV+lK/n1VK5V/7y/8hv/H1/iUT/qVe6pesvnMjut4M7A6J6TxxsxJczf4YWSwdm7Xn8Slw2M+CZlp7FuuO4ykzniPeVlbrHuMs52PkOGZykXSmWiu3N7KqVyhiyISUcVZjjbriWqa58OHjEUWmc5rtpmNzu+Q0Zr79+iOLhePh4Zbd4xlNZbFZcDoHFoMnVyMfYogrtvPyso2zPO9HnDGEMTIsHF3fcXg6shgcynqm04jzHXNIWGtwdOQKxkgCTpwjx6cnXr1+xw//9J+h29xcs6srgt2pyuC3N/RbSS6S5CSoLe3GaMvmzRs+HXbUlERH5z3j8STTIK2A5jivkKcg+j9nMd6hNIRpppbM4v6e7Q9+hPOemiNNzNcMPPJ1RALQojSNJ00zzz/7HWoOGOeayFJTYpYVcs5oJKrzAsvXrqPbbFjdP8iaPAaZgjqJRiQFLk58Vas0TrUwfviGuH/G+IHT+6/Q/QI3rD5f34WBGUaomXQ+QL+mu30FVFnzNy6mMrY1maU50Y1MX3Mink+k8STGnhTE2OQ9SiusNWgvLFKyNFgYQzGGuN+hUhTgPJDPI6CvoPnaTGVKSYpRf/9Ad3uH1ZDOO8xyTZ5nSS/KGeOkyZZmqbnlY6BbONxyI11krSjfN15oavcCcbPHQjUeVaI0oSUKNzVnQUFphXGWkiN2MYjLvkTIkmBk+h7TDWjXSxMaIijReapSUNqitExTsWI6Oj1+4tNv/zZWVYrWchD0mhLkuqwXHWtOmRwSxjnCNFKpdIsB20gNOQW0cSJPyKk13AalBEWWY0QpWL59h+mGplOOkCq4TibB00zJiZIyphf96Hg8Eo4nfN9TUBgvDXGeM679bNckwP1SC+SCWy7wq3UD4MshRHsrk/Ams8gxUHJB5UiplRgip087FkP/z/8b9qX+c1VIhZAy/5N/+x/yj3/+ciB4qZf6Zazv3Ih+834ECtuVIVXFeTezXjuG3vHx40QImfsbRzc4hoVntw9MY6HvYL3yaCOT0MM5EqZ41eK9fbtgWPXkVJmmSEoF6xTGyroebTidEu+/OcgHRYXNpmNzs+RwjOx3Z+7uBpxzPH464rzC9QPPzye2a0nqKSGKm1pDVaI9tNaSckYrzTxFtrcDBcPzpyNDb0hFMEzdakGYE9YYzqM0sQZpKs6HEzUrvvyTf5r71w90yyXWCQuxhAApo32H22zxy61MDWsBZVBFQWeoSkOc6IaO1evXnD98ZI6Z6fmDMCWNwvoO6yyhBkqu1Avv1BhZ92uFcY7lwxesHl6jrROXcOGzWUNraUgb6B4jbvPx6YnTx4/Ui2EqFQHTp9IkEgVVMzkmjDG4fgCtWN3fs7i9RSstOfRtXcovRIleBX7Ok3Ph/OEr8vmAcQMlJpxfMH36Gv36S4xftNV1os4jpCAT7GFDd/taVvxx+qwfpV4z58mZenHMl8z49EgOAWOdNGVGg5dGWGdx7pcLV7RkqpZs+rjboSvohqEqKaK8lSmmER2lyBkSJVcYBrr1DZZKOOww2lPOE1VLipWyRlzXLRP9YlTTVmP7JaUaIU30vUxzU/o8RUc0l2gDJRKnM9SK6wf591EQRRhDinMD44tOsrQNgus9xi/QXd8mgOkzxzUX0Qi7ZrpqbM5xt2P305+iSzOiaWTlnwpohUZfjXTzOGKUrNYpmeVmhdbyTNreU604/cnyzOcQKUV4rTlm3OBYffkO4zohQUAzDWWYz23UCzXIIUMpTQ6BfDrTD33TKVcwom3126UcmrSm5Eo8nikp41YD1jlpci+4LiXPgcpZDlH9IGsLJYxejGZ83jOsFnLueak/0Aop8+kw8+/+g5/zf/q7P/m+L+elXuql/gXWd25EO1vpe8s4FnLNbDce3zmed4GUCjcbx3Ilzt7Hx8CcMstBs932gOZ4SByOEzEIBqjrLW/frrDOEoO48C9aTmfbh53SnA6RD+8PjGMABXe3A8tVz+555HyeWSw7UIbzecb3DRe1H1kvPSE1p3bNGCMsyYIh5QI1EGJhniN3dwvmuTBPE8PgiEnQTVhHCIm+b055I5ideUwcn4442/HFr/yY29cPdKvl1eFdGlRe9QP97T12WMgHcgUQPVrV0ghcc8mtZ3H/ivF45PTtBygZt+gl+9xYSs4Y9znJRitZE1etcasli/sHFts7cXZncbTLCr60dXfjQxojXyIXDh8+cPr0iHWiFcxTSxgCQe2UC5syY73FL3twnsXtHcNq1fSmoiVVDfUjPMrGDlKitcsxMj19oIZZuJXKoHKRlajRhP0T3Y1DUanjqU3AEnq5xW1uqElMQxcnd22TtKprmy7Lur6mRDjuiKcjxnWkSSQX2nvEbCUYnxriNctc+Y4cE/FwwigtTWjOkrBkdNNU6KuhqdREqQXVDfjNLUZBPOzkPqkq9yRlmbCW0iD5jb2bCrazuMWaqiT1SXvftIlihqotPYt2cKhFojKVUtJQtgdAa4G+i0vctvcXmZQ345k2Hdr1kEojBTRZBrKyFj1ow2Epw7zfs/vZ70IK+M5SlSInYYOKgceAE+xZzW0jEAJKw7BeY6y8hyLr4DqprBdQVqmUFButwLD44gt0P7RrKzI1bqt4pfRnPu2iR7ueOE/M+700le2ggJPIX2UsZY6C+LIyKU+loJzFLZdy21KSgx8iXdDeUcaJy7ZBdx4/dFSlOHzzHouET6mWRvZS/+Irl8qvf7XjJx+O/C//3f/0+76cl3qpl/oDqO+uEdWa3V4c83e3AxXFbh+hVrYbx3LVkYvi6dNMyontyrHedKQMh2PgdJxJIWAtbLYLbm97lNGEOTGNSdypzuA7g7WGmGH3NLJ7OjPPki39+kEa16cnAdUvlx0VRYqJrndX5+5isBIvqSUZxjgrE8VUiefAYmElA1tVQTzNkXkK9IN8PXVZhSuNUUCu4gZH2KnpHNhu77h7eM1qu8EvFoKcKZBLomqDv7mhW60xXX+F1l/WyDU3E0spbWIJOWfG3Y50PqMV2L7Ddr00QKVeJ5slSZKRAnCObr1l+fCabr2B0vA5jYt5kQBcG0MtAPlwODB+eE847TFKYYxu4PdKLoUYE/M04xoI3RiDXw30N1u61QY/LKURsVbWuQ1JRMsob1BMaq2E44F42kGK0vw01qMZugZnV9QYCM/fYpzA1XMI2OUa6x11Pgn03rrrn6U273+O8n1SoIaZeB6J4/hZn9uaIgDTrqeki0ShQjeQc2Y6HOm8u0aFKiUmsJqLmMAa5L0CGaiuwy2W6Foo8ySO7VqhiPSjVmCWFXtV7b2u0oT61Rq0Q1XhVOKcTFwbSB3q9UBTU5S89loF0ZTLZxarNtQUsc7JVLM0xpEGjUbplghUSjuY0JpQ9fmfS5tco5n3zzz//GeUccJ1rmlhlTT7RZp4ZQylVnIIcsaJkYokk2kt8b/mQh/QRoDzuVK1BgpYuZfaaOxigXGWPI2oxnBVSp5BIRgoSb1yDus7pjFx+vhJZDVayWaj5MbjhTwGiBHTO/CKHBJYy3C7aTKV1HSmoltWl7hXpdDe/gKVwDDuT5Q5obV8r5xfTDF/EPW3//G3jDHxP/t3/tH3fSkv9VIv9QdY37kRPR0Cm7VtDafmdBZI/XrrGZaeOVQen2ZqztzfeobBEyM8PU8cjzOqFobBcnvXs1wKYiVMmWlM1ALeW3xvUFpzHjPPzxPPzycolfW6Y7XuSany/DyitWK16olRmJrOG8mE9wbXO8IUZRKmZeWojSYVSFHMSAqFdQ5tCsfDxDBY1uuhpTYZqnKkqig5YbRGO08qcHh6xmJ48+4HbO8FAWP7/pp+VJVBL9f45Voc8HBdA1LKZ3D4Jf9bwJjM5zPj0yPjp4/UmDHeC3g8lzahrJTYoPmXuMKuY7i5ZXH3CjssaV0QV5BmhesErE3BcsqMHx+Zd0/k+YxS9ZqQk0Mgl0KYAzEmaVeswVmDWy5Y3t7RbzYY20FVgmYytvlIqugPhfAvRp4YmPfPpNMRcpL0oTYNNp0YTkqD1FMKaRyJ5zO2W0gqldFQE8q0mEugpiCZ65f7SqGGTJrOpGmSvsK0VXBD8tQKqgiA/5Kag9ZUbUhzJI8nCTPQSvLqtTRBlUojKEHTDJaKHDKGAasgT2da1HmjAigUhpoak/WSQNoMZbYfmuu+SLPpTEvjQpoqKsp6aZNzJKfQuLJyC0opYrwpcr8FkN8OESDvpwKte0zXtWbrn26ilLpMJ+VZUcYyn4/svvo5JQbsIAlJtULNggrTYpEXk9UcsM4QQ6TUgvMWrZTcd2Ok6SxJNKA5i344FzngOYtdipveLnp5L0ttBAADiPkOrcnTJK557wkhcHz/Ht24ubUEMZul1A50gmgqVcIbcoyUlBluN/SbtUzTkeswxpBixHSdOOydE5RTkwbM+xPT006m466RFIripf7F1b/3D37OcYr8b/7vv8GLD+mlXuqPX33nRvThrsMNnmkqxBDpHKzWHuss+13kdI4oVbm5cQyDZ5wyu11gGgOGzHLdc3M7MCwcORXmORGCRCJ2g8Z3EpV4PEaePp04nwNaVba3A8t1x/mUGM8zw2UKmgrWirO75EznDc47zqdZMu8XHqUkejNdXPhUjBWI/TRGVEn0XUvyaU1bUbKmKzEK/1Nrdk97cq5stjfc3T+wXK9Fk2ccylpyzNSuw2/v6LY3qJIo4wllWxNVc2M+tptZxLFeMoxPz5w/fSDPEm2pjUJVLYYgpUVPl4VZqo1GWYMblgy39/TbrYDV09wmcm3N2pJtLp2UUpowB44f3jM/PbVYyoasSZVYJH4yxEgMEaUVzjl83+FXKxZ39/SrVZt8asmHb/nsNDZpRcvq1jjiPDF9+kCZz43IVChVEquMs60vL5e5ZJN51pYs5CWRSWmU8fK+NIbo1Vik5C/VkonjmRxmaXI1sgoHWQ/XgipK4kjbVFkZQ9WWcD5Tg6C8pAmVhCrVVrc0EL2MN1vUq4J+tcI6f4XiXyaMympBdeXcVuuXZlY0y6ZFncok2VwB7gJ0r+L0V9KM5TBLopISnellRa3QzeHtpCkLQQ4QIWJ6MfvprpeGt0ksULqdS9o9aJQEsugux/OR/dc/p4SA6zvhjwZpJHEG6x1aK1LK1FzxQ0+YZ1DgvMcYhTEW08l7lmMkxwltLFrJ9aq2Jre9xw0LjO9EPzuPYg6qVe79RWMcAtpa9DAQx4nT+48YwA4DZQ4yOc0tvlUbUEVkK0qm2Hme6G9v6IZBJslai0aWKpG2bWqbpxlQ2OUAyIHw/HxEFVBeSwPeZA4v9S+m/u3/+Hf5S3/zNznNL1Pnl3qpP6713YH2vRd2aC30nWK17qlK8fHjSJgii4Vls+3x3rLbzXx6nihJGKHr7cDN7YD3lpgK4ylSiuSY972mGywoy/PTyNPHI/Mc6QfH7d0CrTW7/UzNlc3tkhiyGBC8FVi1kgZEKYEcT3NitV6AMsSYSUmmXLXK6r9UxXF3YjFo3GIgpySJMMggrcaMswbvLSknnr99puuWvP3yB9zc3WKbC9h4WTPnnDGrNcP9a6wzEGdpGrzoQmtJXJiT0jwlQBPGmdP796TxTCmieSwt1lMb0aRd9HfGCU6mKkW/vWF5e49fbgRGHoNgZxQNGN+a0GaKqkozjxOHb78mHPYY1Qwh2JZQI9OqEBIpRpx3uF60qcu7OxZ3r1rajwJtxbQDrSlsmCEQBqV1xPHM+PEb6ngW0whcxoLSZCTRPGIsqkqyT0wZt1jSr7fy2i958hcpw6UJLU07WSs5RuLpSEqSHy5T5trShZrO8Nooi85P+45cisSJhlmmdXCF4VMqVWUueIJatGCxsqzRrdZigGryBzEI0bbb+rJZb9nmoGrG9T1mWAgntX6e/NGiK2uKv4AQUpQ4E8eTNKzOYpwA65W2wjFVBqUMZRrFKR4jJc4YZzGLjTSElxCC1ulfEpdqSVfMlbKO6bhn/+1X5BQl+Utr4jQxn8UUZnqHMpo4R0opaOeZzzM1Bay1KMAYK+lKzpFCbOY5MT5prdFGUarCrxb49QrVJsfkRI2pReTKDJosNA3VEpbSnDh9+xFCEIlLlvem3eZrNCjQpqeO8XBkuF3TbVbShEa5v1XLJiTPEpdbY/mc0jRbioJpf8KAxIKqdpCrmZxfxnS/3/XXf/Vr/s6vv+dXf/r00oS+1Ev9Ma/v3Ig+7QJW1xbNKezOp2dJ+rm56VitPNpoPn0aef9xRKvCcnCs1x3bmx6tFfOUmOdCSqBNZbmwOCd6tt3zzO7pRIyR9abn5m5BTpXDfsJYzWLZcxoTpWQWC08KGWM0uQryySwc85RYb5YYq5nGmZQyrvEWu86QChz3R9arTlzzKeG8I6XUpI0KZzTWOc7HE+Nx4vb+La/evmZ1eydxjEpjesG55FSxd3cM96+wWlPnM/USU1mLaBgvfMvW7JSqmHbPnL75BtrErMamSUzygVdLJSdxzBvb9InO0t3csf3ix818U2VVXdqUsDV6qhpKDFeW5+nxmdOHb8QoZISFqaqYYnKSdf80TlAq/TCI+913LO9vWd7cSxNcq+hLtWlaxGYjrsiUUWswnumwIz1/pMxz0zS29XGLraw5k2Jq6T+Zi3+932zoVhuJXK2iWbzeQ9Waai56V0nyCccGpL/koremqyYJSdBat+Zfmj9t5OCSY0TljGlpTG2pLZGbqrZJKFdzdYoR4zusMdep25Up2lbYivq5SWqNkdYV1y8w3aIZnhq5gDa1CwLF1xdneZEEqDSdqaWiXWtM0wXlpCDJ31PGoKzF3tyhxjN1OuMXa5Tvmhy4MVsv1Vbw6hIFiuZ82HH4+qdQq+DGtCbFSJwjNResM1hnBdFUCn4YGPcH8hzpen81IKGVGLNioqbYkqRyg847qtLY3uNvtm3lr0jzJISDdnCSH6Zy3Rpo35NS5vThI8QkCU66UmN7Boocui7EiItmOMVIf7um325kxa9kAnqZ4jPPUMT0l2OEvpdfgL5nfn4W0x6ixa1VZCO1IslPL/X7Uv/oZ0/8W/+3X+fjYebxOH/fl/NSL/VSfwjqOzei3sByaVltBo6nyKfHGe81d7cd/SCJP199tefjbma9MCz6ju3NwHIpOr1pysxB0lmshb7XDIOnYvj48czu6Qi1cHO7ZLPtOY+Z02FkuelJWTFOEUNhsx3Y70YAlr1lPgaZuqSC68SwlKYAuWCUYp4D6+2ClCun/ZHtZiCJrwRrmwtdOawTvmTJiecPj+Ss+OLHf4Lbmztc310NG3hHUfJ3+jf3dJut3KCWHa9KFu3bdVrYpj9AVZrDt98w75/kQ7Io8jhJ9GaRudBF1+l6f5222cXA4s2XdKs28aJS5kkmSlymgHx2RPdreR0//znjh2/RSlb7qlbRy4ZEzUhzlgvWW0wVXI92ns3DK4btjZh0qkSJYiTtiPx57Yx21wZv/PiectrLOv7i0G+mGdTnydVlpU6NVO9Z3L7G+kHamlJawpHcz6oq6NoaCQ9VsuXD/pkyC0RdXRzTFdJ4Js0zxnnBLl1A9lqTi3AtrXVgB5mM1YKptU0lTdOHtolbyaQ00683zQTjW2xmEtD/JcdeXUNTqakhn4yRFXS3AJSs2F0vrz2cKWFGWYd2g6yLSyZPI+FwlIOAMZ/TuEIQ0Hst5Cli+k5e3wUYrzRmtZXc9UunrtuPtRHIe80tNlUr4dM+PfH89e+KUc15dOepNRPP8py6waOVIk4RbS2+74hhRlHwQ5NNUFH18zNUY8D0nTTkWmGsQOWVNrjlSlbpMYoN/YK/agcPXdt7rxXa9ZRSOT89y2S095QQyOcZZZoMQtvGxG/GKCXyD7des7jbks9H8HIQU6VSG3+p5CSAe63QTsm9do7z0x5VCq73IrMpQj6oGmpVWP/dPZ0v9c+up+PM/+Av/gfMqbA7h+/7cl7qpV7qD1F959+wm61nseo5nwMfP8mUcrO2DAvHdI58/e2J3SGyXTqcU9zeDSxX8ot9nguhGXSHweCc6MtSrnz8eGT3fIRaWa971puecSrsdyObTc94zmhd6b0YpY6nRAiZ9aYnF7BO1o5FWXLI9L2T9a+G3X5mtV2gUKRpZLletJx5MTKleuEiKqx3hHli/+GJxfKGNz/6FZarQeDn1kkPVit1nLE3tyxevRWm4y+YhFSplOnUPqgvLhaZHKUQ2H/zDeGwBwohRHRRONdYolqadOVsc7ELG9MtVmy++AFusRaXeS3NOa6ajlIc/hjRHOq+J80zn377NwnPj2LK0tLcKq3bRFP+bqlicOkWHdP+RDWa2zcPDOtN0+0VaSQvrvvaJmCXvW8t5JSYnz9RprNESVYt8aSqYi/NUWNQAtQSqSXhNmv6uwe0NtRZPpjUMLTbJXxMmrHmkrxU5pF599QYp/JaqkEA9tNEmiOu69s0US7ROEeKiTTNIjmwEm4AFXUBrSsD2knzG8VkkxX0yyV1POMWC6iKlOK1qRNmqnwbWe9XFAWlwS8XGN9fNYy6G6QJjbNMDa1HdX0zVWVKisyHvcRSGovtZbIZzye0k3/G2qb9vEzNM3Ua0UqmvTWlK4WAkmUCmEszkSGNqPNM45n9+68wCrSz2IWY7cJuRFcwnRjlcpTXqo0lTrPIV43GXkxmRZpQ6xylJDH2NOeWNs1hXxJGK1RLcIIKIX3Wa2YtGmJka2CHJVU7Tu8/UULCagPIdBJjKI1iYLSQJJS11Crc25wLNzdr4vGM6ztqrtfnhyKTVpXr9WdSO4vuevYfPlFPI245SEhARcD7Uf7ZumZaeqnfc9U2qf5X/sJfp1SY4stk+aVe6qX+f+s7N6LD0nPYT3x4nKHCzdqyXDimMfHth5E5wd3aYazh1asF/cISpkQMSPqJLnS9xXtpAkOsfPvtgfk8Q1Ws1z2btSfGQo6ZV/cLxlk0XNY7nNfk1uQs15JCc1mrFuTDTiO8xOkcOJ4Drx5W2K5jngLL7ZrTGCTzGwhV45zD1YTte07HM4dPex6+/DGvXr/GGo+xBmOtNFNaCWLq9p7V2y8x2n7G36RIDZ9P+YoKvkMVQcWMhzOPv/1bpNMRpRUpCwcUgyQXAdqqtvIV8xXWsnj9luWrtxgjEP5aC7WZmqA5xBtbE6XRnWN8fuT5J79NCYFuEBOGQOBlwhan0AweoEylxkoYZ/rNiu3bd/jlqgUrGUm3QaFqvq6cL1ikqo3wNxuaSXLVZR2r/ecJbc2i66zNaFRKxm02LG4fqCVTZkkuUtYJyN6YlvttxLzTmok8nZmePlJCRiuFdpraEoLieZTGxcu0uIYJMyzRThNDIJeM64dGNxCTkTj3DbU6MeXnDHMgKU1WleH+Dh0DxTuqtdckozbaFs6pMdcPWyVqWNzqBrNYStypNmLsKi1haxYDm3ZO3OJaU+JMODxjesGZaWNAVUpIKNuJDUxrtAZqagccTRlntLZo76VBKxXTyVq8Gi9NcAqXATu4jvl0ZP+zn8j6uWq0MuSUIMwwS7iDvuTDW4tfWMb9gWG7YfvlD3n65mt2X33D4CQy13adJEwZc03kKtpguvZrZQrYYRDWrGkRp6VNqY1q1ITc1vEeZTynpx1pPOOHAa0V8XRCWduYtbo1lQpltTBKa2EeT2ze3EOKGCfPjeCwsmhrtWC5Um484QpGe8bjkTSecdZIjGwSeUAaxfynjFz3xdz0Ut+tUhaE2b/6v/5bPJ3ma67FS73US73UP6u+cyP6/CgGJK0V97ee5dJyPic+fRqZQmHoNH1vuLtbYLRiOkemWTR3xkA3eLyXle15zDx+lDWq84712tP1lmmWCEnfGVxnCKFgtOj3UlGMx7npyriaZWRQp1BaPkROxxlt4O2XW0ARppnFcknJBeedmKeNxmuFUZWCYffpmXAO/PBP/TluX7/6nFWdc+NralS3YPXqnv7mFpmyBGkHY6SmuRmTaNekYB7JpXB8fGL/zTeUaRLPjtKSUd/YnbnmFiDjGzIno/qe5et3kkvfmh1ygBCuOkOJuFdwiblEcfj2G55++zdw2sn61hpyCDJ1rM1RrpWslrWixEhOheX9DdvXbzCupzlQRGPa8t+r+ny/pYF1xBiZnz5Biqgqf4csAHEuyUcxU5W8fyhhunZ39wzrG2nMYkT7DuWcrLSVkeYNpBE1IieI5z3jp49QkAmgbRPglImnsyT5DAuZ0MaAWwwob4gxUrKkYqnS0D8g8Z7Nri9SANEuFiArGF69wigoCuzQf3bUVzGdlVqvDUpt90UphetXmMVKEnyUQvXL5gIfqWFCdcM17hKjKOOZ8fkRt9o0g1rT7kbRNtaqGp3BkM8n8jxjV4tm0DMCuG9Aeoyh5igkB20oYZT3TIueNE4jp2+/kqz4WtFDj7aGPAXBSTUIfJxnjLdoY4inkX61ZPuDH6KN5+7dl6RUSPsDQ3/BQ8nKv3DJTWgEihyx/SCNcorUECkxtmCAizFLeKTKaLQ2hOOBdDpKOlnJIrH5BRJESRJeUFK+opXm8cywWeF7ef+1Mdc1v9LyvbVR5HkWx30vscFhf2AeR3zXQcxybdqQJ0E/2c5heotp1/9S363GkPg3/+rf5x/87tP3fSkv9VIv9UekvnMj+vFppHOam61nsfSMY+Z5J3niy97Q9Ya7+wVKwekkTtOSC9pAN3RYK5zGOVbef3uilErf9ywWhsXCcThmxilhrWbdORQWpRPL9YKY5L9pJN5RK0WphZwr85wwRhODHLtXK083OEIo5JwZhp6cEillYhH4trMWcmScE+f9ic4v+ZN//s+yWK8EOdPYmjS3tF5uGB4e8IslJScubM46neXD39q2um6aUBQpRHZffcXu22/Fz6ElIUkQTHJPY8jUmtFVC87IW4btDcs3X+IXCwBqSdR5uq7DFWK8qLWZoBTkkDh88zXnTx9wtmv54wbZv2qmcaTmgnNWNvpGkaaEspb12wc2r1/Lerdk0FbWwSCpT40LSZHmq2CI40R4/iDRoU0vKLGI7WEpRdih2qC0XKs2GrdY4hrgv6aE6XrwXtbKF/QB6jOPMgXCYc903DUSQEV3BoylpCzRrYq2spYm3nWSrV6UrFhdS68qKZCT8DsrzZGvZRJ2XWFrzeL+HgWk8wnt7T/FNaxIM425YJYkEUgrcN1Smrkwo5RB+x6KEBlqnMF70XrmTAXiYU84HaQJtS2RKwcxkJWCdkaaoHkmnWbyNMuUVGv8ci0mp5yujaBEdF70uHK4qdahjCXNE6eP70XfWpU0cqSWVd9kDyFRmlGs5kqYRrrlwOaHP0Ybf50GP3zxBXv3DfP+gNe+NY0y2SxGo7TEj9puQHlHSUXg8q2Zv3Bn0zjLM+UNph/IKOIcsF1HCZE8z3LAuazYFZI3bxU5ZyqFqhSL2w3DZkOJCWWNRLT2rvnbMtoaMYeNc5ugyteb54hzTr4+oK0jjjMppKtGVytNGQMpvGga/7PqNEU+HWf+d3/rN1+a0Jd6qZf6PdV3X813is3Gs1h4TufM8SSpSt4pVpuO5dJTSmU8F0K4AMUVw+CQ4WIhpcr5nChFkXLBGOgHK1OOktAKvJNow3EMLTKyrUPRDcFSKE33VnIVlmhVWKtYLhy2sxwPM04rhuXAeJ5RStbqWktSUimV3dOBcJx59eYdb374Q/qWDoMS53VFUa3F371icXuPUpWSAhe0T46zTAO1MBlLcybXUgmnkf3XP+f89IQuuTFA5cNUdJeaFGXdrbUkSdne09+9Yvn6HbYfZKVdsuBnjKHWXzCgKMBIFGU4Hjh88zXxdMIYJ1ihTmNbLGhsU13nnXwo10qphX67ZfPFF/jlEqIgd5T1V5d6vSQkNQg/xlKUIpwOhKePMtnSFhqbUTfjR54CJcwiJWjZ5rbz+NUa4zw1Cnhe9wtp6NrE+eqK10og7/NMPB0p04TVjpxDwyKJYajE1HLbrfz7BonHGjJV1tbAFc5eRGtqGnhdusEkppRaKRqGzVZMOueTTI5TQx2B3BcrznOFmGMkQEq4rkpbmWb7DqUuMaqJGmbQEllZ4ySorOOeNI3YYfHZgV+ksZbGUm5FPO5RVaIyaxW3t18uJaGq5dGj5GuLdKOxQgso16G1Ic0jp0/viYeDTG+VNNSlweYvh4dyhSKJVGNxu2X9xZeY1jxfJAlUWN3ek4sinEeR8mot0oWUMRa065u8Qg50FwnNBUWQJtlsmF6MQxnNeDjIIU2rz657pUkpS1gESpi5CIM2l0q/WdJvt4LT0hpVQDst16mVTEOdp5zGz0Y4Z5j2Z5EVaHV91SWJzMb1Qv8wnaemTJhm5vP4e//N+sekppD5ta+e+Xs/+cT/+f/1O9/35bzUS73UH8H67kD7hwVKW573kWmMULMYlrYdfe+IsTLPmTAlcik4p1ksnKQexcL5FMm5ElMlxiwQ+m7AWMv5LNnofS/axfN5kg+gCr7rKAi4XlNJIV6jN5VW5FixFhZLR9WGw27EWI2ylnkKguWhMR8V8sEyBlTWvPvhr/DwxVuc91fWqCqKqhV2ucZtt/TL1VX/V2uWTPCcW3NimnYwo60jhczp40f23/yMeJ4AmWFK+g1UVdFaHP4lF4y2GKvx6wWL1+8Y7h6kyWhfs6YkzS3yWoHWiIpGcfz0kfPHb6UB0qr1p7at3yFMgZIL/WYFFJngKcPi7o71wxtsv5CG11mwlyno/BkUfvGDa0uuMD09Uk57jGkxi1lWyWhLrYo4nqFxSS9rWOM9frEQ/mZsDUXfo5Sl7dolwvRiuFICdA/7HSUljJa89V/UwlKzNITuc2MCYKwhlIQqCq+kMSQLJki7Tho+paRBbk6jFCNmGBjWK4zW5Fn4p9eUKCVaRlAte16mp2TJXv+clpRbWlInmeYpiqkMJY1pnKm1iKlqmrD90OQcVSanKYpxqhEQ8jhJE78QVJhJEhurjWtfl5YXbz+TCNDyfDScV4wTp8aPLSk325wYdZQqGCvT0DhOYnBqh77l3Q3rt18I1qnkz814EQmD8R23X3zJeNgTDwcxI5VMLRm/WLXXpskNgyRv0mfMmGoNvXbyXI3Pz/Iz5f01olZZg1IaXSxlKg1jlcVpj8YuBxa3N/Ke6oIq8vNZasEoS55nSdbKYgYzzqCNYzqc0TTZzfVnscljnOiTtbVoa0gpN3TTi8jx/7tKqfz1X/2aT8eZv/g3/sn3fTkv9VIv9Ue4vnMjmrNi/zwT5igu9sHKGrxzjKNEdaZcUFQ6bxiWFt8ZSoF5KqRcBWY/RlJO3G4HvHecT5GU5EOxVonhLFVRqsYY3f5Z3MUxJZlqms8TGKthGBylKGJIWG/RxhJCar1Lg5DXwvkwUhLc3N1zc3vHYrNqq2KJb6SZS9xyQb+9xTqHjJfk2oix6e5aDGRqukmtOe0O7L59z/T0iFbNAd/wMrlkUOUKIwdJhbKdxy3XDPevGO5FD1piuDa6F2xPJVMx14SXPM8c33/LvHu8au5Um3BpI43vfJ5IIeCGHm0UcU7CB331msWNoJmuKT/GNX1qbFOzyxRQgzXE8Ux4fqRMZ/lwlxd1/bOUQk1NilHrNTfdLRf41UoapgpYKxO2a+yowNqpiDZUQQ4T8XCghHBNlhIHdJv6pdLujQGaYSVn7LDAr5Y4rTgfdoTTCatUa+ZFe6qcoYREDQI1zyVhFguG2ztUzYLEyvWquf2nk1IF2VRKFmOcVtiulxU5oLtedLUlA1mwS/rShAZKjpI6VBLauzYlFY5mSfJcXeDuJUa0HwRdlGYo0K1vxdDVnj+lL3ra+jkGVCkxMxlDPJ84ffiaeDiiUWD1daKpmkxEmkWZkgoXtTBsNixfPWCd/xwdCjRhtkz2jehWFzc3zFoxPn6ipoTre+xyLa/rOkVtUCmtmx5U3O9KaVKF826HLhWtjTTf7V6D6KdrqXK/VJIYTqVwy57lm1eSIZ8SxRQoqSVWSVxnDu0Q0Dinynvmw4kSM6qInKWFZskBrqWo1Rb1WXImZfld51bD7+236i95/dW/+xPmlPnf/+3f+r4v5aVe6qV+Ceo7N6KPz2Ic8F6zWFrWK4naPJ8y0yjNpDaKrrcslx7n22SGirGKMlVOp0Cl8up+iXeG02kWFytKuIIKVFupasN1dWZRJCq2E2duToUUE94pFsselCLMot00zou+szUS2hpSmDgfJ4Zhw/0P3rG9v8VeP3gavFoplOvob27wvRg5QBy+NUZpropM11SpzQGcycD+0zOPP/kpJU70fYfWnqRyA4gLBkn62YqyDW/jHItXbxhaVrxqU0RKQuIclbg/SsPPNATTfDgwPn5g3u3k6xtB4Fjr0EYmYvPpTDifsZ1HN7d8t96wvH+NX63aLFCg58o4SpzbtKs1OZemT2vmw558eCafz5hL3GSW5lv3XXNnZ2GUKiWsRmtxq61EWzp31VQqpYW/2dz+NUVEEypT3jyfSedT05eKgzwF+TPaus8JSK0hrzlTc8R6T7det3x1ifE8vP+aOSa876WxNtJk5FmkGoWKXa0ZbrboKqD4kgslt8ZOyWRSYjrlWZBpnRI5he9lVayUNKBKSyNfQZXUpn6aGmdKnEkxUrXGOH99juplSghNMiFJYboTk08tGWLB+l4m47lNci/EiPb3W9/cuLOVcDqw/9nvQpH7SClopamqCs7LW2oqpHmWrHVnqTHSrdYs7h8wvpfnuzWP5Nyac5n6Xt4/bSzOeWatcdsb/NDSxBopgSzaYjGr6c+0Bg3FeI6fPqJTwXhLDqE1naI5zVGmm7o1kihQ3qK8Z7i9xfc9JScK4tDWjRtac5WGlktiE2jXMZ3OpPMkuKichSJxnZYbwTm1JLKSM3GcqCXRLXuMcf88v1t/6eqv/J3f5tvnkX//H35FfgmFf6mXeqnfp/rOjaim4Lxie9PTdZZSFKdjJIRMDJlcK11Lg4mh0DwQ5ALznBjHgO8M682CFCLznHC2TRaR9blSmlxkIqWtQ1HQtcjE1BlSM0zMc2DZa4ZlT0wVrcE6Jw1lLsSYZOKjBGJfYmF794aHd29ZrFeSFgSfJ23O4jdb/GqNcy2pB9GYkZpz3iha3qMAvKmkGNl//MTx6RFdo4DvtabQGsfLJ6F0DRgjH3h+vaK/fSWaRG0aHomrM/2SCCQ8TWFLUgrT6cTh5z8VFqUx0qyK+0OiIGtlPp6Yjkd875su1OFXG4a7++s9UsaL7V5raQYvzFBlGu9TojnD/pG4e5Zmwl5g70oMY862CWOkVDFd1SrrVb+5wXedvA7r+ByXCKhLY95en3UopZj3j9QwSeMPaGtl5W4uU+R2MCkZssgcoOKHBW65vMYyVi362NXtKz599RU5TSzWqzZBj3J4UIr+5ga3XDZ39kTNRdzxRXS7yoiB7NooZoVu+lDTCWoJbaSZ1yKVuDSKykuzWdsUNM0TytjmjK/tHl+0naLOTNMkzb0xcqCoSfxfvpN73ThM10Sj8rkBldGtTP/m04HdT3+HEmasdZSa2yFG7qly9tqQ6/Y8UMEv1/KM+E5kBZXroetyr1GyLkeL5rbMMyUn+ts7uR8poxqhASRDvp0ZLtJqga11HacPn1C5Ibfaa9BNVlCSYNtKVU3KkqURt4pus8Z5T57H9u91+xqVEiKXzHpVQck5khgC6XSmIVhbQpaSBC4niVmiaVXU3L5/CGhvhcYQy3f9NflLWX/tP/kZf/c33vOPv9pxfonjfKmXeqnf5/ruyUpWsb3t6Ree+Vw4nwPTlJjnKEgkK1PJlApuXaFY5gC7feB4mOgXjq7zjKcJ7y3ayoeqrBvFzZqzTDJN+2BPtSAyNkWMkthSYmC79ljvSZfJUpX/5SRr0WGxYJ5nzs9HSta8+cEPuX/zmn7oMMbI+hVEi+cci4fX9KutwMKb4aPOEyUFWadfJ3ipZb7DdDxz+PCR+XhEkzG+o1RZT18ZmqVceg6MMShr6O7u2bz9AmMdEg2ZWv74RedXJJ1Ja1AiM8gVDt/8nHjeo8jozjVtofwd6x21ZtIUyTHh+wHrLVUZ/GrN8v5BPuRLbaakZjJK6dohaNsiPIEUIuG0p4wnVEsdEpaqFoqA/ZxoQzM/lZIw3tOt1tjm1qaZcKR5USjrZbKcZrn57fs9/fR32f3sd1jebFjevRKWZeM66q6TRjkHSlGiQdXSlLp+hWuGH6AhpEQu4PqB9eu3PP70d7FO43vJmcdZhmUzTs2zRH7CFS4vjaBM4LRq+lQAMlpVbL+W6acS6URVSOOWAso4sJ5y0XxWRZxGaeiM6IlVKRQqxmlUM4/lcUIbe2V41hxRRWNcJ/exPUu0FfwvTkNp91lrQzifefqd30aVgvVO3PEXyD1ikqu5kM4TfjlQ2lrf9r1MQq1rsZa1nSIz1ajr868u2mAUZZ5I4wmsJFLVnOS5zE1PXWprvKFIGoQ8C51n/817as50S0meEq6nbnpOce8ra9CpUKI0PtUb+u0W57xgyGhfvx04a4trVc5dNzHKWMI8cX7aoXNtibFyyCpZ7qVtWlRioujWhEbBb7muE3KG9d/5F+ovW/37/++v+Et/85+wH18QVi/1Ui/1L6a+cyP66kE+8M+nxHhKjFNimmNDNGlqrHS9Ybtx9L1lniu73czhOLFad3hniCExDF6Sd4xtjUxprmYhEaaU0W3UUxVMseC9JWZFOJ55/XpFwhCisAJLBW8Frq4teD9wPJw4Pj6z2jzw9kc/YrVe4jqPGXpUkdjEgsEuVywe3shKsSIpRbGIVjDFa6NEReI0NWANx4+feP7qa1IMlFqwxjWHekIbK81CFfC2NqJp1X3P4s0bVq/fYrSBLDpFrBOHfm5w/IYVUk4A3ykXPv7ar5JPe5wXLadSgoHKcUZrhSpFVtja0K+WhPNIUYb1q3uGm9sG5rYy0Wrsy5rm1sy01WfTHIZxIuyfBDkUE7RVsnArvcR+Kpna1gauVtbgrJcpaGmaQOfaBLKAlftYi6CSANCOUiuf/slvcHr/DVprTk9PuMWSbrFs61PbJmSRdB6lqWpRnG65bO9b03O2JgqQhts5lssF8faG4+5ZyAVOGmVFpc6jNDmtcSk5SbP+C3nwpeknqRGtLW65BWXEjW2dNMApkMMkPFTft8OBmHrC8UA1TaOcc2ughCKgvCCCyilIHKa10ihpjaZI9KZrDVDJVPRnz0z9BQNNrcJanY4cP33ANOd5BYx3cFUziGsvThPGO4m5TQnXO5a3tzjfibQAOfi17lCaUC1GMqUlTarmQJpO8h4BhYjtujalbYcrDTjd/GiKSqL2PfuPj5Qp0g2XsISrdPX6s6atTICLuvBdC8NmRdc3yYC6aIrbtWkhBehukO2Cs5AzScH5cY9qmfG1KlLKDY9lsUY3qUkWbmvKpPNISRG/XrWIW5pI9o9X/frXO/7Nv/r3mWJmDC+JSC/1Ui/1L66+cyNqrADnT6fE+Rw4HmdyznTe4YzG94bt2uIHz+lU2D2dmefE7b1oElOudINH1Yrve1IUM0cIgmKxLaJSGtJCRZOLous7joczGnj3bss0F1KKdL1vTZjEZ2oNGMvh6ZnnD3u++JN/lnc/+iHu4r7VFrKs0ysKf3PH8kH4mfKpbSFOgtupRaZbJUFu2j1nKdby9NPf4fDthxYHWDBGnLm5sTKhra+Vap/fovlb/+AHLO9fo3UzBV0+enOk5iDfn4ZEMvIhO51OPP3kN8jnI7VIxKi2AvsuWQweUIkxiTm8FNJ4QjnP7Y9+jPeurcc7WfEL1V4c3G3Sp6xvhiVLOB2Jh2dqmikxoY1DNTOW9q5NviKSH69kegf49QbnPYRZPreHBVcAp7k088KXFNORoaTEN7/2jwjPT/iuF9RQijx/8zXbVw/4xRqQRKWccgPcO6CKhGJYyPtTEQRRCqIFVUDXUeaRmiI3b95iOsd02LNe30ju/HymTKOYwVKiVGFSVmVEGtAkHqCoMUiy13pL1QbCJHnlSkOcBMquHSgrUaZtFz0/P6Ksw/peDGiloFCy1m8w9nQ8yXPSEqGoTb5hB3mfa72C1smtyW54LaAdHhQpzBwfP8k15XzFU5UsWfSUSi6FeTril/0Vi+a8Z3X3CucHrrGtl1W/uJ/knjYTljwzlbQ/EE9nVKnkkulevRKpS0wiMVCI5hKFcsJqVcoyns6olORAVargsy67+0aKuGihKbIhUUbjt2sWt3eUMLWfzZ5KQavaXksCZVFU8uksMgHvOP78PeU8Y6wR09tFYeMMprdoLuzVKteeohj8eo+1Tu6Bc39skoFKrZznxH/nf/E3KLWS8h+TF/5SL/VS32t950Y0FcXxMHM+zZzPkZwyXWfpe8NyaVlvPLkY9rvM/umIcZq3X2yZJ2mSrFHyYaYNYZqpKGJMnM6RbugppZKiON1T1WilGHrPcXdk0RluX20Yp2YGcR0pinvZWQ3WkmJk9+23pKD5U3/+X+LVD79Atw80WaVqyhzJWrP68of02ztxfrd0GOaTaBRBPhxLFY4kgNLEovnmH/5DxqdHrBFzitYGRW2pTjJxqQC64oygf8x2w+2PfoVutW160wa9Nx7GA1DBNgNLM/WgDIcPHzh+/buNlylKWt2mgYJhaqk+tL6hFFJITNOMX0CcTvjF22beaevdGChxurJJlXMyiVPifE6H5xYlXwHRSOpmUKJFMQqKSmJYS864vsM1jFLNBbVYygS0FJTppIFq9ACsmJWm44EPv/5rpNMZOwxXGoAxjvE4cdrtJZKzmZ+UFvSOMlq+3zDI19VizqqlSLpWWx2X8UiNAdMvgUrvO8xqjapFzFAlY5YrcsxXTJM8JwVl1WfzWsm4rsMt1zI5nUaRGKA+N0WubzxVSZ0qFOb9kzRiViZzxjrhhDY+a54zeR4l4GDoWv8nekjt2zq+tBVxrZRUmyb1c3Rqs7+TUuD4+AGUIpxO1Fyw1mK0bBfkfdbk8xnrTDPrFNzgWb16wC1WIneQiLLP77FgH8R8dGlSSyaPJ8JhT5ojWiu6uxu0UqRpElIAktok4Hh530spjPsT4XSWA4sSjbUEKLRn/oIMU0ARM2LOkWGzYn1/TwkNK6aaGUpVqrKokgXxRSXu9sTxTLfdcnrckw7SlKac5RDgJbJXaSNT1AoVmermOFFixnQdfrWW12yMaHX55Y74nKOwXv+Vv/DXSS8mpJd6qZf6A67vnqz07YFT04WWXBgGz9AblkvHsOwo1XDYz+x2BzbbgWHo2e9nut5hVG1aQo0BrPfknMkxstkOTHMmJkQbWivOaaw2nA5nVivPYr0ihNQA3JIApI2mYskU8jyx+7BjuX3gyx//iMVqKYkvuYJV1885NSzYvHlHd3MrTngt11XnEUJAnLaladqkCVVGruPjb/0WYTxirBP+Iro5iS9YpdrW8VqaUGPotjfc/sk/iesHaowydbqwI6NMQZWS9Ty6TcBy4fjtN4wfvkYXKG1C5/oeUC0dBtIsLEljjUDDKyjfcXt3Sy2V8dMn/O0Dfb+Q1WMIgrhRGtX1ovs0Eld5/vSBfD7STNdcJmO28yirZTraIkNrzi0aNOKGAdsNMjWrUK2TdXLKwtPMoZlhUnN6a05Pj7z/tX+MLoVuuZSGp16+b2WxWHLeH1Fas7y5wVhhlCqt6NZLbL9A1sbmOjkDJdpA25FPe4gR7Xvhdp5PhN0TpRSKDbjlEuU8OUzUKtM3QR4pWZcrUEVMNbbrZVqpDTUkmcAaQ02TrOXt0JonMQuVlJj2T/KeGktGtSY0cfUYxZYG5Xuq1uQksavGWIH8q4t0ov2dy+trpi458BRpqkPg+OE9eZ6oyor2uShSzFhb5WdASWJRrQXtNDknjHUsbu5xw6ZNWmuTaSDfH2lGJWO9maJKpcwT8+6ZNM645QK3Wcv9KPLcm76T6NNSrk1zTZXxNHP8+Ii3lqos2soaHKWpcwAtDvyqRKJTUiaHgFv1LF+/pcQsJIwKOSVM5xq2TLUwgEo8n5j3e6y3nPZHxk87ul5iamvNbeV/aWIVJNrEuU3EU8A4j1+vUaq95vYe1PzLadA5jJGQMv/6X/6P+Ob5Bdr/Ui/1Ut9PfedG9HCaCEEytRfLjmEwrFYeP3TMMxx2R+Y5cHu/xlrD6TTRDR01ZZTV1CofcFMs9L0465VzTCHLJEhlTK0YKwiVFDLLladf9LIi0pqYKsLgtBijSSEw7Y+EKfHuV/4sDz/4gq7v5UM1NoSONmTArdYsXr2RBiB9zk+vcaaGlpBUqqwHa6UaSw6R/fuv2X/znlIyvuvbClcmlJ8xSEamYwWcd5ihZ3j1is3DO0zXSRPadHYSHZpQFFkLNsNFzYk0zxw/vGd6/IhGGlBVC67rqFRKkPWzyPckM760tav1Pf1iIat0o9GmY/zwDc53qBQbT1Nf05OUVqR5Zn5+Ik+jrO0BXPuQVwrtJfnI+E6kCaWIvjZn/NDjFyuUEiZmLbkBxBPKDWJ6yQ3+rxW1RA6fHnn8nd9BK4XvB/mQb0PnkhuqB3DOc/j4CeuckAWsY7i5lXv5i3D7tpZX2qKMopwPqFJQw1Jy6McTYb9DaYv1SlifRmQBnyWWQgTQLWsdLj6xDtMNwKVZLRQ0ujZdr/XtvZAmrqREODwLMsl15Fww1kKVBCRtDSqrZpKRBqqUAmEE69CrJXBJEmvCxGZGEmqAag25yFdimDg/PlKyyDRKnqCBCHKIGCPUgpJLa0ItcZpxvmN1/0C3vm2vn+tkXd4IyZ3nwott9yidj8SnJ0oFt1riVksB2QcxEYqpTAxfl+kqVTGPgfPjMwaNa9PvkuK1ga2lyCS9udapIlrx2xWr1w8NlSb4tByCHEZTRndNHlFE4hBPZ7T3xFI4ffxI13eCqVLIxLclsWltUaWI6z8Lm7jWglYKt1zKwS6Gz0isijT0v0S1Owc+Hib+4t/4J/zHv/Xp+76cl3qpl/pjXt/5N2wIGWsMXWcZBmGFKus4HjPnwxljFa9ebyRdaQ5YZ4lTEI5hKjKESBXrDGEOlCLxnJ0S3JGuCmsNBXHI973l/9Pem/XasmbpWc/XRTOb1e3+NJmGkiV+FPwF8zfg2pa4wMIILri1hIwsQLbKAqkkwMhGlKlyZVWefrerm11EfB0XY8Rcp4yQT7my8lSWY0ipPJln7zXnjIi54o13vE3Far5oFcbQVJEDxsR0jJz2J7xr+fL3fo/LVy8ls3I2rzjRPdK0dNsL2strYV1qUddxEcajVqlnnMPKnegEp8OR+++/4/jwILI56yiI8UJulgbnLKHxGgZeqZ3DtR0XX3zB6upGgUA8b1LRMHScwaBRPsZQ4si4P3C8/UQ+7MFIKw1VXNy1Flk/WivrZANQqerot9bS9K28T+fO+aP5cODw7nv6qxtJVdQ+91or0+MDp8c7zBwQr3/XzNFCwYP1mJrAiHEnHQ+QEk3fEkKnZhFBk/MxIGj+ZRaZBd6T08Tuw3v2b98RnMU6qXacw+pnvWxBQI9vWzpnOTzcs372gtX1jZy72YGvFGqtwjwa6yjDnlqkv76kiTQNVCq+78VY5KwAmhSV7XOUOXzfoLrQuY41CKPrnHadyyrX+HB2yku8lpzTmkeJgDJVgtEVvAhOFdOaqXLNWSfnLMUJqNgQCOtL0WHqdVZLUcBpFXTrBVQzVEtJE8e7e+lA1/xREJNRpUi9a6mkOIm+tlamMWFDYPPqNd31cwBqmlSTPbuFRAJgNBpszjnNcWC4v8NaS7vekClM+z3Oe2zTqPFQ8kqLBtlXDGmMnO4eMSnTblaS9VkyNYo+1DhxsNdc5IFVGVzfN6yeX8u1nxMlJ3ISM5lVY9f8ntNJzEW+a4jjyLA/0rYtBkOKiVJEdytr/R/rltN5k2Cdo7vcEvqeEkd5T2b2rVmR0fwNmfvDyH/3v/4p/8P/+e3P/VaWWWaZZYC/ABAN3tH3QVjQNpCy4fg4UFJktZZcSlkJWsaxUmKmCU7jIgVszOxLyQWvhooYM00w8jOTGG+8t0zFSLC9d+SchUVrxMBz2u0Zh8zl1XNef/45m+tLCVvX6kVCQ3Ueu1rTXl0TNhey1tSAbYoYQ2T9pv9tjfRSl8Lx/o7jxw9MhyO6H1UG0s5JONKs44WpSjHhmpbNy5f0N8+lv70WYX4wT/mXVQA5xslaslbKNHK8f2D//h2mFKx2ZteC3qg1KL7OOlRtbQoe3zRY49SZ7xS0VnKKAiwqjPd3+Laju7oW09gUmfYPpNMBazy1TphaqBpkL1FLalA5B1VCOh6otdL1Hc7680q6zpRmlbicqmw0VkBiHE7s3r7jcPsJJx9eHi6KrOStNvoAAsrVKOTaltX2Of31c1xQFlONOoqZtM4yi+bVWFm5p0kyJo3FhlbZWgmjF0e4PgA4h51bsgqULJpHN8sLVAdsXD2vrI2X2CbK3IJUqTXpmr+cQbIJAnxrRR48SlHHvASv52mipohrO5r19gzimCUC1oj5xuQnIJqlYStPE4fbO8okbvs0jrJZL1CpNH0r6/lpIJWKsZY4TtjguXjzhu7mmaY6aDOWU2a5FAFq7klqAtJ0laeRZr0BKjknub40Oo1zssEoBi9dfadc2d/uMDHTX8v3r0wiJzHWSrXmlKi5SFnB3EvvLP1mDbmSi362mHDeafi+6G2Nkyi3GiO+64Qhvt/hnMcHS46F6TgKq9kg30MtU7DOEmMhpYp1lna7otlu9b07+XqicV6+kc/7Oz7DlPkn//f3fPVhv4DQZZZZ5q/V/GQgenHRsr3owDoO+4nTcaJtDP2qJcYKOdM0nqxrttC2EpVShe0A5GZTRLs2jZIX2DWWrgvkXCkIk1SVowuNMCRFdXPxsOfx9hFsw+rihudffMbFs2uNFNK6xFqxbU9z9Yzu8hoX1LWta2JmcwpZGKEsq0jbr4jHI7sffmC4+ySsbVXXu4K9XIThcs6K3qwUWcG2LZtXb9i8eCmawpK1urKIdnLOw66IbVed+qe7jxzvH4j7R+1htxSr614jLKMwsALmUxTNmm9aXBPk5mznVADRdeZJsk6NtfKe08S4u8etZV09PdxLcxGa8Rk8JusxMdIDbptGXdBiEMm54ENDaFuRJBj3BFRntk+ZUTSD0njPeDry8N23DPf3OG1PKrliNdMSZ6VUoJizYUkMQIHts2dsX73BeS8smyy0BbQKRS35nfpZTa0CQqcREzzOeQE+VdnOKhIK27TkaZTroIjUo9aKCw2+bZU9nZMLjBjMrNH3yNnAI7myk4Ah47GukGsShvbMbip7brMErCN5oCVO+K6nubjRB4b8I42CHhsD1WpoPmKCSuPI8fFBKkC9VGVSihqM5LBY50lpkoe9piGlhGsCF69f019dK5Os+uegcUzTKOfRN5y1z7VS0kS1Btf35JOYkUpRmYF3Wr2pLWM5y/fWWHCB4e4WExPNeiXVtSlSNQvY6ANESQownYTgF1Np1v35garmcjYbGtVTy/l3lBgp44Tre0opHD7d4SqSXKHXBmq2q1rI4LyX2thJ8nYrFb9q6S4vMIZzjrFVyUXRX49l/N3VT9Za+W//2Z9wnDL/6J9/83O/nWWWWWaZ/8/8ZCB6ebUiV8PtxyPTMHFx2eGDZxik5acaQ8wVZyUkOmlTTdGbiUHW2VjLeJyoOXN5KQ7hmGTt71DGytrZoyFaRQP7uztOjwP9+orrly/o1r2ExBtzjt4pGPzlBavXX4gpZdY9liwh6qXOojgBJj5ggjCA+4+fePjuG4aHe9RbhVGmUTboBmskzN4FWeVnDP3NDRcvX9Gu1rIWzzMLKl3oKCCd1+Ko63z/9gd2799JPqmZzTpFtKGGc8OO4JRCnhImeGwThLgyFmukMtJ6R02RlLSXXdwmQMXZQD4O7L//VhzDRXInqzXi6jaWap66ypnD62shq2s7rDaEoHFWmtEpBhCRNfw4bxUjgO30+MDtN9+Sj0eMk5+ZUxJA5iTPNOekWZTuDDJc17J9+ZL1zTORgf4bbNQcjn8GwT4AhXjYiRGobTDGaW3pzCIrMPdBgGAu1CgVrVDxfUNYbzWqag5Jt2rgmaOSvDQMqRs8DyfyeNBEArmGrBEAWlLC92uq6iVNytKBHiWiKPRrmvWFrPmzNHcZh+pDeWKijTl/hjQNHB/vSZMwt2U29SRxfbu5lShGYpxwrTxM+BBYPX8u8gb7Iw2qdRjXiFGvKotr50paSViopmCslyrNpHKaplEmVE/5nN2qDwPFNxw/3ZOPJ8K6w3gJ8i/6EAXioi/K/jsvhQ2lJJrLNU3XaranguUq4fayVRHpTE2JGiO27SgYDrf31CljVdZQKloa4M9A1zRq9oqJNE2UlGjXK/qLS8CSx5GzKFSOKK71It+Zq2V/x+a/+B//FYcx8ft/+PbnfivLLLPMMv+/85OB6KOG05ciXfG+9TzuRpWuabi8rlshy82lVoypIrNyjpRh/3ikCZbLm7UwjJNov+qsETWOOMmK3zvL/nDi43fvCa7l2ZsvuLq5YbVdY4DD7sjpNNFdXEBoaFZr1s9eSFZj1fV7zk8d3cymDCPMXmgpFe6+/orHb7+WG67mc3pvtbGnnj+Xb4IyJ4lsLKtXr7j6/AvCnDk613KiUULz4ZCXxFhHSpnHt98wfvwgRg9dvdqzjm2uktS/bB1UZS6bgLMOrzdX17S4tqGkTIqZqlpcyZcUGUFFmCWjXd5Gu1dt08gNulbVxMnnNRRMkZt1LZXu4grnFWBbJ5mZVc0ls7gUzuDQWHcG9fE00raBYgw56nGxwlrXmBX0ABRKgbDq2bx6Sbe91HzX/PTzlcmuzgk40INaqaTTgZwmcajHRLGaAVqg5CxRSkFAYh5HYfC0qSh0Lc3mWn9elS51q69xjsfShwjNXk3DkbjfCUCy9cxGGytlCU4rKK0PoKDJeJEE+H6lJigtBFBHfUnS6CXPD/ZpRV4y4/6R48PdU6xYFhY3xwilYtsG5wRMpRhV6xix3rJ+9oLu8uYcUm9mRW6tkqRQizyQ8QT+SpwoFFwQdj8PI1iLa4NKEOTEi1ZZGHtDpXrP/ffvMEMkdOHc/17GCBZ5QJiSMI9VgutLhWk40V5vaVdaLIHB1Cy60LbRRrOCWa+lS34Y8G0HxnL4eEs8nNQYVjWSTdb/xhoBu0FMgSVO5DiRk9R3dteiQ50fuKwPGDWegTwwlVKeigV+R+Yf/NM/5o9/eOT/+e5+iWNaZpll/trPTwainz7uaPuGV6+2gGH3OJ63lNb8GJEghgPvSSWSYqRtPeNUeLg/cLFpuHm+lUxQUYGSk9RE2mqwJtEEuancfbzj7uMjlxc3XL94web6gtV6Jeu5UglN4LDb0714xfbNFwIUc4YkgfGyuk0KKI04ELRdyISWaf/Ip1/9CeP9g4Rvu4aUo2ruKsZI/qD3jnbVUFMV80fTcPX6Ndvnr8REk0ZpoVH2SlwUooeTTvcG4wLjfs/9t1+RTwfJQdV1tORl5qc1pTqmS844A3QtZYqEIP3xxsnNtVZxSJeo2jttMDJq8khqVAltp4yjAB0BZeYMkl3wVOchFwxVu9Ed/c1zATApggs/ClaXnvRqlPmdQ9at4/7de+6++jWN97RtI4c9FzHuFFl/GhGHYo3BGgECbt2xff2adrVRIFJ/FAGUz3KNOo4C8pGK0ng8UIpoRMs0KtuqHeo5ifnIe9UEV8x5NZzwTUPYXgiCzBG8PjxMo143QaKdAEqiWkc+7JgOO1kXa7Um1mIwlCzvTdbXokme+8/rMODaDtd2+rCiFauWp2gvY3VrIHILUwvj6cDD+7c0fU8ZJ6k9netaa8F5h9Pw9WosrmsoecIFS3/9jO7qmXidSj6nAuCcgOOKnFcj0hoTvIDQmnBdL0UNpxMgNZcCqKWa1Mz5oqUoE93x8PY9db8jtL2+R8hxkl2IPrCeQV9oMFim04DfdKyurzE5qyzBSGVs32KKaLCb7RZjLdN+J3m6bcfh4YF8GmhCoJRMmqIwqFmrf0uVc2oMxEQeIiVlXHB0N9cqGUiUccT1nbChqkm1QXSrpgl4/7vhmv9H//wb/vv//Ws+7gfG+LvJ4i6zzDL//s1PX83frLi6WrPfjUypENy8qnZY74S5iVl+aRuLKQlTBVydjhPH/cDNzZqL6y1pHHHeUrFMuRLUrS2RmoE4Rj7+8I5xKLz6/Bdcv3xBv+rwzsl60wp46toe063YvvmMpm002LyI0zlPwmDNa1y9Ccs6vmH/4S2Pf/pHlCljDUwpSUxUraJjM14iXVYdbSOs4xhPNFfXXL15Tb/ZyKo/T2L4sAJ2jK57z+tPH8AHhocdD998RRkHipokpH1JtI/WzU5uAc0V0UoSZKXbrVZ4H/TP+XP8TMnKFmkkEGoIizFJ4Phqrf++qinEgJdgc3IW8GqNAGcra1TfrwirrYCjkjCNBMibMjv25QHCzEH1OUtd51dfsfvhB0lKKIZqnW6yzbkph9lFVTPFCpvWbDdcff45oV2JekFzH6mqVzRyrMpwEtf07PzfPRBPR1wj8gDX9uAdeZhEQtE0el2p7jaJLpA84r0nbC4lZ3IaZM2fk+Z36srfGGENvdS2xv0j48Od9Nujx6FKNqgLAdf25NMJt1pjvSPu95KNWQvWelzTq17aiAbYQEkzU+xV/2i1StNwerjj8f0PysSLnjZPE6ZphH1GZSw5E6dI6CRCyQdHd3FFf/1CczTLWStrjFG5SAYjxQO1ykajJnGou9UG6xzDwwfyNNFsNhJr1igjaud6Xkk+sE3L4f6B+PCId+H8gFFT0uYp81SZOp9/WzidBnzfcvXmNSWl81agaoTUrAluLraY4En7gxQErDcMpyPD3b3EaVFVomAoVInTqhKlZr0l50wZJmKcMLayun6OazrqlCh5OstdalTNuEG00saI8fF3oGHon/3hW/6rf/rHTGkBoMsss8zv1vxkILq92HB3f8RYS+OExUtV2AtTKl5DuadcCSUKRquwexywFF69ucSEluE40rYCUPanwtobmkZCqbGe/eOeu7cf8WHFl7/3Jdevn7PabpRdKlQnNyfbrdm8fM36+UvR/s0OaNsogycxRkbNDnNVYamG+1/9a44/fA1VzCPjOJKKmqWsFZbJWkLwNG0LxhFLoX/zOddf/lKMxmk6gyRcIzf4mJ6YvNCcDTmH2zv2339DnUbKFLG14rogq8kp4sOsu9P1fJEMymo9aTjRNS0VIzdnZ6ipqBzT6s1a1vtV44hykQikpuufDD3e69rZnPUCvm0ouZBTxgJpmnBdT7O5FCd9ytB2cgzhR4yaedKFmkquhQ9/9mfs37/D+4ALXgEQwtSVQi0CkHJSVtQYLJb++oqbN58Js1qFkRJsIcCRpgNbYDgICPcC2Ib7O9Iw4Loe33WAgDSbLVb70Y0Pej6MxjCJjrHtNxrP5Kl5FOlD1fW6b6VFqRSJemoaKJk0HBnuPhBWG5UliMO9ZGmcqllWulaD58f7O9LpJMY25wjrtWwATFUZhzmfQ0IQl7aaZaiZ6Xhk9/EDzkpQfYyDRFuFoA87RhnjShxHfNudUxVW20u661dn5/eTZEYZeAym7SR3NP8o43Y8YpsO23akhztJhriQ0HvTqHvc2vPrigvecNztOH36RAgBybqQ4oUco+QCl6frFd0CxNNIMZXrX3wGY5IH02qoqt+21hKPA2G1AmeJuz15vwfrmB4fGfYHCc43ljzlcxmGZKx5vPfYVnWv40jWOLH26hLfrzQyasIGh+1a0TJ7DzVhlU2v2WItDPd3/46/Xv/qZjZmfvvpyH/6X/+B/u+f+10ts8wyy/zF56cH2j8epbe9ZiqWrDduAaCGmGHKmUChFMMUM6fDSNtYLq82pGJIx4G+DeQMMVYuGkPbSOB8LIb93T3Hhx3bZ294+flnXFxvMNaTjifRTmrgd7i45PIXv6RdCUDNpTw13KRJzQVF2CyrdZOhZdzvuf3TPyE+3oteLQtr6Ky4cJuga3ssoWmw3jDpOnLz+RdcfPaFaOvGoxKsAkgMBZI6gq2nOqnszMOR3aePHD+8w4cAWIlnchbfdZSYJBZHGSNZyxZcCJRScTXTXFyQx0gIQQBWrZSSNP9RWa5aMVXC0mORzMbQb85Vnt57dYKr5jUljHOScFAytVqKMbTbntBvhEnWY3YGRz5gkqFaXccXqWlMU+TTV3/GcP9A17YYrOg7nRVCtRRylgD5qqkD1ll8CHRXV9x8+SWU2XGvF5symAI6RWqBlfrOCsTDDih0NzfKtup6eF6h1oKpVsLQSxHmUMGj62aNJpTTUUCoUUa7kcICsqyP5cGgUKaB4f4W369lzY8RfShGgFacpBQgtAJOx5F0PBKPR8xqRbu5VFOTVljqCpgqwFocXFZZz8x0PLD/8B5b5fhRpfLSKjMrygYBojVnfKsxVTXTX2xYXb9kFijPDnirVag4eUiiSGoEzmKanjKeML6RVIHdI3katUAAjG/O59AYQy1JXOulMI2J04dbfJHvEV4eFNNRZAo5qQyhzG59Q86ZMUZe/ke/h6uQqBIcoIywNYZ4OJwd9mVKTA87aim4YDjdPUCRrYhk1TrIBWssOU8SZ6YxaCVGask4Z3D9SvTkKZKnkVwKbbPC1kz1Xj57ilSKHq/McLdj/+n2L/Er9jc/hzESU+U/+Xu//3O/lWWWWWaZv/T8ZCDqNIDc+SC16M3MdFTGVLE1E2qCatkfI+M4cbVtWG10tVUrTRMoWMiF9cpLN3oSU9P+4z3DKfL881/y7M1ruvUKpkjJE6WIAQHn6a6fcfHmNY2p1OMOmhYTVHdX5IYn4sksq8OYqMYw3H9g/923lHHCu0CKEYNEE5VS6bpWKgOddIRXa0gZTN9x/cu/Rb+9oqRJO841LF+ZvhrFtGVCA6HD1Ewcjtx/+y3T/pGmF9BZUiZ0nRq7CmGzFvuIroyLmr7SOOKshOPXLDpAYyqUKH++ZtVnPulScykYB6vtFteuRDbgvQBDY3RFPIMSp6vSpHrYRH95SWg6Ae8GNVuJxpR5HR+cmmXEmDVNiduvfs34+IAPwiJTnbYUlbOG0BqJIypq/ApN4OLVa7ZvPhcmu6azaQuVGBjnqHM+Z9PJ2rUW0uGRnBNhcykPIeOoOlynDBnqnymSaapNUuSE8UErO9V4JDtYBZBB2GbV22KMSByGA+W0p9leMjvmjXWUkqklk4sG03c9xopWsYwnfNPggqfd3kjygnMCdkukGveja0h+TtXXTNPI/vaDMHlW9IopFQyZEosWGBgB+hg5x1ZW0t1mw+r6+VmGUnUNbpSVxlqMk1D5EqNIKJqGPDxSU8att8TTQSQQodHr0VNLPMtbaq4YaR4gpcTp0yesGn1yLtRJHpSMsXgrrHGtSFZrkfOfSubmP/gFbdeTDkeRF0wRq6v/mhLWSGwUFNJhT84Z1zWcDifSlOh6qbxFpRclF00EkPpTF+ThI2WJ7nKNp7nYQpEs3ZILzWaLC450EDmF8Q159OTTUYxSPjAdT2DDb+jX7V9uPu4GYir8nX/wBwwx/9v/wjLLLLPM78D8ZCBaEX2l9Q6LIU6TaP4MWCy5FMZomKZIMJWr5z2+CZRiyFZuRsE7jIU4VVLW2sEx8fjhljgabl59zs3zF3RtC6lQqvREx5Tx6xWXr16xef5CbpLDXnScvoGq+jMR3WkGpuQI5grH+ztOnz5IeL2BqJFJIK7auR0J1DhUKtVYuusbLj//nKZfSRwQKKuomkNdUdZqMEHW8yVG4jRy/913TI+Pkr05SwOcRE0ZDL5tJaMzRcokeZ226YThsh7jnWRAzgYkowzYOGGMk9aXKnFSBbCNp+nFjT3r7cysCVRNpTWWytx+U6FUUk6sbm7wIah5xp6PhZz4J92smGhEDzoeTzz88D1pv8d7h0GBkZEIoaJmKOccVd3HplSatuXqs1esr27k9UpSR7XVUH3zo7UvoGHnNRep0KTg+xUliUnLOqfXp2hyqxETD1WzSRWcWGuwTafaQ8B67EqyUKVwR5z88/q6pkQcDqRxwDVS9SmO8SrAMSdKTBgrQevGzmxsFM1qqdimPbv15YFjfDKoeU1acF60uhTSeGL/8YPmuwbqpKHvml3rGy8mHyusYklZsjEdtKsN/eVzNappesIMzOdTaM1TtzwGQqAMR7lemhX5dCIdD8Le6zVQpkEkDlYYTaNMd5wyj+8/wRhpe8n+LDVSpogBiRTTEizRFGtLE5XtF29YX12STkdME8jDgOtbYfeLPKS5VS95thr+319eMIwT8TTQrXo97wK1z9FLGFxo5VouAohzjLgm0N1c4Zwn7o/UkvCrNdZ58mmgWq/XmTyIuqYTY9Q4kcZJyjd+xnl7f+JuP/J3//Ef8s2nw8/6XpZZZpllftPzFwKiwTvpNp+m85rNG6nknFJmHBKbVWC9DhjniAnavoUs2Y1TLtjZxFLgsNuzvz/Rri949cUruqbBYyTuBUPWQOrNsysuvvgl3cWlgI2cMb7BuEaBYBUgUyJQMVlWsmmKHO9uGR7vzqSe3JQztYAPsir1rbjIS0zkWnFdz+b1GzbPnwt5lkawut6eHc8FWctbh2ksBkgpMRwO7H/4ljoMhLaReKQkbmCLRP04BSclRvIUMc4KU4ewh8YKiLTOnVlPMBCjrAzVgl4NyowGmq7DGPdEYPLUdCT6WSftTDGdzSs5Z9I4klLCe41lsl5aheoc/q9ue2B28g+7Pbv378mnE6EJf07zWSTdHsXJmr8qPyN0gYvnz+mvbsSQYoTVEY3rk6mpjAMYJ7E51lKmibi7l2xIHxR4SEqAhNUrUDfihpf1caFMo0ghvMc2a3Fyw1nfaoyn5kStiZrj2SFfSmI87BSwrARAJWn3mrcApRSJTQqNamcF7Rlt7nKrtbCPc8yRRluhxrEaJwH8Wiubxonj4z21RKx1EjMVI7VmrJFqS+eCJhTA3BBWUqLdXrK6foYxXtls+6S3Ra9Tp/pUjYCyzpKHIzVOuKYjjSfS6aRZoyL1OBu3jGYAO+mfzzlzvH3ApCwB9FhlwLOsxJ1kvaaYRTFThbHPFNbPr9je3JCOB2zQhAE1ldWY5HvltN1KGehmu2WcIuPDnraRB76KRpFpjzyAsRbnpTY0T5KYYZ2hvdgQ1hvSbk+tBb/eYIInT5P01vcrAdAGMBa3WpOGE8PuAMaRp5/PAPTtpwN//5/80dIJv8wyy/yNnZ8MRBvvxVVesqzKq9zwplQYJlmLPb/p8E0gA9OYRQ+aZLUoGsGKCY40jhwOA9jAszdfcvn8hraRqJwSCylmiXMKgc2rV1y+foVfXykIVbAZWmVCZVVO1h5xJ2B5f//A6faWdDxinIChUoo0Lzn3dMPUidMkN73LCzYvX9NfXglgKBljnDJET24Ao+tuo6BGdH0fmB5uqVnWerK6z4CAS++cagshj5Pq+xoB5rkKe5g1T9JZ3VYbZWGNGJY0+D3r5/Z9T2jaJ5bTGFmRO60RLQWM17XqLAEQNk0YS89w9wn37DmhW2ugu8gnqnkyxGAM8XRif/uJ4eEBSiZ0LSXJz7L6Z60xKoGsav6R996uelbXV7SrrbynIjrVem66MuJqT4m5SQcgnY7E407AsPOiBZXMMHmNGXBZJ0D6R9esMVLbaptOygYw8kChwJgqEoNaxc1dslROxuFIzol2s8HUQk7lXEVqEPbWd+05pQAjBiCKADfbr6ReVGO4RM5h1RlfRROrTLVxnjgeOTzeEYcTtlYNbM9Sf2ksrm21xchI/BFoc5ahWa01JzTw1Btf5u38mQmfY1/n66TEUa7TpiXHkbQ/SKi915aj4UQtBavNZPPPKzmz//iJdDjQrla4phH5wDBQcsGq26zETM6JqsetGkN7c8n6xTONhELMcKVg+55ykuKD8/d5Zo6dZzwe2L37SDBO4tLmRqws50YyIyrOSi5pzkXSBUylWW8IXUcZZYMTLrZSGzxO5NNBanKtkYdrPZlxihxuHwSM/xvX1G9rPu0G/tm/esv/9fXdAkKXWWaZv9Hzk4GobzvyMJBTIcasN2YJUveustoKCKWIC7sJcsOIRaJ4vLMYC+PxyGk/sVpfcfPFG1brtTA+uiqvJVIKtDc3XH32OaubZ7KiqxXi6Qm4aF2nRr9rw4tlGhP79+84vH8rK0/nAYm4KaWKI171rWLcKUxZInr66yu2r17T9CsBkbNW0ji5SenrIW/1vHI/fPzA6fYDeRjkJqftPdY7YdtqxWuNoSlVdYXC6AlrpI01FaAoeyWygXm7XM70luhaK4bQ9fjQCNjVakjng2pQ58Yep6H+0jwzDQfyGLHOSwg4hpInxt0jrluLS3tm74xUMRrrmMaRh+++5fT4iA8B73WFnjJPFZryvmtM8leNsLftesPq+hrfNOr0L6p1Bcl11cvQqMRBBK1Mx51EICGA33mJVarzKl1jdSTSSWUSRQLZrW9w3UoeCDRdYGZC6wzKp5ManOS9lBTJ4wBA06/FXFTAmNlINTc5odmmen0ZjTFC6mWt11B81Pl/fmARacY8xnlSnDjcfiCejro5EDA7h6pLO5DHBi+ZsaUogM80fU9/fY3TvncwkKUz3iBSBwvnB65SdD0+DcJehpYSI+l4wjp/Ti4Qg09VNhwB8VOiWM/u4yeGu3uapgGMMI8pnR8Cygy8qzkzyKVm2sst65sr+TkpYUIgDUdpoIoTxjkBteN0NtUZYzgdD+w+3EmTmNeUDvmk5JTkwQ2Rk5Qq3/GSxazou5b2YkutlTweJQ5Nm5nKOFDGkard9fKgnEingePjUR4+jBwz+1t0o48x89/8/p9wux/5X/7o3W/vhZdZZpllfqb56V3zNy/48M2vpanGGlLOIvhvLKtNT9IudNGziQ7POSNxM1ZCqXf3R2zoefHLz7h6/ozQtFCFCZvXvviG7YsbLj7/gm6zUWNJEROJEYBU4yg33CqRRwYDvuFwf8/jd1+RDge9kTpdl5bz+lY0dY6URtEZVnD9iu2rF6yurhUQ6n57RoHnSkllUDXJv5TK/u0PnD6+FSlerZRJqhet9+reN/jQYJ1Xw9KEbVtqNQyPO5qmxbeamUgVxkd1mWVm/H40OYnLu+nXwqbWQk4R6xttk0F6v7MUBohRRBjrVLPKBNzZgW+MxG7VIsCvu2yxmgZASZhSmYY9d999QzqeaEJDNZDnqlCtpbROmFQDooVFDle3XSsIFYZQAKNGcIVGWNucpEt8bqMaB+JxRxwGiv5s14TzOTFVwYaRRiqrsUBFc0+dD9KuFSR/UyQGYrSiTtqslJ7Ob87UOBEPB+1Q73Ch+XOvN2ttc4qk04kSE75r8b2E/Bsj8gpha/2ZpZdrJVDP8EkNNqEhxYnd229kRVxUXmKdtCxh8Y1KMzQCqWRhkVOcaNdr+ptn+G4uK4C5+Wl+r1JAkBWgy7kqaZR1f7+CXEjHg3x/qoBrY42yrcKmW+fleg4tj2/fMz080rYtxjhy0gecWSqg2lzUJOWsJ6aJsF2zefkCVzUH1XnyMKl0AfIw0lxeqKa3Sranc0ynE7v3tzjA9xqwn5JEmxmRcpiqZrwKSd8PteL7lvXLF2IsG0fRBrctZRwpxz0lZ6pWE9eYyONEiSPD7kCetCkua8Yrvx0k+p//w3/JmDL/268+/lZeb5llllnmr8P89ED7Fy+5f/+OKe0ZRzE8rFceHxripOwfRWJS3MykCCM2DRP7+wPd+pLnX3zO5vkVDkedMsUA1pLGiFv1bN58zvrla2HrSqamTIkjNrTY0ErkjIo9hV0SJ+7ju/ec3n1HGgftpRYW1FdLMWCdldB7o076UijWYfuem198Qbe5UJCkjJKu8sGA44lRU+Y2jhOPP3zPeH+HNRXXBuJwlBuzc6RxIHiHC40aRxLWFmzbEmMmD4kmNPjgz9pOqjBKNSXRS2Jwfs5tLEzTRNN3hH4tGs9xEsbSeWkUMoaahRWU+kgxcBWk5acqkAFDoTxlZxoR8k27HTZ0tJtL5krN/e1Hdu++wxRo2k4Y0JLOpiJjJI9UalUFCOYsgeTrF8/oL6+ltWpuDUIDy4NXo440X83h+CWOTLt7SopiHFFQO4fCl1wUbOjnNrPkAJibhvqLJ5Z1Pm8VkXWo439mtCXGa2J4uAPvCE1zbm6SnFlEv1shnw5MhwNpGCRGtG2oOeKcVze+19xSZaFLwToxRDG71q0V3WGK7H74tWoZC5K/Ke/X+oBt1GymxqScIjYEcpTg+s3zl4Sul2tLEyOYdZNOtKgladOQEX1ongawFrfeQskSL2XESIbR92AMzjWSj2otNSZcv2L3/gPp/o6mabDGikwni7RDdLZFTHveK8NYSEVayDYvX+CsNF+5plV5QSF0G4m9QuGePljWcWQ8ndh9vMMaS2hE0iIGx6CfV3SbrvGYECgxk07ycGmDZfPyGaHrSMfTWYNdq9bBHk/ynfZBTXFSdZqnSJoStUork/cO5wJxGv7dfrv+xPnP/uG/5MPjiT/+4fGv9HWWWWaZZf46zk/XiLYdm6tr7u4ecLbSr6RushYIrWeaMn3jgaKB4o7DcWTYPZJj5fL5S569esnqcourVvSAejM5DZH1s2uuf/G3JCbHWAWhooez/VqkAHEShsfYc5/0dBq4/+ZXjA93Z4avqmbPOS/gODhC40VTNpuM+p7N1SWbV6+l2QnkBq63xRmEVu2fFrOS/Pvjp098+tNfUadRqja9I8cJ64yyvxEfpKZRdHKVZt1jfOB0/0DNldD0oqs0utZWZ3hRHadIGUQXWpTp8m0rrT5GDCMU7Qn3wmiK4Ub0kqUgq95amcYB74MCL/n/CcKWVjUa1VopKTLcfsRaqY3cvfuB0+0HfNPinWcaRnJK2g8gphbXNPoeDGRIU6ZQuXj1ks3Nc4nWmXWfysxJrWRRt7gyhECZJsZPH8hxwvVrAa9JQI71QRi4KoYv48QQV2slF8mD9c7jejGiSPaRvu4sraBC08i5zunMxo4Pn5BltheMaiQRoZYsxi1nyYdHaknn74MNQWWeTvTK87FV93WdJjVHKWjS1T7WU/LE47uvqaj+UJMUSozC/rbteVUs+Z1iTJoOJ9pVz8XrN/i2FwZUga18ZaIkGyCvJRWeIkfIcaQ4JPYqRuL9vUop5D2Wou1eeu1XZEUfVlseP95y+OEtoZNUhpyy1M+qdvnMHDonsgwnOuhiKpefvaZpe/JwlGNpHWU8SAC/GgpD15zjxsLFFeZ05Pb7H6BWCcm3RhqVrJja5OlVMkSNl/IEpoS1lerg4vM3+G5FOg1Sh9u2AlT3B8kkVpmLNVY2BE2gWkfcHYU5Nxp5VWEax1mu+huf//J//iP+4F+/59N+JC9p9Msss8y/p/PTgWjX8+yLL3m8/YCpoumigmk8pRpWvZUbZxEQNcTM8e4eQ8PLL77k6uUzus1Kqv+mSAVijORqWL96yfP/8Pfw/RrmNWGWfEbTbaDK6rSMw9lsYkLgcHfP/Vd/Rh2OUAouNOQs+lWrTUO+6wmdGDniYaAaT3GOqzdv2L54KZmYGKqacozVdiPm1qisK0Rh8vYfb7n71R9LL/vMQmptozWGeJqwocGFQBpETtBeSEbh6eFBwJdtKMp2UY1KMSVPUiQNXoxLVLK24zT9ChfaHxmoAHX715RkfWugjJFKQsBFYToezh30JWUBL95h85MJo+SiLKwlHY/s338v2tn9I91mi7GONMUnXWzJ1CpubxtkxZ/HUfIbu5bLN5/TX1yKaSnJn8NaSFmSDtAqS20wohTyNDA+3osbvVspS5gFzGVDHiNVtcTGaB6mQd4HFmcNrpPrp8ZMTQNU/VmIyc6oXpQcoVtTxhOnT2+xIRBs0PVyBTTX08paP+53uDZg2556OFGraKZDv9ImJV2HWw+uFe1prWBEf4oz59ikHCd2774RID+KZEJc7uWco1qSxEJlIE1ifKsYmjawffVSGXFxsleQ16pFeu9n1FS1tx1Dnk7E8YTfXknG7cMnbPDCCMaE852woRr3ZLyhTAkTGg6HA4f3P9D2K3IppCixWSJFaMj5SUISnJPvn4GI4eLLN3TrNenxUSQ7XWB63FHGRNj4WeiJ8b0cby1PONw/wDTRNK2a7JTtdV7Y+FlaYq1c8ymJ6cnC+vULmr4njhPEhFuv5WXGgXjYP/kNq1brtg3Ge4b7e3JM+EY05bVUpnEkBAH6v6mptfI//cvv+fv/5I+YUlkA6DLLLPPv/fz0QPt+xcoUXv3yl7z79a+wtWJ8Q0qFUjJTzkwFNquGPE48fnhgtX7O8zev6S/WtBcb0WqOESykMVJdw8u//bdZP3v551zeNY0CCEInN/CcKKc9tVpsJ6vmxx/e8fjNV5RpAANe2Q1rxApTcqHd9PimoeRKHDPVeMJ2w+rFczaXV5Cmp9gfdV3PWj1J5wQTRPdXU+Lu66+5/fWvZeXeNtJzrT3dKWacMYR+JTFOuz1t19BdXZNK5fjhE8EHjO/UvPLUKZ6nCGomknSeQk5iFrHe0mwuqNoEVbPo+Hzbnl3klXJ2WdcsYfelFob9A844KLLSzjFhasF7qY08A0vNv5n7wMeHR5xzhL4XNjZGCpZqHNVJpeus6a3GaDJAwXcd289+QbveasSRvB4ZOZ/eix7YO/CtvO8UqTEyHR6pVNxqo6A2i6N7mkRGUQrGBTEaFTDVgahZ8V2Pbzr5d1EYrPNK3XrJllWWixypPkCKjB/fYlwQh/usBbaiXyWLjCA+PMhqd7umTElzZxuazQbbdMJKmzmzNFOnQRj0tocYVT5SRKsIPH73NSmOmFwkh9SLFrRGyTqlFJF6RmUdrSdOIxi4fvMFzWp7rrAVo5UYykQPXfSDWwgeUqZMI/F0xG8vcd4TD3tME7AhUKeEdYFSxcSHXudzdWdOmeO7H+j6Fd63mGFiOB0pBbpe8nGtK5QkIDjnQsoJYwrrz96wubxkuL0lx0xY9aJbnqaz3hMv7zmPGcjUOnF63DHc30sAWDGq1dQa1TpXmyKB/saQToNoy3PCrTvaq2tKyuTTEd/1InUZI+lwACo2iEbZhha/WlMqjPs98TBqU5PBGsswTYTg5YHW/uWBaK2VlCv/x59+5O/94z/8LalOl1lmmWX++s9PBqKiHQusr57Rrd8yjQNjzKQs5pxqPW0wjLs9x1Ph+ee/5PL6hqbraNa9MjXaFkOle/GCi8++pN1ciclEndCkSduCjK7hjehCS8U0njglPn79FcP7DzhjxNxDJuWKcxJG75yj3a6w3pLGkZISKUN3fcPV558TZiNRVp2pM9JFXqquifX9OHGuxynx8Y//Ffv3b2m7legQgxcnfoY0ZnzwVFuYjkdKybR9R7tdk3Jm2p9oWjkG1hoBgujaPSURA8wgiKrZop6w7iRMP2Ugqe+lEZe4t7pWB5ynDKM4jr0hp0pMidCusNZSUiFrbqXzLXqk5fOap2itGCNYaT6yRtb9KSU9HuYM1OdIHmfAkJliIqx7Lr74JaHtqSWdTSMgYKIaK/Wr2ihUcxT97ziShr2YhEIn0T61YL3kPIo7XbWPtZ6lDLUWnJ/Dxx0larWrk5u+McJWo/pFZme585ThxHT/QVq0QiO8om9AOejZvBP3O4yTvvWaM3G/o+ZIs96IrrbM6QLIta0ZszSdgMPQaLi+pdTC7v33IuFAlAMmuHONJudrAPKUKFPCdZ4YJ2mievOGZn1xbkgSva+urX2L0WNb1VRXNTUhDgds1+Hajnzci5mrac/lBWUS7SnBQRI5TK2VaUqcbm9pQivmoFwQLzpyrRvEpT5LZbDEccJY6G+u2FxdMd4/YIyhu7ygpEw6HQnbNa5pJAC/FFLKxId7fN8yDSPD7ogzos3EWXIRg5IQzgFTKq4R89p0mpiOo2iDW8fq+pk65EfCSnJjU87k0yDfIWNF2uE87cUlJgSGxweODzs1VcqjTYoRZ8E5K3Gt+UmS8e8yD8eJ2/3I3/kHf/CX+jnLLLPMMn8T5ycDUVMy1nn6yxvay+d8+vWvybnQtp42eGJKHO+PWLfii9/7W2wvNlhrca1UCs5AphhD9+w1l2++wGmTkFFwQRJmEKetM6gnoVaqC0zHgU9f/5rDh480baMrTYPUSsrP923Atz21VuI4kMaE7zo2L67ZvHxNaDuI0zk7UrSORZzeVtklDXKnOI63n7j/+s9IxwNd11EA59Wpa52uNi0lJ6bDCecc/XpNs+457Y9yjLqVrPlntz2iX4xTxGlblUFARIkCvkPf0KzWlHFScGEkxN/L+rVEfZ+Wc+833hHHkVoNTdtrwD9AxRkj0U7ek3MS93GQbMoaI+M4kvNE23XiXC6RUqu2ZxlsTbLKtA7rHeDJcSJNkXa75fLNZ4TQohk+quvTCCBjqFmC2meDUs2FPAxM+3sx51hPHoQJt8GTk1YYOo+tolk8SwFMlQpI538ECK0ErpckxhuNZaKIeUweOAJlPDDef5C4Ii+1nsY4vQ4SVCdShOMRYy1+vYZSScOJPJ4IfU+z2kgLlDX6Hyd65loxvQTgVzNHKllySRw/viPtHtU4JF31QtBOONdIZJEx5HEiDgPOewrQrns2z14qCM2aUlCF6dXsVqPaU5jBVhEQOp6o1hJWK/JwlID/pqVWCy4Ie2uF0TZJ5C9USUQ4fPqEA5wPwrIjHfPeClOcpgnnZIVtnVz/tSTaiy39Zsvp40ess7QXl5ScSYe9gOf1Ws+NyFGcF92oCYHp4QjFyHpcFQZlNt1hiHnEeU/TBH2QKvLQUzPbZy/ks00S0G+bjhJPKvuQmmBrLa5pcF0v0WLTwHD3QLDSWiW+r3qWWlTQqLS/HH/5H//d3/9L/f1llllmmb/J89OBaNNhnSOeBnBraoGuDQRvGQ9HjruR7c1znr9+Q9e2OGMxYV41Q40R16+5fPOK7vJKboA5KZlkYa7Q1BsfoAC2kpNoMx+//waTEqu+wwapMqyII7jkTNO1WGvJ0yhd8taKpODlS9bX17KCVcc0ODGWUJjrMwX8yoq25MrwcMv+/Q+EvsXkSjoNuKCAIWXGYVS3MNSSaVdrmuCxXcswnKi50Ha96Bxnhg7JJixzvuT8/9VCGgX8tes1oeu1aaaKCUpTA6hJjkspmq2q0TxAipLf6EKg1qc8Ssn4dArURCtq1aWdUybGEajniKWSMnnKVCNRXKVUNcWI870aiRPKpdJut1x/9hm+W8+eeD13Cp5noGNVJ1oytUTicWDa7zWPFuLpJLFB1qvjX9hU6yyUKs1CXsFXrRKvNDckhUZeUuslCRIvJK9rz476fNoRdw+q67TSXKXrWGlMkoSCPE6UnNUYZhQAZpr1mrC9knpQNZJhvepJVbOYJjUuzT9r5PjxLfG4w/kgxh7rQAPZQ98L8D6N5DGSRpWlUAltYPXsBaFdqWRESw3UJKQXkGpgExgBqDVmpsMDtWaa7QVlitQ4SbC/iEpFQ6oSDaPfz1ohV8Pp9h5fwSrDWosw6l4NWikWvFejm51NeRP91Yb19SVxt8c6i99syFMkHg6UaSJseqzGU5UYMViazQaajv2nW+o4EZya26yBYtXQVmXFDhjnyKlS0ygPXU6Oc0oFFxM1FcK2P4PXGif5PaNyFtv1koiRM8PtHbVUQtfK+yqFHEeJUbNWDYs/yg5eZpllllnmNz4/fTXftJz2R+6++prD23e01lNyYvd4oCbL9bPXXL28EaZSb/4mV4opmNDSXF6yuryi6XrRfWoQeEUDsK3DOInDkXus3IjGw47jxw/s378XttTqzXdmLoCKEfe2xiqlKOad9bNn9DfP6Vdr0d/VrDE3qNmqnvWhNaczEzqNE4ePn8jjgWazAgzWS+C2DZLzORwO5JSUzTP4VY9vG8kyHAacsYTVWtjEEETPmTJpTgJwXlN90lO0kbe0TUvTd/r5jLTqeEe1atSowhSLSUNutqXq6t1Y8FZX2U+h6NZ5rEZAlVQ0g7UQc6ZU0XcaY8mpUkgakZTOAeLWymrZ1CrgJEvf/Orqku3z54TVWiJv1I1siq6HQdbVGs9US6WmSeokB4nyMbXKz7YK3GLUHFWJ3DIGaMK8/cYgoNQqEDUaHF9LkdV/8NJglKJeK2LCyfFEGk66SterRlMQpAZVVug1R/LpIMc1R6mQrNLGFfqtrsMl3mkGqSB66VlKMkd95Thx+PA90+ER66T/3ACoCsQ1LQZLGSNpGEUrjEaNrTrW1zeEXtqdquo/RY8q52XOta0pQkri/jaQTntymmi3lyJt0N77OThAtKQSKWV9kHV8TuQCx4cH6jjgm1Z0xApCq0Z1OefkOJUkWbnGkuKEaxvWz24kp7cRYEfJpNNAHAZC3+IaYdurZuPOUVO7Tx85fbqj0f54rAbhmyLO/CIrdhcaaq6M+xPGZKqF7atnYkQcxCzXXl7pLwWJr6opigfMB9HGqi51HAZyqbIhMfIwd7724FzSYGdJyDLLLLPMMn8l85OB6OPb9xzevmV8uCc4z2ha4hDp+0u2l1f06150X0l0erN51zYd/dVzuu0GW5K0qDQX4igusko860fTIGyogZIKx0937H/4Ttyus0PYGHUX6yhQAgGQ1EpYrehvbrh4/RofWgWZojXEeAhe3Ps1KTDVnEsLw+Mjx/s76cJugriCxwmn7T3TFInjQE5ZDD2NxzUB14jGreRK2zd4K+tF5zzGe0qtpBT176mkoGQx7GTRv3WrTpqS5lV8CLL2rYUSR9HpWkHfVQPdZ7Zq/mdhEWXdLMk+ol0UjZxEQZUc9b0UQteIQ7uKG18AZxH5gb62gLUiTmvxSNNtL9g+u8HrmhM4g5xqrcYIVWoxUBIli9s6DuI6N0Eie0qVuC9jDfncbW7VBW6VTTYKmIWls81K1rvqFpcYJjG/GN+IgQjOa+p0FGAmkUv6OloaIBFhInUwtpCHk7DIqp81QFhvsdokNBORchKEiTRzVigKwLWq8vDhe6bdg9bOFiEiNfHAegXXJRMPJwmrVwDWrtesn78grLcClrVaF5Bgdjt/Z9BrWI0/1pFPO7CV7upGzWtS4zk/sokGFmoRwFxLUtOZ5fh4T3x8JHgvQDDn+fDKM5w2lVXE5Ge95KFWU9k8v8E3vbK1AuLScSQNJ/l+dD05ybV1Pobesb+95fjhE06vX+u9sJNkfXiUh6pGNwumFKnjdZX15RVd11ONoWkjKU6kccDaTkLqj3Our0RLzXreeDwwHY7gGmwIlHEUEDpnvWphQtU4uHlrscwyyyyzzG9+fjIQ3X/za/Ikq07fNKwvLlhfXtB0LW0bZG0/JoGLtVKDp7l+xvr6mtAEyJM4HfqVsBNldmioySNNylBCPA3s333g8OE9JMlWLFRMNaqnVG2eOeMQSkrC0l1fs375im67FX2bRrvU2YDklfHQG/sZkFTD/tMtw+M91lRCI1FQKYm5xHjHOIxMp5OEZntHaIMYOSqM4yQsaBcUaDgFDKJBzSnKTRExpYiXWlgh4xxN32lgu2RDuhAwM0Oo0TTMPdtVWK5c8lm/Z/RYCplszkYh+YhF17ECnIqylKH1wsjlTFGzljGiC3TGUPSGPN+Ic0wQHJvrZ3QXV7hGXOwCLgRdGDSBYG7E0hajNB6ZjidMaLCtVEtSigIbbUqq6LkVR7SZHziMwRivK3UFYmd6z0iUlhH5SJ1jqawYU+L+kWm/w61WYvKioo2Oohs0jqR5sCVNpFFc+hLO7whX12KImsGINnnNcVtolaaZNcfOUUri8OEt036HDY3iZU0a0PNnCuBnbeWTWc+3Hf3NM8Jqwxzyj7XixP9RbBV1DvZ/Oj/puMMYQ9hcycNJrZimYzYvcQ6Cl/X+XIeKCxzvHoiPO8m2VfY853R+8LN6nadhBIoyo7Kh2N48o7vYil63yjlPpxPxdMK1jWwGkM9aLDhjccFxeHhk9+4Dbgb41mplKszxSjknyQL1WsSQE9UgMoleDIAueHzjae2K08OOx/cfCNZhS6KIIlseohpHjgNpHGlDy3GciC5gjZXfDwaNwkLj1YTJd24Bossss8wyf1Xzk4FoiUV/6Qcaa/FtEB2Ys3hvxbDshEHz6zXt1SWXbz4ToDYNYPyTUSHnp7abJHFOABjL6fGR3Q/fEx8fBaxaS84VY/TGUKr8DEWhpWRhjKyjv7nk8osvadcbuenOVY7zKtDZJ/f0rPsSYpKHtz8wPt7KDc9YSq6UqNWgjWc4HJhOJ/l8IeCDx3ctOUnoeAgtIUiupwuaA1rE1FFLEcYRMKaqLlJMOb5tfrQ6r9gg0ToAeRwBq1WY0rhUimg38yQgoeaiuj/t9q5V2FIFa1XDxlHN5Gw+8j4IMJjZP6pmn1sBGVRqqme9nEROObYvXtBtr84rZjmehSemWlayNYqD3HhPmRLj4Ug1Fu9UA6w5rKVU+WtZ+76N6EIlBxZxRLsgK3FNCKgiZlRAqg8VQX+uipKNscT9g4DBptWGK43KKpWSEtY3xHGUmtDgSFORXEvkQaK9vMa2HWDPoftY/bxWIr6q0bakOldBVg7vfyDu9+L8NhXBqMr2zuvnmqUZC6NSBNFsrm5uaFYb+SOqBQZx5xsXFCRmbRgzZ5lB3D9AaHCrLXkaKOOA69fMetVqKqhz/Hzdx4gJLY8f75juH/BG2fciq2nrmzMzjYE4TRI84Lw+3BhWNzd0miJQchJ99vGAKZVmvcapeavMznfn8E3Dab9n/+49XosARHv8Y8CnD0Hn0PwsBraS8H2gv9joNaj5E1auCx8aSDs+3d1y/ewK5xylZGl2ypnpeMI1LdZ6Vr5hOJ3Ixkn26PFEKVLwYK38rnPen4s1lllmmWWW+c3PTweiFawzZ9bKWoPD4L2TFRoV4wzNxQ3XX/6C0Lb4fkWZBioGu77S5pVRHb5FGJU4SoxMNTy+fcvu3VtqjHhnwBlyzOetp1WHsugfCylOVCp+tWL74iX9zXNx4arxaWahgHMDzXmdWwrGO6Zx4tNXv6YMR0LbUFMmxgk7107WwrDfk1MmdA2ha88d67VYDI62DTgrzJ7TjMaShAUtOZOLrLOtk+imnDOlFLr1hbyOag6tF0d6zuL0NXrMDVVMFLlIduIwCgcqh/3sxj9/ViPAYW6uEpK6Mk2jVmp6BaD5/HO81XD+Kk7hmVl1KivoLy7Zvnwl0gFlMo229sy6P4OBPAn4dVZAaIwMjw9grGR9piRdARribp07r0RBQI61ApxqjrimxbWzZlbY5LneUc5xkXX8/M+6yhcm9BHbam88EIcRMJhccE1DjhFjwbWBOR4+9GJm8W2PbRrm6s0zU6ca42os2CDgM6dzLej9t38qpjYNupf1btWCAsi54pzoKoP31JTxjaVWT3txRXdxKcdRr9OKPTPrwjLHs7sdvTam4w6cx3UryjhCEmPgLJUo9kfXSM6Iua/g+jX3Hz4w3T/QdS1pHFXHm3VFblFFBNM4kaZEaCUyqlToL6/othJtlY57lZoYwmolD1dNK2x7itRc5AEtBKZhYPf2HcE56hwfZgwWq7rncmaJQ+jAGcbTQEoTTd9w8eKZaluVxUcMbyUmaq6sNhsohcfHHZvLC4I+vIy7HaZajBMjkusaNm1gOA2kaZIsY9WNewtO28fyAkSXWWaZZf7K5qeblVAB/8yegTIlskrFW7avb7h48UZugtZR40Aej9hOtG41R4lmUrNEVZd6mjJ3X3/L4dN7vHc0nd7sorTrGAqhaUWvpVpR4Ru7AAAFIElEQVTCNEYKhuZiy+Vnn7G6vBGgMA5UyjnqqM4ZgOd1cZIWoaZjf3fL3Z/+SgB122omqMTSWO9EcxYj1huMbfBNi8rWpCqUrKHXwnL5vpMVb4xqfICqWkmnbFjS5qdutcEqYBT9mjCYOSZZ46uxpdYsTVS1KkAdJZ6qCKAwSK/4ee37I02bVIgKCziNUm04xx2VKkyo06aq+fzmLKDSt1KFmWKku9hy9fmXym5PorVTjSclK2BPwkA7JyDUGPI4crr9CFSazZacxA3vfdD2IGGG515766ysgLNoSl0IeF1Rz+U2T+BO+EdCK+c2qVnLOqbdHdPjI7bpz+YkSQ9Ar1VhxU3JwtgpaJ8NUC60ki/qJRQe1bzOkWK1ov9s5jdELZnHd99KGL+xZ3mE1GFWvPPKXlfimGj6BksFCzFFus0lm+evOTOkxmCqnksj2sYaxVRE1WrXWomnPcYH/GorHe41YdvmrFqotWC0sagWkWiUFLFNz3G3Y/rwibZtz1pgqqztrXPaCS8AvpZC49WoRiFcXdFsL0jHEzlGwnqFa/U7qg+sJaYz022dk555Cvff/yBxYrYh1Uk3KQJAJaBf3odznqq62VoqvgmsXzzDh071q9LaVVKhlEg1hZwjaYxsnr/A7h65/eEdm+0GPw6YanEaDWWRnFBjHU0p5MZx2h0l7zdF2cB4x3Q48nj/+Bf6pbrMMssss8xPn58e32RBjDDa/zxrCEulOKRb/NWXyu6BSZF82GG7NSY0Gmszg6ZZr1aZpsJ3/+JfkI9H1pcbMZQoA1TKQKXSdp3ekBSolUI2htWzG67fvBZTh62U0yArVCOGH6M93XUOUS9acRk6br/5hsO77whezDqlGuI0YgHfNKJbLJnQOHy/Jh4jZZqwXUtBTC6+bdXtbfAaNJ+HiTJNVGPIRYC7tfYMOJyzdJsL5lB264JECNVCmbQ5SXWSCrWooPrUA5vrG0pMWGXoqtYynh3qter93GmGYiTFUVjrMyNcMdWd5Q41S4d7qZwNI3NGa3e9Zvv6c2ngmSRaSDJCVduo75GqrKGuNkuMjA8foVTCZnt2mLumIeUkDVjqTDbW4cOspxU5hfcBv7oQUKfVl1IHOjdfIefauXPMF9aQjnuG+zua7bWytPxIRzmzjAamAavxTJQqJQo5Y12QmCPvtZYTAdfaZoQ1AriNkegja8A5br/7mjIM+DkGaIhiDapF8lr1/KRpolkJM1y7hjxmfGjYvvxMvmQ5MkeSCeM5a22VycdoVSlMxz15GAgX1/pwl8F76hTFoGTAIG1JtUpeb54itumYxsjD19+wXm8lm7ZWaXqyIrFJU6SWTFLmvGsC3jnGUdb566tr8vFEzZId6vvuzEjXUjlnnhp9YLWG6iyP373FZvm+lCIAFdS8pWkYc/QaBsiFFEdSnNg+f0G73kjda5rTCty5NazkxLTbETYX4CxN8Ny8esH+/oFaPN1KYrDIqDZd6nFD39J6T4mFnCth06u8JHPa7/DhN1fxucwyyyyzzJ8fU+e8kmWWWWaZZZZZZplllvktjv23/5FllllmmWWWWWaZZZb5zc8CRJdZZplllllmmWWW+VlmAaLLLLPMMssss8wyy/wsswDRZZZZZplllllmmWV+llmA6DLLLLPMMssss8wyP8ssQHSZZZZZZplllllmmZ9lFiC6zDLLLLPMMssss8zPMgsQXWaZZZZZZpllllnmZ5kFiC6zzDLLLLPMMsss87PM/wsk1mVhFOfd1gAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqIAAAFUCAYAAAD/Il5qAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9Wa9jWZatiX2r3Q15GjP3aLK7uipA/0fQSwmQChIkARIEvUv6VxL0J/RUt1CqvHVv3syMyIjwcA93MzsNyd2sVg9zkac3N49GCSg5EeHGQ26uvblJnjP2mHOMoWqtlXOd61znOte5znWuc53r/8el/7UP4FznOte5znWuc53rXP826wxEz3Wuc53rXOc617nO9a9SZyB6rnOd61znOte5znWuf5U6A9Fznetc5zrXuc51rnP9q9QZiJ7rXOc617nOda5znetfpc5A9FznOte5znWuc53rXP8qdQai5zrXuc51rnOd61zn+lepMxA917nOda5znetc5zrXv0qdgei5znWuc53rXOc617n+Vcp+6YY3H78HQCkA1e6VUKZTNpN68g+v/fR6PVvgi6q+8kz1E9aqP3F/P7X+mNf01hrPS73y2MN+Hodlqc/s/uEIZT152uN11YstX+z31dP47HkVai0Pj6nHD30m2KsWebTKTu7u7/h//D//X4QQMEauoWqFGBO1Vpy3WGOhKrrOUWplXQPGGIzV1FKx1qCVRilFCBHnHMYaOU+lglLUWimlUlVFo6iAswbnHPvDRKmV68sL5nlBKYUxhs579tNEyQXrLDml09oAOWVqrWitQUEtsg/b1l2Wlfv9nqHrGMcB7x3eWSry+lLKxJSgVkqtbDcDSmkO08zHm1uuL7eMwyDnwTpu73fUWrDGAIq+98SY6LoO5wxUKMjrW0IgpUQtlZwLtYIxinHsscYSU2J/mOicQymNsQZrNKVWQojyriqF0rAsgb7z7T2HECLTvDAvC19/dY13DucdFcg5453l/v6AsYacMtM8Mw4DXe8oueKc4+b2Du89fee5v98zrwvXV5dYa7i9vUdrzddfvcdYzTwtXFxcEGPgu+8/UmvlYjNirSGXwrurS2LO/P7b7wkhMPQdX3/1nnmeiSnT9z3rujLPCz/7+h1rSHz1/or/+f/iv377c/ojpT73JTzXuc51rv8/ri8J7/xiIPrK8qdbr4HT9sgfv/wX1ss9fOk+f+qx/dTX9XybzwHf10BlPf7vxZJv7/3pOg9//9Qr2zygwTc/KLW+gmQbaH288rOX9hIIv7KO+pH9AlU2Ot1dSiHnjFKKXApKKTrncc5Ra0UphbWGWmXblDO+81ij5b5a0FpjtBEQ6tvzAO8spcjzvHcCvvYTKSWsde1fw+V2w+39npvbezbjgNZaXpqCi+2GJQRKzmhjSDkBFa0NSilSzlRAN/AKmUql1srlxRbrDLXI6zhMM7NSWGdxDSgrQFtDjYn9fsZ7izWaX/7sK0JMlFxYQkANmquLLfOyYIwmxExKBecc67xSi8NaQ6mVUo9vj8L3/nRBtywLu/3EMHRQQSsNSpFLxilDKhmFwntHbq9LAdO0MA491lpyzmgjANV3llorISXudnuury6ZlxWjNV3nuLs/0PeezThSayGGRMqFWgqbceAwzfSdxzlLqZ4PH2/xnWPoO+7v9/z6X37H11+/h1r44YcfsNbyy5+/59PNPYd5YTMO9J3n46dbttuR/+rf/x0fP92wLCt959Fac3NzxzTNDEOPcxaUYrPpKeWcgnyuc53rXH+p+nIgqo7M2Y/XETucQMhxgb9YvVz7MdP2+nG/xvK9xgA+/vn1XT/hCT/7N+sxYvtznhf1dNfq5d5eHlj9/Kt78uRHCLg+vkeh1OdYzcqbF0Ptgde43dcO5Xi8uWRCiFgjQMpog3OWmAqUQi0VYwyVIkyoVqf3X2tNiJFxkOdMy8rQd5RaAEXOwqwepgljDOPYE1NinlY2m4HdfmYzDlxsR5ZlPQFprXS7XTFaQ60YLaBYKXUCak4JSLbaoLWmNMA1zwubzYh3nhgjSsHY96ScoUKK+YGpzQVrLUopYoinYx/HHu8da0x8vLnl6/dXAhJLkXOgKvM8Y7Sh5EJWCq0VSmt0reSUWJeVrvMnsK9QUBWpMc4hRKwzpFJQFYzVaKNPr3EY5BjmOVBrasyy3L/RhpQiyxJQSrHb7fHeE0Kg6zqury6oVHLKaG1JKdN5S84VrcA5Q6Uybga6zrPdjOwOM4fDwrvrS9YQWUNk6DzbzYa73Y773QGAdVmZp5mrqwvGoed+d8A5h7WWvpcLBBSMm4HDYeKwP5ByIeV73l1vGfr8I5/Qc53rXOc61x9bXwxEf7zRLcjly2HVYyD2JW3047ZfBlveuu/zvOaPt+sfQNED2nuxR/X0prSXH8O+lwzlA/n49Mnq8Q8vXsUXAOUvecbpIqM+sJCqgczH7foXu2nbn1r7nzuO14/1BRw9saGvraUwWp/2aI0hpfRki5SStMutJsZEKRpjDApF5x1O2RNYtVqzrusJLBttqA3cWmPJOdF5Ty0CwmJIeGcxrS09Lwt911GNRmVFqZWu83L8pZ6ApFKQGrhzzhJjwmlF5z2qgm33UcE5YRJjjPjG1FEhZWn1a62IMZFzxliDrpqcCyEkpnnBO0ffeaZpJZcsgDcXtFZorTlME845NpuelBGwbgzZ6BNA1loLC6gyULHOElIk54zzlloK2hhiypASoFobPuOcwbl2kWAMuihhgLUiIa+/6z3WGHb7A147YkzEkISJ7A0pFVCZyhEsKwGta6IfOvqhRyvZZ+o8pRScNez3M0PvWWOk83KBUWtiHHu22w3OWtYQyDmz2x+Y55WcE8PQkZOMCajtyLpGOiCsgfv7Aymdgei5znWuc/2l6ie05r8E9DRY8aQN+6czfo9h5OurHcHdYxaUp/e9jmtOgOf5XKvcfwScnwPArzCb9eXNl/tRD/d/Fkd+7vy9BNjP4erDjGW7783lHh2EerigeACjn3/ej8+BvDF+cHzsEeCtr61ZK6WWh1lJwGlNjFFmIa0wXADGaKwxxJAoRUBYzrW1ymlzihpnDQXTgF/CdPp0ArVWlCIs5GmuFNVGAIQFVEqRUsY5aTtTZZ6ztNnMFIUJ9c6iUA0YV6zR8jpiwlmLqpV5Xggh0Pde2uCoxo6q9n2SNr1uTOUaAqVWnDVYY1BaUUpmWVc24yAgLSViStKCz5XeWsaxZ15Wpnlhu9mwhkDXebTRD+e7Csh3VlhIrQ2bcSSEQC0VjGJdgzynVJl3rZW7+x3vri9kXAGopaCUjEXElNBaYYy08kOU+dwYk7CsOTEvM33foZS8h3JuHcPQtwuGxOEwyWt2Ftf+L4xzbbOtpn1uFUYZtpuRlDPrGlAotuN4mg+utTLNC58+3tJ3Hc5buShTwgI77/CdsNTnOte5znWuv0z9pNb8Y8ykHv33cwDxScv6BHA+z1r+OdvVr60Oj8FyffRfJRD0yYt8YCwfnvsl+38E/p6s9xzyqmf7OYL5L1i9PluyVp403D+zyKuP1Ad4eDrk0w7eAJqPGdNne1BvzoE+5ztfYawrL5atVcQ0qbGH9UQjS2tYWveFiMIajXVWzkkF5y2hAdNApNQqbJsSxrSUwhqkbWy0ISVhMEupwnrWSspFzkStaEFLrCGCgq7zTUClcEaAadd31FIoRURK1lpijBjt8c5xmGdKkRGCzjlyLSg06xrxbX61FGnFS1teWvTGGjZubOIlOQUll8biFpZ1RWtD54UdjSkzTTPTvJzmLEWUVOm9Z11jA+y6nS8Bn6VWYV4NKK3oh44UM6XIudFKoZwhp4Iziq73LMtK13UnsF1qFqCr5GdjNM5aDvOCVlCNgMKu863FX0TYVjkB8RAC1lju7vcMfXdiqLWW9y7nwmYzMgwjOcvxxZBOwF0bQ4ozu91eGFnv6bxvoxMC2FPJdMafQHhKicM08dW7K4z5S44Vnetc5zrXv+36ciD6Cp54CZre+IX9FI0+euDYDv7ssx81/N9m3d4GcMf5xnra/dMjeAyNnwKkJ0u9icWe7/Dl6xHQK4CoNuTwFJB/bkjg8a1HrOqzY3l6eG27N5Z/BeOd7nh+XE9w5LP16pM7Xy749nzoixtPHzwei3rK6Cpo6mwBYyhY1yDgwVrmKHObqlMcpqW1dF1TjsPQe0pry6ecqRWZCy1yZo8MWy2VNYTTHKrO+tEnsJJLwTrXREfC+OnGsmmt6fuOkgtGG4yzhDWSchbgizrdPh1be705lBNAFICqWdbI0ABxaQIthcJ5ERwdQZo2GqU1SitqLSfgd1TxD0PPPM/I/Kol58A8LyLKAVLKaC371EaTYpKZ2hDRWtT2qYHVI4NcqqYWGS04gvPNOLLGiHcWbSo5JmKMWPuIvSyVzTiwroEQA6atqRqTqrV8mo/MMxXmeUErTQgJa/VphGBZVgH4bSRjuxkppbArB+Z5oesEdHZ9Ry6F/WGi77s210s7L8tpBlbWlRGQzntizHjv3vggn+tc5zrXuf7U+kmq+RO79SpifA6W1Om/L7d/m2E4gpuX4PNxi/wl+Puxes48vsbtvr7KI+73jyRGXrCCtT5b6zHd+mVrqidg8Hh8j/vo6nSmnorHXt/tq3e143yOZ6UN/fiz0M5RE9S8vuIraPjFlvXZTw9zp8dLloe2rbS1nbPkUuitwRiN0boB7XoS2VhrRERkDEppcil03on4xhrmZSWGSIyGoe9ke6NPlj/Lskqr+pGyvpaCdraN08oox1F8syzLE5V+beyrtNfNaYTAGsPSBFPGGGKciTExjh05l5Mif7c/cHmxFZa1MYfzvJCSPllNyTEb1pCxRuPbrOo8L822yTEMA7UUchFbJN8AXNf5Ns9aWdbQREcWo82xR4A1hsM0nfaltCKsEWctJReqkn157+i6HuscSsu5Pn4kSs5YI+e0Urm63HK/P7CuoZ1bEV5prYGK93JuRQC1YK1hHAfWdW3sqow9mMY0x5jQCgGenUcrRSlFxi6M5mK7oVLbOAdYK/O3FxcbmUtFxGZKy2xq5z37w8zmx3+9nOtc5zrXuf7I+mn2Tc+wxJGxeg0aPtQbTdjmDakezSM+bpB/8UEcn6Hqj2zz4/XAU375X57HTOwLCPakba0eMXw/fgxPmdXXW9/H7V4uqZ7erK8fz+eO4slIgnp896t8atv2GZB8jK8fI+Lj449uP1rk2Wzow76P9kwqPMxP9l1HiJGYIiEmLrcbvHMoJVZCxzViyuQiAFpAEs0/VLEZBhZjoFR2uwnvrYhbvIMYUVgO09I8PxvoSRFjNN5aQkwsy8q6Cos6jgMxZQ7TjGrve991AiJb+zumJCR9qRwaS3d1vWU6LMQmnFlWYQurtdQirKX3ckJcA7Ouc232VMYGjFbM8yrMbNeJFdURkBtDqhVrNbWqBwunUhn6XlrUKbMugVqKMIdGE6Ooyq2zlCIXA2PXs5oowE0pUkpobVjWyM3tnp99fX2y1QpBzpezDp2LjBvUgtWGcejlLSoV18n86BHQ9n0nQLKB5fvdAa0QT1EvoqQYE4d5oZbKsoRmhQW1fVas7bjfHZiXBYXMB/dDx7qG0/+tHeQ71q51jdYMfU8uhcvmtHCuc53rXOf6y9RPAqKft0F69KN69MOP4p6nSOflZp8DTG8BtNd2+uXg8vMG1PVthvGzaz46ojcZ4mcDAqd/Xu7wCVh+8tKeLv6UoHytz/7oec/B4nM8Wx9v+7nLj/py+foMeL5GQT962sunV1LKTJMow52xTMvCLib6zmOUCJSmaWEcZYXNOJyETd45mS2MkTDPxBjEwsfYBhDVqR2dS+EwzSKosYZcpB1/e7fj+uqC7VbmM49rhxgEaF54bu92dM3/cug7nHPt+AshpgfWuIqA5+hbaq3FGoPeaj7d3J9ET7UUxmEEVVnWlZjEukoBfd9DrSIiamxp3/ciDooR6xzeN+U9CMvaxhKstVjnGpuYWMOKd56ci8ycVsU0LRirm5WS4927K9YlsMxrs9ASxb41hq7zHA4zyyJK9I8fb3n37gpoc71JZmXHoW/zlwtcyudHa82aVmKUWdG+66hUwiKCKG1k3GGzGbm7351GFAA244CLlmmaGceeECL/8ttvef/umu1G2u7Hz0JY40m49e76qjHiIlBKWWzBjM5kY5q1U8+8LLif8LvjXOc617nO9dPqJwDR11viRzxRn7TTnwIl9ejWid1T+rTlH1efM4z6MYT4OUD9ZSD0tFLrhtdnTz8CznrsbT86fS9Z0cfA7K3xh2dM6Redts+fh/roP5Is9PJpRwD6YnePX0+tL3HlI7R+bKsfgeYjvvW01tGH8zV+t1LR1qKMJZbC/vbA1cWWcehZ18DhsBBjpuscyxpwxzb1GppSW2YTQQDpsgZyLlAToYrYyFlLbcpxbexpzzSxzGbsORxm7ncHvnp/TWkpRJ131Db76L3j6uqSu/sdQyfzqNJStnjvSCmeRgUEmIp4hypWQVELmP7Z1+9Y10BMkc45YsqEmBiHvrGDHSEEDoeJ7cWGrveENYol0bLinLTVU4zUIi3nWhERT0p4JyME6xrQSnN1tYVJPDytNdKW3jhCzOIt2nsO83Jq21+/u2RdV5YlAIWUC4OzXF5u2W5H5nnl9u6e/X7CO4dRilSkZX707yxMMnpRKrUK+7quYq2UshzzEUTnktkf9ry7uuLqckvOwpp771kbCO97EVJdXmzoOs+6LqQUT3OjSimql/c0l8zHT7dYI3ZdX391za5KkICMUMgnMMbI5cXmgVk/17nOda5z/dlL1S/JXwJuP33P52cz32DrfqTR/nZ9rtX+FIx9WYTeW0DzKTR6fZtne37rjKlXbz7ZtRz3l4Deh02eEsyP5iZ/7HU/HyR9WOTF+IF6PFugnrfZn9UjkHkEkKcnvrLN8ef6+FxXqCfke7rrGSMrKD/Oew6//zXf/X/+3/zHX3/Dd+qSpLtTMpJ3jhACWmtJ46kwjv2Jfawg8ZRaxFfOimF6rRW0zHz23uO8p9bKsqwnlbuzDwp6pRTzuqIRFs86y9B30s5uSve+79jtD0jUpmUNEaMVrkVbhjWePD1zaUr/ZlJfSiHESN939I1h9J1HoVjW9SS6qqWijVhHWWsF2JZKKhlQ7PcHhr4T26gm6jnOkkqspkSPLvPCsq4opfFewHdojgTD0KOU2FHJeU3CqDZ/2X4YuNiMTPPCNM/YxiLOS+DqYts8PAWslyYSWsLKL77+qp1LLWC8uQ7Yo59pLk2EJWzl4bi20czzwuXlhaRmpdQuMAoppxOovLq6IiWJFV1aclNqvqybcZA1p5n73Z6ry4vGiuuTe4F1lsNhIqfCOA5cX19SSj5HfJ7rXOc61x9RXwIxfwIQ/eFLd3tc+gu3/7F13l7riwHZk/XeAqI/ts3TY3kaY/lan/lxPQZfL/fzCKu9/lQ4if5fP57X2eoXi7T7RYP06BjUcd+Pj+uN1/MMYL5lz/Qa2H04rPoUdJ4OT1FLoeZEmvfMP/yWu1/9PXe/+o+k+x8gR6o13EfDD1xx2PySxfRUJbObx90dppmucxhtQCkxdDeacRzIuWC0AA+lNVqpRy1yL8xlTK1FLUIZmjreNiFUiGJ3FELCO8d2OwKV/UHskUoVUFOLdAmct6xrU6l7J2MCPIiphqEjpXJi9xTgvTvNWMqMphjt51SIMeK8FXuqxsw6Z1lCoO+704iC1pysn7QRv9GSZebyqPb3zhGzKNuPn88YIkorAeSNUYwpy+vSwpiGGLm6vMBaeW25yEVFzhlVYXuxIefCuq4yq2nk+I6zrH3X4Zzl081dM8svfP3uGm00azg6IRhiTixr4Ot379jvp9MIQgjhdDFqrFhVzXM4jS70fUfKudk51dOYhTMWYw0V+OHDRzbjwOV2e3pfrbUoYGnvlzGGr79+x3/9v/xfv/59+II6A9Fznetc/1brL5w1/0dAzh/Day82/pEtftIv+Le2VV+4zXMG8cee81CvsY8/hRT9kUN5ZYfPAd7Dzp4MTBwB6JtK92fLPRaEPcKjT0Hss5+fqJ2enQkFVAGfJQXSvGP9+B37b/4L+9/9Z9YP3xCng7TOnaFoS8qZC525tp+Y08ytes9HLoj6AuU9pYJzThg3oLYZzJQy87TgO9esR1UTHWU2Y0/OD/ZLXdeRchKRTUzkltyjvG+RmaImH4cHo/qu83SdI6bYGMjSUo0yOYvf5TE+0zlDLQICxTpIsWnRlUejdaAxsRJrqpuXZdc5nDPkWjBKU7XYOs1rY/9iJLeZzqYQI+fC4bBv4h2L1lpAbmNWdVUMfd9ERZI0pLVGqxYYgPiwpqY+Bzn2wySRp13nMVozN8FWSgkU9H2HaRGg2igZpQiS0HR7L/O2V5cX3O12zGllmme89zjrGpNd0Sg667m739F52Q8K+kEy4KdppgRhloeho8cT13h6L1PK1FJONlm5FOKacNbx/t01h8PEvK5YY3FOnBS8c81aS5NS4dOn29e+Zec617nOda4/Q/1JQPRt1u0z6EodJ0VfgpoXxORn1vjsofxF6mEaVgjI5wfxGUbyM8f25KydWvevPP5ES/TWvutLDPrsmNRJaPTaYb2FcuvpnxesbH3t8frshTxbUxzYSWEh7e9Yb//A8sNvmL7/FeHmO/K0p+SEKgU/iF0RRqMBU4WxUkrR1cR7f8e/Hwq3Fj7lLbtsiQpiToxdT4iRtbF98pY1tXkzMzfGULK099caCOtKCJLCI/6RYmS/BpkxNcdYUQVhkRlEFKdWdIgJoxUhwGbs6bqOpc2qHkVDx5a6PkZ+pkg5ZEp784zROGdJqbQ4TzG6R7fvTZvnTSXTOfETtaVAFVGVQrFGmf90jQnt++40clCrtPdLKZDl+yhqeNWAo/x/HHtiFMbTe4d1Dtos5RHollxYV2FiUdLSz23sIYTYnA7E6F/8TYF2PDKvKgbzx+9UCOHE8FprUM2aKWUB/LbvWNaVCozj0GZLV3IpTPOC1kospZrYq+u8xL429lscDAb2+4lS4erygsMk7f9aZCwAYJ5mcslst1tsMa9+m851rnOd61x/ev1JQPRpw/eN+5oXpToNSD7ixdSjJx1HDX+MIXyMlV7b9iexrm/XU4P8x7OPL2680mF+emBP2dPXkeLnrJU+z2y/8eCb57FBxcdiohcjA7zyop6v8exEvzgvzy5SlDCfaTmw3n8gfPqW9ePvWD7+jnD3A3k5UFs2upizW5QX8UjN0vYVU3fQxuLHDtt7/GZDvx34K6XY7XfczZXfLIUPeaDqHq0lwvM472itMGNHdbxpQK1S6bwTk/Q1kFMmRgFWx1eSc25KdmEmvXfsDxMgxvqdF+9O68R/MucscZvI7KVWkuGesoDOzdDTKU9tjFxIsUWJChOnlWIce/Qiiv7DPIn3Z0yYFuspGekOlKQ7xZyoubKuhfvpwHYzshl7vHcnNnNdA/OyiCK9qKbsrw0sN1/QlvJ0BIxHEZQC1hDbjKbGN5ZSrhU0UDANwAPUQgOkwhqDIsVw8nK11lErp9Sl2uy7csmQhFXVWsMa0E7JGkqsufb7A9vtRo67BQpM80r2+UEgFjMxZpQSIVbnPcZYhmHgMM1orRn67mQNdnRncM5REyzLSt91b32ZznWuc53rXH9i/UQg+hwoPaIwXwhYnj3trZift3bxvF5hS59AoS9lU99a9wuO4UhGqi9Cu28h5mcDoS/2/3Ru9IsP7vjsV573vHX+9MEHw3EhpeS4n+LKI0yVPnx9BWyqx5u21vcpfnNdWD5+w/SHf2H94beEu+/IhxvyOlOyzEmWlIGK6VwDMvJCtBGwlUNCO8f4fkt/dYUfO5TW1JwpYSXMC2U/McbAv9fwMz1wGw/clpF7M5KVxbXP5hrF/zKnAsSTsOl48lyzUhIhTCanQtdZSougdE78N5UWYKR4ZHJvZP7wGNF5ZAXlnMgJOrbfrdYMw4BJCW00XjlKi7csOVO1Iq3pZNekrdglhZgY7cNYwJHJzPmhXb/djk1klMlFkpYkllPT932bnSykpkCXqFNhQrXWlAYIj/ZSSkGKD6r6YwxorZJUdfz3KIw6CpUqIpKKSeJTrTGneFBJdnJtHEIiUksuLCGczOiPoQPWmmZOH+k6scWapoUYIqYZ3UscqFhqpZSkXd8POGdP8a2lRa52nYxZhBhPkZ4yQmDQxjA4S1c9u92BEMNnv3PnOte5znWuP77+jK35ds8Lf6MfJec+12n+3K7+PN34V8g9+Pz86eNEd9n2dIsHavf5Tn6EZDweSFviJQv6Ol38wtP00Tk9AdA36OrHkaFPdvf64bftH7XdHxPFxwPRBqU1JUWWT99z+PZXrN/9I8v3/0Laf6KmFUqhQEspqmgKzjvM0Ek+eLM0qrlivMOMHdr3uH7AdxZKIsVE2O9Z9xM1R6iVkhMpF3TObPNKn295j+VWbfnk3nOwWxJivo4FpVs0ZwOmupmzKw0aTakitgFFjOoEZGo1aC1gB+ppJvUEZpSi7zzTvJwAqFgdVfpO2Ml1WZnn5bT9oTGr+tFxHN+Zo/jJKEN10lZPOZ/Sn1LOLbK0StJUkvM5jBI1WnIBzQkQe+uIx/lRJYAxlxVn3SnOspbSzO4LKWV635GtMLlGG2GtlWpKd5nDTFlsmKZplmSjNitrjKJWwzwvbDbjybszNzW7s1YEZLk+yY/3XmZDh76j64Q5DSmiW1JW17lT0hNVZoMvLjbElE4ipTWsGGPRSlwKjFYsy3I61pwy2mgG11NqJcVMCEEiVI3sJ8b04nt3rnOd61zn+vPUHwlEX4KiL0kN+qL6Ka31Z93fP7q+cH8vD+1tYPg5AP54zlImFxSPQehnD6iexuk+t/Bbd7ysNnqg3tz0yIbWxz8+OxCFspaaM+vtB25+/Q/c/ervmf7wK9LhFqczzmnIhZIypYK2wjx1g8f2Dtd5tBUVeM2iYs8l4/yW4d3X+M1IDYEwHZg/3VBSBBQlRMISmiglo4HabIw6q+hqZKPu+bleuUsd34QtH9gyJ0PvHWiwrS2bcjkpp7WqeG9ZFrkqSFkiRUspJ3atVomEDDG12URpfx/Th47q/M57htbiVg0Qmsa85ZxP9k1HlbdvsaUxCRvqfLOnQjMMvQBLxBD/9HFTovSOMRNi4MpciE+oUVhtT52KFHMbESh4bylFGEdTFPOynI7XGvsQUYoipMTQdVSEURSPVo21zYbKWKi1Afd6YjKhnkCltRKXOgy9sJshnWZxj1GrWkvAwDTNYte03VLbesYYDtNMipmul9nhGBOHaUKhxDGgzd4qKw4DpRTWVVwUvBPbrt3+wOXlhpSSKPSBrNWpG5BLxeSC8f4Eis91rnOd61x/mfqJQPQ5FHtAQ4/nPj9HaL6JF/8UIPl8Z59b/08EyurFrbdf2eNHPmvL+eLGG9u9sohcADxx6Hy51hMm9OGojnO7T+ZD32Ken7wYhE5UGlQl7m/49F/+npt//B/YffMPxPsbKFkyCzRoZzE4Yf+8w3cON/T47YCWGB9KzOQQyTET10hOAu5yuqHUxHi5Zb3fU3KmxEKKkbhG0izznFSFsmA6i+vEsogi/y8pU3f3uCnyi1C48Ffcj1+x+l9wiJppPtB5R+dF2HI0du+0Z7sZmOf11PqmtZeFqRSLoZIlrWfJK12zXTq2tI9nUJ7ffE1b1nrKGa2VsJvN6D4GAbrOO8i0VCJh5HIp5JRxzrLfTzgvWffrujIOHaDw1pJLJseE0ZppWnAuc9HslEqVfVtnGmDWVCpd3+E7RwiSGHUE2jkXrBMv1WxzYzgFLMosbTmxotZZVBtfeJj3bJ/RWk6G9sZoYhSQOC+LjEmUwm4/Ya3hYjvS9577+wM5Z8axlxa+Unj/AEBNa+n3fUcIkpo0TXOb9TVUXRrbm1lWmQHuuk4EXUpRiyQzHUVk8nozfeeb8CwwjD3DMHz+i3muc53rXOf6o+uPYETfaj+/tuUX0pt/lh77o+WaF+MT2vBNtlA9u6c+u5cX2x23frrCs9Sl+nK7zxzx5x99BV2+dFxq+3lsTA/UFsWpan2GJZ8uUNsa6rXjfTT8qaSfTV4OHP7wKz79w3/g0z/8d0w//IGaEsY7rNMY7bCdxRmN1gqlDXbs6a62OG+hMaM5V+IciPMqTKbS4nnpHW7ssV5DqUzffxIgFjPrbmFdAtTa2tMy36idQVlh++KaUKUyH1bWJQlrp2Dwhit/4N8PhexWvvVf8087y81dYLsRcBNTolcd8TA3IYtEQGqlMFphmwfnkbk9so2Hw8w8zbx7d8Uw9EzTLBZMWklmfDuNtVbGYSDnzN3dnmEQttTWepotTTGx309opbi02yaeSqxL4GK7oe/kOcZKLjrIGPaxZR9SYhwHfMlM0wxA13UYbRo4FbuizWY4JRrJfTLTaY0hRGlx55TwXgBu572MphRhkVGcQOduP3F1sRFPVx7GW2oV0c9uN+GcZRg6Ou+JPpFS4uPNLdvthl/8/D3zvEorXMHV5ZZ5Xk4iM9d1uMbUKgSYmyLAOKYktlpasZ/Eb/TiYiMgU4mNFlTud/uTIb53jpQqFxdbQOZ8tTFQyymBK0ZR9p/rXOc617n+MvVHGNo/sG+fWfaPPJzXwOHT6NCnWz8GjerJvQ/3vcVYPgNizxjE1/f4FFi/ZDyf7+uN+cxX1np+ZE/41hfir0fzpM/38yrMfGMvjwFrfXTeTjs/gluxvilpZfn4e27+6b/j5j//t+y/+y3rYUYpg+0tVmmcNfjeo7TGOIN2Fr8Z8JsB42QwM6+BtARiSMQlULK01LWXFr3r7AncQGHdTcy7hTCvxFgwgHUCVm3vsFajraVUiIeJMC2EVMlJ2uoowCjs4Ok3ndgC1QIpkULkPnr+UK/4Vl8T/ZYQAleXWwGPza5IGxHLaKWE+UM1tbgiNB/RECLLsjAvK33vmyempZT60I6OMldqjMU5yzTPLEug8zJnqrR4dBqjqQU+fLqV1rkWBfuxxDi/WTChsNaSc+IwzVxdbvnw4ZZx7MW2aV2bOb3m8mJDLg/pXAJAxTPz8cTw8XU/Zh+V1ixNPS/sqXiCOiugFgVWi9XRNEssZiml+YlK5OoxJ/4YJJBTJpVMrbDdjM3zNZ38SMdhwNg2h1rryQd1v5/w3pFL4erqAqMN8zSjtKRETdNCRYRnMYqnqIx7iACqlsIw9KcQAe+ceKmmdLqQPbKpQ9/zv/pv/rc/+o16q86G9uc617n+rdZfJFnpKfh7euu5GObtvb71+HOW8TGOe631/bDIk/b3oye/bTz/CruoZD9PRDxvznw+AnxvnsLnnPDz/vZb6/HK449WqEc/0Jfrvpl09OjmC5haH7+v6gGN1kpJgXD7Lbvf/I/c//rv2X3zzyz3dxhrME7scajgOy9ze9pgekc3DrjOoUyzY1KaFDPrYSGvgRyiJA9pjbaafjvixx5KIYdEroWaC8tuIq+RUsTHU2uD6y3aHEVRIkrJKbFMKyVmXN+ALCL+6TY9tu+oCtIaSfNCipG0rtR8PBea4DZ8Gn7BH7hgrh7XCRt6mGa8cwL+SjlZPzlrT76iprXotRHPzBgCpdRTez6XQt95rLOnGU9rDd577ncH5nnBN4BnW3SlzHDKzKJCbIVQir6NEBhr6BozOh3EXF5p1WYtFbUJeRSKnHNLhBK1/zj0MhcbM8sasFafUpKE6VQn54AYI0aLIb/SAiBTlMx7abuL12qMkc1moKRCVZBjprZEqKHv0UaAbMqJzSj574fDxDQtrGGl7zuGvqdWTkr3nAtXl1vWVQBjqZXtdsO6Bj7d3Mo5c46+63j37pIPH28IIfH+3RVaa+ZlIZdyArBH8dkyr8Lwdp6+801MBn3vSSnjmxDqU8uk/z/9n/8vr34fv6TOQPRc5zrXv9X6Mycrtdbs59jOxzjrxUxmPa3w2ac/o1vV4wcUHPXqqt16A8++ckivw8HTjTZt8MLj9LXjO/70o39fnkPlVw7w+X1vvWevuBG8fJ31tN1rrPXj0YPTBvXhfZUc+0wJgXi45fC7/8ztP/13HH7/z5Q4I86Slq/+9q/ZXF2gjWG+uyctC8pY7OAxzqKtRZVKDYlUoSpNCgIAS8igNX7ToY2i2wxY76AU4jQRl0iBk2UTWRg/13VYp7HeorQihcy6n8mt9a2UFhB3MWKcgWYgbzqHVpDXKEzpspBjoqIoCbRzGC/HPHrDO/WRf6cOfDTXfBNGgh4xRnN3v8dcX6C1zFbWltsOUGolNzFNbd6k3rsG4lKLpXRtJlRY1FwKh8NMKZVxHGRWNDXj+iofxsM0Mw4DWoE19qHtHiUBqW8Z8NM0S+RlLWw2IwpIMYn/ZYu+Oirqa1WgKs6KIEpp1Yzrkwi+AKWl3X90ATBGk0oW1bnSbcYVDoeJzvt2/MJYjv0g2fLThOsakE6SNX9MlzqyuVDFJ9VouuDQxkj8Ziks68o4DCzrwm5/YGhCpGVZubvbMQ4dfWOhS6kSUYr4kXa958OnT2w3W1DqdBHU9wbnPDFGLi5GpnkRVjcVNpuBu/sdIEB9nguXl1v+9m9+ycePN298Kc91rnOd61x/an05EP3xfvzr2zbAVJ8/frz52Dj+C7hZ9Wyjx235Izvz5MGGHutpJ88O9fWByJeA+cWG6rN48iUKfBu4Ptg6PQXXp3PzdK9tJvHxzp4ewOn5zzdRj+88Hr+ilkwJM2F/w/z977j/7X/i8O0/sd5+QKmKHwc2V1/hh4FhM+IHAQ+lVrqLkXWaoBaUMeQlkqKAyJKaAj4Li2i9w11u8dsB4w01ZUrMxGkhTIFwmKm5oDsram/fFNAFjDdo27LS10SJqRnfi9DEWg1G44YO48Tqp6REWlbSuhLnlXwEVq6tO8jcqm5eoNpojDZc956/HhT/VVj41e3Cd8Ggvdj+aOsYOkkRSi1BCJScj1Ik//14hhVorbBGWu1rEMN6UZsblJfZya6976b5c+Yia8oMY8Jay7wszXBdGLYjy2mSZhx6vBOj++N8pbXHOU3IRVraxopZv2pzsMZYjBE7K60Vznl2+0mSlJw7xXZqrVqsKTjryKmQUmzWRpF1le1yydxrxdXVJX3XySexguo0MQRSzmJTpUQkZJrPqTUW0xtCEPeDznu0FoHUdjOyrIH9Yeb9uyuZFXW2+bk6xrGXsYSUMdagopZ2vHWs64qzwp7HnLi7WxjHoVlNyTHEGPl4c0ethaGXY7bWsswrNzd3OGsZz2Klc53rXOf6i9WXA9EjiHtt7PKtjvMTTPjjIFC9ge2eDS4+fa56Ck4bAfT5OrGGz5rtjxjXz3THHx3HW+MCT1/tCWg+espLIPl8vy8Z3Ic7Cq8j/EdU9Gsn4bR/Rc2ZvOxZ7z+yfPw9h9//E/tvf8Vy8wOqJlznufz6HcPFhn7ssd6JvVKFnBJxXai1gNZoY8kpkZbIej8LCM0CDKwz+KHDdg7b+9bCLoTbA+uyktZMCUnGDbTGDDLzeTLWL5WcE2nJ1FKpKYMS0Kia0bvzFtvZEzhb9hN5Xam1kGNCIWbrYsauUUZjB3lNKIX2Hm0szgtoyTGxzIE0Tby7u6d+OHDRXTFf/RX3ekMqBmMcykjkZ4xRhEz2aPUjIiqUEqGSFXB0fM+ds9Qi0ZhKSWqStOJdm2WsTVmeTnOa1tqT4h4lhvklF1JOGB4Sg2oLKND6eImmToCyQ1TxkvjU03ee2IztS4v89M4SQhC2s/PND1TmYK0TNrrvJUxgXla0EVCbS8Z7mRudprl5m4ogyCIjDLnNi5ZaWENkM/aoIq/vGHuKgtDOp1g2yfF7Z0/nq5TaxhvqyQaq7zpijCeWtPNyMZJbilXfee5DZF5Whr7jMC0UJzOjlxdbaqlM84J3DmcVw9CzLAvLsp5b6+c617nO9ResnyYHfa3X+2ob/vHtt6lU9Yp55WOG8616g8R8ysKe9vH0jlfnFdSzedAXi75CKx7b+I9GNR9iM9848M++rMdM5hNOk+fg8vF/Fa/d9+iIH73+WhJp2rF++o7Dd//C9MNvmH/4hnD/kZqCgM/3l/TbkW4z0o29pBcVafmXUsk5NpslEZrENVFWAZ45ZWou2M7RbXucty0lCUpMpDmwxkSYFuIcoXk32s5inMU20FPbWsthIa0BSkUZ8To1zmB7h/YCajVi2J6WQAqRuK6ULO+LsQZjJbNctwxxbS3aOdw44MYO4/yJQY3zxOF2x/7TPcs0yQxpKWxGz8+vDcPPC7OtfJwD3+4Su2QlN33oCeuD6CXm3JJ9RJRznG9USjWngCx57S3d53jZklLGe01uCn2lhflMMaG0ADBtZD61Vmkhp5RbFr1qSUbCyjrrxPg+JbSRTPt5WVHIhcSyrGIXFRPGWvrekVKWeEsvVknTtND3ns1mhPZ+i/pfwLSwwkmSp7xHKVgfeXOaJlyS19s+RwbGoafkSozpZJ10DAvw1lKzWDst63ryGD0mQSl9VMCrxvYKED3OR4+d5zDPhENsAjAZ0VAotuPAMelJP+qeWGMoSs7husqxe++acCrzym+cc53rXOc615+pfhoQfasV/SXDmq/WayDvc/t/1pZv7OcToc2LVd7ex2MT/reP9PnM5QPYfPtl19MGryUfPZnVfLarV/Xur44byP3HFvCTNVQTSChNrZk837N8/IbDt//M4Q//wvTh9yw3H6kl0fWe7eWW4eLndJsB571Y2GhFKZk4B6Fya5Xc8HVlnVbStJLmlRwT2hq6zUh/Kbng3XbAeivq+DUTpok0i3inJImutEOH6127jqmiqKfKHOe0koIo2qFivcV3Hjt4rBMmkgolRsK6EhZRY2sEXBirUVqhjW2spMF4j+073NBjnMOPA7rz5FSY73ccbu6Ybu9YD2KY7jvP5c+/Zri+oht6bNdhO89VClyke8Zy4ENwfIpb9noDtqOUB3P6XAopZox5AJ/e++YnKgIrreUTG9p8o1JtNjYXyUY/muMbaWErRKx1BG3ydottWC6ZXItcMORCVkm8NKmEINZMWsvcJ1XSmuLREipEivcCQI0mhsg4SjSmRJQuKKCo2sYRoJQss7CDtLdDA5XaZBk3aK+1lnpKqxLvzsKyBGwTLgnQtByBpajePaUWfPJNoFTo+o4YIlorShFweUzFUgrmZWHoO0IIdJ0X4VU7jlxkRtUag++EdTZ6kPOshUVXWjOOPfOynOys+r6j73sO8/zat/xc5zrXuc71Z6g/MWv+ePdbg5GfAZYnQPWFba9XmMyHuz63xpuw78U2L9Z+TpO+0qJ7Mr/5bHazPj4vz0HmcbuT1+LzY3iK8E/DBPVHhmm1KNTzumf58FsO3/wX9t/9ivnjd4S7G0qO2M5x9dUlw8WWbrvBdV3LD5e89EyBlMkxU3IlrSvrvFKWxLSbKG2m0HrL5t0FbujwQ4d2lryukDLTfmbdz6Q1nGY5jbd0Vxu0s6hcKDlBLdSUmaeFuARylJlSpRV+sPihwx/b6LWS1kBaEhhFPYI2ozDGompFI2p6hUIZYT/9ZqTbDrhe5kfRIp66+c133H//iXCYQBW0qvTbDeP79wJAx0FmPkshLAv7D5+Iuz3rYcIvgZ9XGOMfuIme/favyBc/45BEuCT2lSJKqqWC1uSc0NqJFRFIex+ELawifErHDPhUAZkJddqii6jVj5GW4o8J/ih+OrKiJXO/27PdjCidT3OlYY3UNjJgrCHM6WS9dExxUlrReUfJmcM0ncYJ1nVtXqWV/X7CGH0y7T+a3hstqvsQAt57cs5MKVGqWFcNzT8059KAbD0BTrFlMpTyIKyyxnC53YhFVc6s63ry9uy8w3svYxVaU0pmWaO00bUmhMDlxfY0GpKDmPgr3YBr+z567xjH4eQtqhRsxrHZR4nlE7VK6MK5znWuc53rL1J/QsQnfAkAfFuh8xOf87jdjnoQQjx5rM0VPl/qBS35VLcj/z4/INVw4nN51GfqMQh9NqfwZUC4/Vsf6NMnx/YGzq9KgF6NkfXu9xx+95+4/5e/Z//db4mHHZDR1jBcbNheX9FfNPBpFEcz9nJkV5vHZgyZ6XbHcj+LACmsVMRDc/P+gm4rvqCqPYdSWW73TDd7mWPMhVwr2mn80NFdDOgGitJ+oiLsXs6VZQrkJVCKzPP5bc94MWK7Dm00tWTyGlnnhZJam9cojFXY3guwUIoa02lu1Q0D/dUlfhxxQ48ymhwih0933P/wif3HW2IzxXe9Y/vVNZv31wzX15iuRztLjYlwmFnv7wn7AzkE0rySQmQNibhGdCr83Fm+PsxM87fsxp+x2/wS/MAaVjTSek4pE4Io6L33J19LYwzOGSqa1FhF72XWNOfjHCltftSzhsC6yjymaYbyMUYR/GiNczKOENq5EPso1Qz9haHs+66NCRTxVzUiDJJZzyKCICVscs7h9HGz1rLdiPdprZUY82kc4dg+T0lsnXRLWdofJkopTPNC13w/tdZYJ8zk4TCd4kCVUqRcKFRilnM19B1Vi5dpLU3tn0tzLJD5UdNM63WLTgW43+1ZlkC92DTGU4F3DP0AtbLfH/j2dz/wd3/zy/YeSJBACIEK7Xig1OO+znWuc53rXH+J+on2TW/Va8Ojf+xax8efi6M+D07lWZ/tsb88gvoKQFQv2/tHLFt5gXkf1vpiuPoIFNfXZ1Yrz7KtG9p+GIEV4IXS1JIIN9+x/+1/4vbX/wPzh9+S5/0JsA3bkYt3l/QXW4wX0Kao1ByJMaO7HhmYk9e47mbmmzuW+wNhWak5YzvP+PU7uk2PdxrbeZQRFi7OgXQ/kdaWjlRBGYu/7PCjkzjMWqlZhEM5F3KMIn5q7fO67ZlyIu1XASKqqeSdJUwzy+FAyUdVu0VZ3cCDpDahBIwXY7De019u8cOA6TuUc4Q1cP/N99x/9z3LzR1plVa4tppu03H1t3/F9V//Ndb7k9p+ubllvbslzQs1V2m1h8g8L6xzFK/M9lqNt2wuO65tResbFhf5gffcdtfcrgVrNLpKXjpJ3u+u8zLDWSsxpQcVeWN5jTbkWnBOQGnJ0kr31kpLPQhzbFqmeopry1o3sj8lM6LH2UljTWP2FCEEEVMVCE0ANI49MUnWvTbSKnfO4qxlmmbWEEhZ03ddYy/L6aN5bI9XEPsoJSIupRRDL+3uvinSj6b22814CgaY5om+74gpU3I5mf/XWlnWQN91bJrZ/TwvJ5ZW6wcRl/iaugbqPePQ86nccZhmsbFCSUpTSPR9x8V2g3NOrLBOcaHdyV5rjomSK9uLDdO8fuF3+1znOte5zvVT6yeKldQX4K3PMaH15U+PNlcvHlXtj+lj0dFnDuAVUvMJ01lf2fjR4yd17BNw+PTA6hP0+ZpK6/Euns+XPt7y2f6fbPDydSoqbdAOaiUebtj97h+4/Yf/lum7fyYcbqVVaS3WdVz94orN5SXd2KObv2VOIgLStim6jbRhw35lvt0x39yLiKi1u/uxY3x/Qbcd0QpcP5BTYP50RzgsxFigVLRRaGfpr7b4scdohXZGREerzHqWGEXMhNgn5VSI84HlMBODANiqZC2jlTCgZaKWgm1zq0obtG/q9lopKUEpKGvptxv8OGI6mQEtWjPf77n95lfsf/hEmBasM2ig23S4zqGtwShFut+x098yvHsvava7W+J+Or016xpYDzIbixIrI9uLUr/bDvi2Xknyerv5jqubb7Crxm9/yf3FX6O6LcZYUWKvYtR+BIelFO7vpZ1+bE2v68ow9IRSMFqxhtBYTo+zhqrFvzSEiHOGEFJTmUv8qDWGWCXFqdZ6EhnppsCPWcDXeHUhzgJKo1URdl2J6j6HRIETe5tiIhkrLfWmtD/6d6IU0zSf2vnG2nahJwzwsawx6MbSKqVw3tCVDmMsQz+QcmKe18a0WjonNkwxJTZFcuGPYwnHlCYQlfu6BsbRoFNmGDou04aYUhNuSUqS0krSrGbFxeWWnBLOWm5u7vFOjksspJyMOdzv+Ktffv369/tc5zrXuc71J9dPs296EwM+nWeUe56yk2+OWX2uc1+fg9CXG72Eto9R42tzl8e7X0Otj29LuOjr6zxd7+ldr29bHz3+7ChfPu2x56j0sKlU8rRj//t/5PYf/wO3//z3LLcf0Aq08/ihZ7zcsrl+R38xYr07KaTneU+OCdt10s7Virhmlt3M/vtPxGlBVYXW4DrDcHXJcLXFe4vSlrDbkZUiTAvTzZ4cRKBkOyeq9N7hhmYflBJpXshBRDphXslLONkQVVXY394RV2lxp1TEq7TzdEOH73u0cahahVkbHBhJBxIRUlNZN6GM6ztc58FoKpqwRg7f/cDdDzdMn24xluaRaXC9w9kGhLRCVxkrMJ2HWpg/fniY5dWK+W7PcgjUAjFEFLSZVUd3ucGNYkullCbHSJxnDrcTYQ7knLgaHVf19+xvf+Deved+/CWqv5AM95IhQchZPCyHgTXIefLe0Xl/shqSF6zwcAJ+Aiq1gKzmgRliYl1XMXB/9PmJKXHEi9YajsKgUET8o5SipISqsv79fuXyYsNmHEixsK4rm82IMYZpXhibV6qzprkB0KyeOpZlJcTIzc0dF1sB1kdRllYiIqPCDx8/8bd/81d0nWUNUay2csYawzD0HKaJNQR85/FOWvq7/QGtDdfXlyzLQq2V/bzSd2KqH1Piw4cb8QcNkRAid7s9fSfm9+u6tjQoAZvLsnA4LFxdbbm+vjyeZrx3DEPXIkwL33734Y3v/7nOda5znetPrZ9maP/THnh7qWek6UuP0QeE+UBSPmYuX+MM6wlgvg56H0nYHyPY10CuglpfW+RLZmNfbv3ivkdq96dg98igKlTzjMzLnuWHb/j4X/4D97/+j8wfv4WSMc4zXm7pt1uGyy2byy3Gysxm1Yp1tyM25q2WAiULM5kK892OZbc2RjGLiGjbM15vGLYj2oiFUkUT5oUwRZadsJMyf9ljB4frLFoZOeyYWfaS711zISeZ6YshirVTzuSYiCEQV2l1lgrWOcZNz7gZMU04g5LceWO1GNWXQs3yBO0NfrvFD6NYMtVKyYl5v3D//Semj5+Iy0wp4JzDDe4k0NFIyo7I6xFWtBe2NYeExM8X1v3EOi/kWHDGoRy43jF+dc3Fz645iqaUljlX7Rzz3YF1knZxv+1AOxkziImuTLzf7xj337K/+jt227/idsqEkthuBmIWI/rOi5Bpt1vZbDYYoyVdaewB6Lyn84gNk1KsObCUlU2zJVrDijVGgL2XWcrS7KGUFoBFbRnvJ8W4bGONQSvNxWbDZjO2drdEilrnuLvf8dX7K6wRNvJosi8WVZrbux3GiFG/s4bsHIdpJuciAqijVZKVSM4h9PzjP/0L799d4Z1tIq0KUb7HV5cX5JIJIXKYZpkVrZVKYZlnbLPlApjnlWVdubrcklNmDQFjLVeXkv4VQyTGyNAPWGvYTwdJx5oqm42wrMu6YrSwwcsqowvztLTxBPNF3/dznetc5zrXT68/Uax0LHW69zhhqZBW6x+BU2WFRsC+Sl4+3u3niM3j0Z4WqZ/d7tmzni/w9Dkv0fTzZz1pzb98Xrv5yEu1AjVF8rIj3H7H9M0/8vEf/3vuf/cvhMOM33iG7ZZuHBkvN2yuLzFdRy2ZmjMxxgYAS1Nui6o4hshyvydOQeIZa5U4zMst3dWWfuwx4n1Ezi03/DCz7mZqyo2NtAI+hx43eMkpD5E4L9Tc1NOlUJOYjNckDFeKgbgGShYFtbRtxaPR9x3eOVG9txxzq6ykADkBmdJ699iLAb/dYIcB7b2kJoXI4eae++++Z765I6+BbuzotwPaGFHJNwsh+X9BO4sberSS1nYJmbDMxJQJSyStGVXBestw6bBDz/j+kuH6EtP59h6lk2m/NmJk3/1dz/5yy92335OiXADkJK4DtWrcxYavf/EVlz9/R9aJH3bwH7+N3OwS3XZDKVVM462hAvO8YFpaU4gRq60YrrfZ2hAiSisqhXlZxJlAqabCl3EC7z3OWjGI17rFkxa0VqxrlOx4pcgpk2Km1ELfGEPf+9NH07S5yfv7A7VW5mXh6nKL1UbU9krYUWNEPKW1pD3lIlZOWms6Z8X6qVQ0isuLjfi9IvOrquim8K+n1+GsPY0uHBl1jQiXQowCRo1hGDpKFV9S5yxdJ3nxhxDoe4/RbQ3EW1ahGIaOeV65ub3j3fUltWTWGPHOyvkJAesspUqC07nOda5znesvU3+UfdNnp0BPrKR6eX9jMh93+R+2qo8wWnv+yUPptTo+/pQpfbHNcwD65LHjJo9b9k9eyLNFX7bqTx6mT3Dr6yMBr1lB1VohJ/J6INx9z/LdPzJ/90+sn/5ATSuqFPrLDRdfX7N9d8mw3QqTpxW1SjxjjjKDWat4TmpjMFvfVOeG5W7Pcj+DVmJUfzFivaEbepSCFCMpVklGOizt8IRFNGOHHXvxmLTCGNUWy5lbjnop4vVYciUuq8Q5hkhNmdpGHIx1uNZal5Qj11r7Gqw9qaiVMS0VqKKsxfU9ftyIf2Qt5FKZb++YPnxi/+GGsN+jNVin8d3Qzo2wcmix01JaC/PpjrZHmhITYQkstzsKWpjBlLHO0409w9WG/voCN/btmDQlhOb/aWT0QXuZk1xXpvs9y25PiuKt6npPv+nR3cDmZz9j/OoaZw0lRta7HZfTHf+z9Zbf3hTW8lekzTVzsYR2PlNcsdY2b1GN64XtFoDajOJTbvnxlbBGtBGNfuc8sSYOhxnvbRP+CKAERWnxmLVy8vKU9KXAPC8i1lkWhr5vvp2VzThKelaz3QqhWXg1tfuDMb1YUJljG761wWupxJQftq8a78XuaZqFOb2+vGizq4YEGAxaGzrvSDnTdeLVqpQ6qdxzA6mlFLQxp3a6UpyArda6mf3LRZK04SVs4OPHG/aHmXHo6JolVKc1xopwTCnzx15Ln+tc5zrXub6gvhiIPpjGn+545YfHFOUReVYeE6NvTG0+UJ/taY9B6QsZ02sM5+no6pPbsq06deAfZk+P4PC4Zn2yypv19GnP727rvPGnqwkrqJUSV9J0T7z/QLr/juXDN6wfvyFPtyhV2+zjO1zfY5wXkKEEROScyLmSUzpZy2hnMUYAnet6dOeEMUtF1NI1tznRZh2UkiivVzGPV+3YldUYK0lHrkVzaq0pMRLXSAmRkjIlPghhUkisy8IyL6Q1iVjJaHnntMF5h222QsYKM6eNJCTZ3lGLErBoLabrsH0v+7UOSiYvK+s8Mx8mpts7lvs9eQ3CmjknxvhGWsTqKLYxBuUMGIuyThwDNOQ1isJ/WZnuDqQ1YbueftNh+47+cstwscGN/eliQYKlqsSZCpVKipF1Xplud+w/fmK63aE1+LGju7jg4mfv6MaB7uoaOwzEZWH3ww2Hjzfcf/eB/cc7akm8Vwq3rqjLv2Ief87HUNknw1Ilm77vfJv1fUj4OebXp2ZhZI3BmMphmqnO4n2h1kLnLUsz+zfGMM8LvvNyMUCl7zr200wpBWctfe9PyUJaK2KKDejK7Kj3jkrCmGY0X8QPFECrQj/0p9SoXDLOOYyOIHacrOuK0T0pZ5zWrdUO5RGjrhBQmbO05b13OO9Js1wgOedOMZ+1Hr1TxcdUt7GB4+8M3YB3yolSZZsYE6UUxrHn6uqSmHJLaKpYK7Oz07IIo5uLJEi9OSN+rnOd61zn+lPrJ8yI1kcDm8c71QmgPpm/5JXgybfQ3asK9edg7vlM52v1AEJPrOyLXb3+B+UJUQkvqNX6YsNHB/MKO/qC+VS6gc+FuPtE+PQt683vibffkXYfKGGiloy2lv7yEr8ZsC3CEqXIMZPWQE5RzNCLJMFIProAN9N5AWJHdjcX8hrJIVBCkMxu01EqMju6hsYugXFWgJoxkCJUad/qmon7SIqJEjOpgc+SKzlG8fdMiXVaWOYVFGI23nlMi1e01gj4bTGbWikoRRTr3mGsRzmPdk4AaN+L32hOhP3E9PETy/29zKq2JCcA5yy+cxhn0VrLu63ENF9rLSIi70FrSsqkZZVo0jXKeAKFbuzpNxv8ZmS4GHHj0MRcApJo9kdKtY+EsaQQWHYHpptbptt71sNEyQU/dGy/es/2Z+/FPaCXeNQYIje//Ya77z5w+HhLXFdqylijGL7+mu1X14wXA/3YU3Tidg58c5P4UDo+FSeWSqWwaWpx/WjcIxexdSrGMI79adYxpofozHHsm4l8BfXAqJYG3oa+E1a9+Xt2nTClxuiWZV/wzhFCIEa58BHGWjfmUZ2iN9dFUrisMcwxYYxhHEdylnlhc3UBtLnaZr0UU8Q7xzyvxBDpm+l9iqm126OATipU8S49zpsaLVZVSkGIcp6sMS1FSrfIVId3nkg82T+FsMp75j2/+PnX7PZ7Ss4nFtVlGWeoFWp48FE917nOda5z/fnrJ7Tm1QNh+RioPR2AfHlnfQZeHz31OE/6Ft/wHAC+FDW93PpxmtHplnqyyYt6VZX/Yr6zvvJ8Acz16YayVkMvJQbS7iPLx9+x/PAb4qffkw+fKGEWwOecJAd1nYDPZuKeQmDeT+QQKWtsc3IFZQy26yUrvetEoGQ0VMgxkEOQIzJWDrkWSq3kVMgpUmOmpAhaC4D1Fl2qmMmHQG6xmgC1FNKapLmuNaUW0ipMYFpDu26QVnI3DvRjh9Ua13coYyg5Y5wYr2trJW2oVnAW08lrdX2P8R5jHbTXffi4Y727Y7nbEaZFFOY0JnDopBVvNMY6qtJgDNYJu6qMkVhJo6lVkedA2E2UBmxolkG2l5lT4+Ucamc5WmNJ+74lTTU2NMwr827HfHfPut8TpgWlNOO7KzY//xnj9TVd32GaIn/dH9j98Ind9x9ZdnvyupJiplJwzuOd4eJqZPv+km4zknNmud9R7u64uJ/QUTNwwc5ecKe3HJTCG0vKCedqSzqCOS0s6yJznK1VHkPEOscaVvpO5nArAi6naSHlTO+F/TRWk0slp4y1ts2aCtNpnaU0oY+1lpQSKck4RkqZYejFJiql1vaWOcvNIC39ECNGy7pVVbwRJlNsnwTU5lywg8FYw/4woZTM3BprqLlApc1sJrxzLXY0EZMA3YrMpForbXnI9G2W92iLZYzEhiql6fue3W7PsgYRJVlF10kS1LoGYkqMw/DkW35kic91rnOd61x//vpiIKqekH/19Af6+NizrY+bPasjmFOvP/z23mXrLxOrP+yrPfehHf9l2z+952Uv/oUN/mPEq0RxHu8/Mv3h1yzf/zPp9lvyfE+NKzVLe3y42oo/phPgqZv/Y1xWYe+y+G6SxPvQdR3+YovtvLTqdWsbp0RaZkrJnIyhlKIGeX4Jwn7mlOSPvPe4zYB2BoqwpnFZT2xrySLsETAms59KwTovxGZwn2NGa+iGDtd7MBbrHa731FzljGsNHFvZpZ0ag9v0uM0G43xjY8V+aD3sOXy6Zb69l/nTlKkKjAbnPVo9XLgohQDbzqO9F1a0jQKUEFtWfYRapdWbMyiN2/R0241Ed/adMNUoqqoo56SdT4VcKDm3XPSF+dMty9098/5AnAO269h+/XMufvkzxvfvWnKToYaV+X7Pze//wO233xMOE7pKrKY1Gm/NSWlvvSWvgd0ffuBeG9YlcNjtMYjrw1AVLi9cpxt+2V/yKV6zV+9Zi2bZTyzN2mnoO/aHTAhB7I68ayMKYI2VRKIqoKzvPH3niSmScmrMaMVZR4oyWxlTAkUT7YioLGdp7VNhmkVdHkJkDZHNOOCdbeSxou9FOKS1JqZ8eg9UEwwBpPZZvLjYcDiIDdPQd+SUWdaVQfWn5kiulb4ByZoLoBjHgfXovNDa+OKfKnGg+8Mk86TtO78/zAyl4qyh6zzeO+7u9gxjxw8fPrEZR4ZxEHuqaaHkQ2v1iwDr8mL7I787znWuc53rXH9s/SRGVJ3a5u0e9RqYVC8B44mRfNEsf7bB04dOROVrjOXjTV9Skk8Xemug8ynf+eLW4+fWN49VCftWCulwx/T9r5i++c8sf/g1ZbqHU0qSZI5XoB9HxusraWsCaQ0sk7R4FTIzpxR0Y4/tB5wXv07TD41ljcR5IgfJZldaob2lpiyAIiaJu8wNmGqNv7jAjwJ687yw3N9TQkZpSy6JHBvraAyYSq1ZZvtyIUyrzIWmJGKOTU83dgJ6nEVZK4xpKZgmCFIFAYC1opzFbUe6y0sB30pTtSFNE9PtLdOnG+a7e8IsQFc3uyVjTTNaV9J6L1VM78eOfruR854L1EIOibwm1v1ETsKkKaVQ1uC3G/p3l3QXWwFUJQlQNjIyoJRCGQU5k0MgTjPzdGC53zHf70khkGPBWMf7f/c3XPzVLxguL7BdL238UonzyvzpA3e/+5YP3/yBdQkYrekHL64ERmyolFagDTklpts9BQH+a/NarZ0Aeqc03smsLXriKh8I8YZbc80P/TX7rEm5YC30vSRCbdzIfn/AWkeeZpwTCycQoVJMUeaIrcRvohTLvKJUwjmxjooxEmIidZIlb62kLHkvMZ6llqa816xr4Obmjs57NpsB3znGYRBbJyWCqpSllW7RJ/ZU5koLy7JydbnhMC2knE42VfIrRIznvXesa6DvewGwKLQ+gtEgLGgDvn3nSTGTcpbEKC3A2FhDjJFllVloY0ybKzW4XsRe33//Ea0V79+/E4uqWlnWSIjLCfSe61znOte5/vz1kyM+n4I+1fjGxyIhnuLLNu75SKfD26DxWb2GT9tT3zTI/wn1xsToK/c8vU+1eUSUIq8T07f/xP43f8/yw6/J95+oJUEWUKa8bRY+DexUmG5uJTqzH0jLJHGcRgtz5Bzd5ZZuGDDeodtJKECYF/K6UNZVrIO0PrXMw+2OOC3UUgS8tQQbvxmxQ4+2ljzPhN1BxCFtvrfmIKCvEyCSixisK9122tqj1IoyhmHTM4wDqs0Q5pBRVWM7AY01RKpWVOsw4wZ/sZF0J9fmNWtl2e85/PCB+e6OuKxyJKWgqBhncJ1ryvDGcpbaYiyFtTWS94l3hjxNpNRYNzRaafQgKnB/saG7vsSNg8y/1oqqmWol+lMhfq3UQgmZdXfPdHfLepiJSyBNCyklTD/w7t/9kqu/+1tc50AplHXUVFjv7gh3n0iLzB2O24Gf/dXX7O52eGdxTkD68QMrAQMraQnkImbvS0goremGnm7osC15qCQR1mil6QfNtodfmD1/VxZ+M/d8rNekLCKww36i6zw///lX3N3tseaYVy/57845OnNMREJy2Zt4DJD3HWlza6WkVR0k/tJZxy7u6Tqx7dLaEWNqOfac7JRCjKeW/boGJNHJMK8LnXN0nRcQmGWeeJpkpOCk/A+xCc0Km3GDacA1pcz9rrXYnaOGcnIOsNY28Z54nhZqmxmWi8icEmENlMpJgNQPTmZhqWy3G1LKOO/Y7Q7s9wf6ztH1XWvxe7rubN90rnOd61x/qVL1LQXPs7r99D0Az3AoPP75zfoSsdHzB+uLf56OBzzb7vhTfRCYvDzgV8jR0/zpayvWJ4+oJjyqKbLcfMfhm/+Rw2//R+Ltd5R1aWCjkpPAPNtZbO8Biaw01qCsEWa4LX0Ega7vcP2A7XuJskRmNHMurPf3pGYerqxptjiaWkVRLqBGAKhCYXqPH0V5Xkslr03pXiGHVYzhVRVVeS7NvF3SgJRSwt5ViPNCWBPGehEGNRNxdZxBVUriPbXMY1LF8L67uqR7d3V6LVTIayDsd9z/8IHdx0/kaaG0+T/b1OjWanRrkVMRBlkrqtPUXAlLbHZXGWMNzjk0WkB8SwcyVpKhuqsLzDhwuvrR0h5WyKgAqoH4lFnub5j3e9bDgRRWATVF4zcXXP7NXzN+9Q7bj+KpqsSsf727J9zfkxcB/zKSkcgpUVoKk7SrK8Zb1iWy7A7ENcoMa2OQw5rpBs9wMZ4ETjnJOsoorO+wvVwvlpAoMZ1SqeZi+Kje8737GWyuWZaVi3FAGcWyhDbrWUhJLlqcs5QiZvcKxe39nnfXF2JJpeSC5hihmWJuCngoVKyxjENPRZTrIYQGHCWTPqVMKYUYI33XEXOGysmUv+88fd8xDiNKy3HtdgdhPEMU66QKMUXWEE7q+3fXVwDs91Pbj3itCqur6Tr/4I0aImEVUdKxVS8K/kpKic04yvczF/Z7MbW/urpgXhaoYJ2BUnHO8fHmjhAiv/jZe3Ip/O/+D//HF7+tvrSeW9md61znOte/lfoSiPnTxEq0icvGdD6wmz8uInp9vZc98yfe8afW/5GNfYZ8H9Ojj5Z6AKH1Kah8Nu75eFL1FV736YIlEe4/Mf3+H9n95u9ZP/4W1lnAjVKSztNmC42zGK0xvUPVJvzwHg3NCwiU77C9o7vY4rYjVotVUamFGgLLspBjlFnHUkXVrhRFidgjrwuqZGm/G8k9t97jhw5NJYeVcH8gV2n1lxRRpbS2tyTqzLcHwmERAGdkfrECMWVqESui66trVBWFttKa2qyZjgbpKAFVth9wmxE3jCjrpG2uFHEKxGlPmg6UJIbjm8sLlqqI84rvHN7ZJjCysv8gIAgtxvIqg9v0YBQ1FKzpJSGpIiBUa/HtvNzi+h6lrQDYUlFKmFylNaqZmlfnSDEw//CB6dNHlsOhjR0YjHNs3r9n+/V7hstrdDdQc6KuC2ldSdOeOM8yexsjZJmHLTFQwkrNIihDKYwStvDwwx3rsopv55rQKKwF7xz9+wvGbY8fPZVKioVaNd1m09hXEXDFOZJCOPm1qgJdXPlZ/C1u+Q374ef4d3/H/b5wcbGh7wXYCSMq57NWyZpf5sLl5Za+8/zh+4/8zV/9XIBxLk1gpOl7L4r9lHDWMLdITe/lV4YY62v2hwljTMuYF+DnvMPhmKYZ7xzmwrAsC+sasMbI/GYux2aJtPxLJjRrpYvtBoBPN/fs9gfev7sSNtVqUdrH2GZfxcKs7zuc81hrcdY1Zb9mDRLPWmphmmZSyozjQN95rq4u+MP3H/n1b37P9dVGjP9D+9w7z/XVBWtr72/H8Y3fYec617nOda4/tX4CI/oDz9vvr89Nfgld+vSxp56hb9QjUPkqw9BA8fOpgMfo84XIiAd4fdzowaGpUnIg7m/Z//6fWb79B8LH31DmXTsGmQ2UGdbGVJaK6S3aaihH9lTshlSV2VnT9XTvrumvrkRFrgQwlRAIhwNpnqkt7lBphe06ipa50BoSqArGCGgNSXw6NyPWCsNWksRKlpzJbV7UNLV4zpW4LqyztJ5rrlhv0UahqsRA5rbfYTvih06sc3LBNqU7qrHNtaJ9h9uM+K5He99Oo7TT07qy7vaUdRZAiFwZ5SDiqFoyWqmTur2UpqKOuYlaalPcW5kZ1AaFCH3a7tHG0G039O+useMggqWUxZZKm6bbaoxoTtRaiNPE/vaWw80N6+1EzQmqwgwDF3/7Sy5//jO6cZB9KA3GkkNg+fiBsgZKFeFTjUlmdFMSoB+jiFucoZZCDIl5PxPmFWol10IIYrt1cblhe3WBcRa0wfjGbscsQQKdxziZI01rJK3i4VpjAi2Me27zwOsiDgY1ZpL27C/+mv27v0VfvCcjs7WxJSsZrWV+MkQ2m4HOd+x3EzEnyYUHGSNonp5imO9kTpXKPAdAGMNjWz6XQggBZyylVozWWGdPmfLHDsUxrtO3UYXOe9YQBBwOPdbaNvMpiVB911GpfPh4Q995TLvo6ftePjdaYbTMesYkVkveeWKMp98ROeeTh6p1lmVZpTXfea6vL9nt9uwPE9O08O76Emct+4Mwr8477m53pJT5+c/f89/8b/73b/9u+pE6M6LnOte5/q3Wn5kRfQNQnhDfS3bzR9erj7f68YMVlvSNX+rq4Z96XPcLjaiPgLXmRAkL8XDH8uG3zN/9M/P3vyEebtosoXhoUivaFGwT62jbUmRyA7tJ2upKyx924zx+3OIuNrjNgLEiBKkxE+cDYb8jTjNpjRirMV2HsuL1KG1zMYk3zlCrRmsRCPlhQGuFMkYiGmOmrJFMoZ4Uy5WYE2kJ4sMZ1mYJq9BOQKN2BmsEcKimFDbOAArrm/+n0Q1za3TnscOAGwZRvee275xJ60KcDuR5ltOv26xiaPtOBW0tFEhVWK2qFKUpvTEKYxpDqiVZp6aCrlWERUbjug43DOIiMI5oYyXmtCCm80aiIKm1WVclwm7HfHvDfHfLeljIIVNzkTlc6+gvLujGLcYJC1lyJoepsZEzNUUBaQlyCKR5kX3CKcazpMIyLUz7CYqo37UzMs5gNFd9x7AdxXZI6dMnTxtNqRrXjOKplXCYifPa5oLTCZCnUMgxEdfQvDZlXlZ3jtEbfvE+MPz8QNh0fL923ISemwhrCPRdJ0x9YzLFW1SOM6YkefNAVUrsoKwi5kxcFi624ynhKKVECIHtdoO3otIvJUOuDwlItVKqxMNao0957TFEnHMs68o8r2w3AoBrcxfwjflXSlFr5fJiK0b4VsYvcsrs5pWuczL32jmM7TnsJ6Y4nWJLtZIY1GOq1BHgjkNPKaWlTjm2jKSUubvfMY4D261YaeWU2WwGQkwsZ/umc53rXOf6i9VPivh8jDfVYwz6peKjpyu9ylC+WW+YzKv6GgvKy1svXesBKDmRlgPx8Inw6TuW7/+F5YffkPa3KH0ECqblp4uyHGswnRUQpiDnikoFVZutkHOYo0H70OOGAd2UyjlnlsOOcNiTD7MwnUVmK3XzoMwpiVAlZZkRNBblDNqZk3VTLbnlrecWCZnQtYqAqFQoYmaf1iAsUWpZ296JalnpkzrdO0ejZ7FOYje11aCFnVPGigVRL36n2kk6T4mJOM3kZZF2dYziUdrYtFqK+E4e059QYIzMquZErpkcJQVIwK5BKYM2FuOb+b1S4HTLuu/pLi/EfsoImyiiHjHhf+zskCvEJbDc3xF298RpT0kyt+icR6tCrQo/dMLKhsD+N78l3l8wvLsWBr75l6qj8GU+kGMmxoxRCm0NcY3EObKu0jqvpZzCCdzgsH2H7zp87+XzUkR0ZZyjH3pM1wlYj4k4TyfT/hQjaV2lVTx4ShNrxZgbC5qQqQzDcDFw+bNrrn/xnuHdlXwPcuQrv/LD/T2/UZU73VG0JyE2YbXIrOSR+cxWZjJLrS2C1VJSxFuL0RLTadt8cgyJkAL7/YHNOKKNxrmuqe4Tawho1VT6LYO+NGN80xht4wxaiQl+7Vxr+3uMKSzzwoKEI4DMpGqlxXRfgbX6BDJTG/fo+551XQlBFPYo0EaRcvteGkNoYjdrDesaGQZp5//i519xd78nxiQq/1KIsYn2lKj9z3Wuc53rXH+Z+vKIz/rWz48f+Lx66SlF+wXtqtck8s86/4/hZm0s2AkcP50kODGqtRTyuiPc/IH19jvCp9+z3nxLvP9EXmcR8xjJJKdKPrW2Bu08VusmOGpilCxCD9M5XCf57sb32L7DeS/AMgTW21tp5S4LsSmKtdJgDaqqBmASJYoCnFoxTjw/j6AfFDUm1hDJMVCigDzVRgpCkbz0sIhf6VGJDsKmCvOGgD3nWtSmAMRjnro2AjaU0WK7NG5wQzOdN5JglFMizzNpmsjLQkmxWUVJ5GethdIEN2iN8V7GD5r4Cl3Rg6euAXIlV4NCY40AeN0uKbSzuHHAjwN26E6gWCnz8Flqn40jY51zYT0cmG7uBOyHFW1kPVHOG5xVmCizliVLBKrxVt4/o8nzhLYN5MY2m5lSA9hyQZIVlFhYp5UwB8lgP86gakO/GRk2vZx3K0k/NH/WYTviuk4iTJUir4k0T6z7A2EW8ZO2Guf9SfkeY2wiJgHTftPTbUe27y65+OqKYbsRFr0qwiRrxcOEm2b+NmTe07Or77m376jKNiGZxjl1el+Uyi1bvpzM/FNObDajRIVmGUWxznDZbcltpjROqaUZqWa3FIk1tThaOb8iJpOxD2cth8PEdrN5YjFFFa/P1Fr7yxrQWsRzxhq8cczTgnOOzWjJRRKj5mlBaUXnvVh9tQAH7xzl6IGqxL+0tGx650wDswFrLZ13jEPPGiJaG/reSBxoO/fnOte5znWuv0z9JEb0WMexuxf584/qi+Y+n3CYb0qFTgs+efTR+g8Cp2MUYLu/3StzgoW0TMT7HyRe8+b3rLffkvZ31BwoQYCbNhrlJbNaI7Nous0rUsTeRlk5bba13W0/YMcBN/aoCpRCjbEBIWntpnlBA9qbpmaXeEZyPkJomTtVtflaapTVULOAv1xFHR+itMBjlHa9MWgvauLD/V7skypQG5hxTuZArQiMSlXSmtfi06kN4oWZ6ynu0/Y9ppfsddN1ogAvhXCYxTw/SIJTyTLzWBHAUlMSXNgAi4wXVNIqaveCCJtMJ2ImcsG6DqUtqgmL0GK6748AdBybtVUVd/vGkkrKpNxfciEuK3E5tOSjA3EN8l4pBVWfsuzJ5QSIrJd5RTtIupJx9jTbkUOLR43C7GqnKUrYwLQ25hMIiyRM9aOnFDDG4keP77vTBYTWYtwvUactkrQkSgrCLt4fiCEIyCxVXANAojnbrG9KosS33rL5+h2XP/+a8XKD7cSVQWkRNS1396z3O+KyUmIUT9WcGcqKX/dszEcuas+du+LQXZO0wzon57EUcq6neMxahWk/Ku1rRUyytBZwaIRZ1Fp+IcQgbOPRBB9bT618reQ7tUwRf3WBQrHb7YVpdRbfFPHj2GOtJCZNccYaizXCrlo74L3EnhYq3jtS89GttbLbH/jZz96fhEylAdUYExcXG6ichFvLEoQxjTL20HfC8lsjANRagzVW3vMWK3uuc53rXOf689dPS1aCJkBoN17Uj82JqgY369PHjus9R7TqseCBF8+R+xvXeWJNW3u2sZk5zITb71k+/IZw8w15+kRZDtS4kFOkRPljpbTCOEtVMtep27GWWjEoxHKpAho7bvDbLdbZ1kbuUNZScyTud5R1FaawpdWgFMpZMYhv4qSaC7pmQFGVgVrEnsmLwvso7Fl3EymKsOfIfiqtJclo6FvSksHmgrKW+eONpPk4aYla74QRbOfEtLasgLnGyhoLnaMbetzQyesxYo+TayUts6jeYxTRD4iP52aL6byo4lOUJJsGYFBIyzeX1jVXgMzuqWpRBWw3oEobfzgyykOPHQYZQTCaqmWWUmkDDfAoBKynGFgPe9b7e8JhT1lWASC1nmI7tZK5zpprA5QGN2g5P53HeC8zoSlLBGqK1CTzo8f8daW1sJJrZJ1mchBhkta6ib3EJF5r1RKpoKaEHQf80GP6XlwJEPCaQ2Ld76FWUpB2+3FcAlUI6yqfkZYUVEpurKAwxsPVlv5igxs3oBRpWYnrRNgfiAe5UBA2spJypWTIGRSZId/j8h3v6j3lInDn3/NhdczFCqubs3ifNlGaAL9AKRnvHKmJf0w7J8YotHbyfuSV1AIGUkpsN9K2z0kYz5yazdK6stkMzPMqs6LLwmYcSFE8VvtemGBnLVC5vb3Hey+t/WbddL/b47zFO/Em1UoRosyuGm2wzlArDENPjElspZqTQMoZRcAYLaJApWRmtM3JxhjJ2bRfQc3O7FznOte5zvUXqZ/GiD4DoE+08i/AqXrl9k+YCm2A4sEw//Ey9Rkje6REJSUnh5n15nvWD//C8sOvifcfqHGi5kjJqdG5wpxqA8q4RrRVAU1wapdTFTiHG0ZM5/DbiwaUHKoWSlyJ+3vivAgAiAllGu7SoNBtHTF+r+2P/fF11QqkpvR14oWZ1thmBYXdLLnIH92+w/QOM3QSb9kEPiUmVKkMY48tl5ASGC12Ue2PqACLZl6ehGVVQ0d3cYEberRxIroy8ge8xERcDgLWU5E2v7Uo53HDRs6HMyht6K7eY/pP3P72N6RlBaXaCIASACkHgNEy3qBQYqVkNcZb/HaDG3s5p1qM54X+syLMUvJ+Ka1aetTCetiz3N+z7g6kGKhJkquMs2jarGkVsJirxKSaTlr9xrb0JydvVJhmUkt1KkkENmjh10MMqFxJMXLY7QlTwHaOzbtrus2GvMzUNaKPn8Ra6TZb+mbLpZuVUy2ZNB1YDzPrtEBO7TyJAE7GIiApg0qGmNaTHZL13QmEKhQ1JPYfPrAcJqw2lLCSs/iXaqXAGcqaKEWhtaFk+RhrY3DOcnkxMFz0KJ1J+papd/z+YPld7rlJlZgy1hjxddUa3+aKj9+3mBKmzRQrpM29rkF8SrOATaUbk9jEUAC+cy1rXsYYhqGn6zyfbu7QRtOZjlqqCO+a04KkIFV2+0msnS629F1H5z3zupzAaqmV66tLoJBLfnBLaL93QvMmpQmZXPPY7ZwVNnzomeaFTKHrOnIupBTp+04uLs51rnOd61x/kfqJM6Kfmf18Nrv5JQKmp1n16sl9R7BYEYAoNNNTKHsEDMJoRcLNtxx+/4/M3/0T+fAR8oqqCVDkEEnLAii0s9jeoZ2o10/sZ5ZEpJorBTBdx/DuHd3lJc53DVjJH7g8T4T725YLL4ptZWiKaCglN/FORiOANldRSOvjaz6OG9QmRNnviWsiNVCllRiCO28ZrkbsMGA7f4oUzctEmhdUrShr0YChkK0+pfmc2tMiSUcpsNsLuostdhjkNTWaO6dM3C+UHFA8zO1hFMYN+M0G2/cCNNqacVklJen2g4ChUolLACdsrDUG3/uWOS/zo9oYussr3MUFruvbzK20kGUI0bYZTZp5v/iLlrgS55llf8+6E/Bfc8VoRzUZ7UTkpIyB0gzgq1hUuY0AXd3siUThH8WEPgRqa4PXIqx1jhGMeN+vu4lpP2OcRHxe/81fMX71NabviWtg/933hI8f8OPAcH2BG8eTeKrmTJhm1t09aZVEIWUqKVRSThI8YAt5XkhJ/Ggvf3ZNypnlMENRGKXkosYI8D/GkrIsZITdVs2iKzYRjwA5uWAzTtN1HeN2Q7cZhflPclFmc6Bf9/zVMnNZHX/QI79PF5TuSmZEU25solgs1VJZ1kCIYsUEgqm7rmNZFlLO5FW8PUNK2MY6ppwxJrMZR2KMwmgaC1pxebmVCNIQWXMQKzEjQiyAvvP4C0/Omfv7PYtf6LoO7zwg6Ur7w8R+P3F9ddFmX61YN2kZD9HtgmhprPnQ4kSnZeXiQkIUNptRIkhrJcaIPyVBffHl87nOda5znesn1k+yb/rxlvxbAqR6+uclJ/rIuxNeqqKOd6n6AFyb+rrmTLj5gel3/4XDN/+JePsNNQdhoTRQKjmmlj3eRAqdw3Re7HNqRVeFrogYSWtSibiLkeFnX9FtL7Fdh6qipC3LQtxPpHmSSMeWkKOMRXtDyYH5sBfjeN3sjoqAWrFykvZ0rSIiSjGzHBbSKn98AWm/lyoM6HbEX2zaCICYyZcUqEuBkqlJPEKPPqS1tfRN5zBdj1L2NPunncf2Pb4XpbY2RkRFpbDu96T9rrGYLanIOXTX4fyI9h4DDfQL67fs9hy+/wPr7R3xcKDRV6AUfuwwTmI0rXeQJBFIO9tM73uG6/fofoAcmzl8QvcCkqDKcWiopRDmAzmspHmC5j/abS9BOXLz6VTaSoRqAy8Y6K8vROCkpTVPKaQwk2OiNnV9SRVlhLktVFIK5BTbHKdi2U/M88LX/+6veffv/icM799LXKlSoDXedVz9rSFddmjVlP9Gnrvu9xw+fCLc74XdNJqjcMwMHV4rnBefUj30AjSdk1TVLP6acgGWT2mr2hls70Qpd0xoSol5N7Pug0SzNtGY2HBZxncXdJcXGO9kJjmsJAWZQjgshHWlaM1GR/6n5hO/5I4/xD3fm6/ZFxETHT7dcrEZGTeD+LFGcRSQpK2CKpnLyy1393uM1i1PnvZvPTlDhBDY7SeMVnRjx25/oOQsQNeJO0OICWttA76FzWZkmhc2m4GN0qdUpwpisH+0eQqBu7sdISX6zvPV+3cMQy8RuGtgGAfGsef+/oDRmjmsjOMgKn2luLzYcn15QS6Zmyz2Z/O8MM3nrPlznetc5/pL1Rcb2n/68B2vCopeU7Yf73/SHlNvzIY+//ERu/q81a9kjXS4Y/7Drzj8+n9g+e6fKeEgLJ11Ivsp4gPY/hZKfKS34o1prIhUlBYWCWnBG+fwF1vc5gLTDQLggjBYeV0I+5l02As72Hlp4+ZKzpWakjBoJaNqEe9LQBnJPq9VPEprldzwuCbW/YF1DmhtMfbohSW+lv3VBX4zopwThjaJQGmdF2qMLe+7wf6MtN+NQluH7jtM7yXRKQtT6scRNwwnU/iKvKY4HYTFXMMpdtJ0HtMP2M0ltutRKVJybKlOmuX2jv0P37Pc3kCKqDaHkIKopPuLEdt7FKISPwI22zv8dsQNXZuRrWhjWe/u2X26o5ZKf33F5qv3+HEQxjcFaorksFBQzaagkGImzascdxbAVWshxdSYT4M2Dj/2aNuM4Q8HYVCbjdVx6kIYV2RWc17EBqulTNm+p9tsGd9ds/nFL1CuE0DVWNu6zuRpT82SFX/8jGprufn9H7j5zW/RpUiqljHNhWDAeEueFjQZZSwlZVKRedqSMrrqU9AAVozciRFlPRWNqgWlDVULI73cT8QlyviDki6B6zvGdxf0V1u0cwLWlaLElTAdWA8TqVSss1ALcQ5yTkqVqNdaSXbkQ93wm3TFTbTM88r1pSjd1yDemn3fyYym1mw2IwrFNC/YdkFwVKmXWnHWkVIS1rYJ9LrOn+I8rbNYY04eojFlNsNAiJHDYSLEyNXVhcxxhsT9/oBtKV/OO4a+k98wzc4Mpbi63GKMYW5m9l3nSSnhvbCph2mW55VKTJLYZIzh4mKkotjtD3z8cMP/9f/2f//s78fP1dnQ/lznOte/1fozG9rDq2zoCwDKSQX+VOn+jDWtDwr3x0Kol3OmikqhhJnpw7fc/ON/4O6f/3tY7xkGj7EW1XwKy7xQq0JZjSoSZ6itFv/J7aa1JFM7Ppk3rNYyXr/HjSOml+jImiLpsCfc74SBrJJYJGb1mXhUMzdRCLXiOi+CpNyAipHjqiWL3U+pAmaXQApNRV5A6YxSBr8Z6C822L5rqU2ZPC+UnKklo0rC1CzRlTlQqhG21omdlB58i9w0GCOzlXbcoL0XBq9WalyJMbLudqRlPs2+1ZRR1uGv3+G32+Z5CkpXatcR7hbm7//Aen9DnCbxVrSaiiUnYWSNdnirMcY2Y/8ilkgXG+zQCxhSirSK4j7c7Vhud9J+1pp+M5IPO6YayVfXAhZJAkpQkAtxjSz3B/K8yoUH8iGvttBtB/rrLdoZmt8BNRfWeSbPS3MbkHnFkjMpFWEorczlliWcRGv+cmTz/h39Zku/vRAhWi3UGEAZSgqUaSesdMlQsmTZOy/xommlv77kov4NabenrhG76eg2g1yYpIT2BqUcpQmbcouT9I39VkpRjYQHGKUo1lNjktesNGEJxMPcrJ1EEGe9pRs7+osLhqsNxrvjKLQw34cD634vEZhKYaw+WW3RkpAUGee8jDeEwM/zxLv0AzfuK36dew5Jgg8k1ShLkpI1HA7zyUjeWcsSAp0X+6RcC5331FowRpMUbIahWX0J+330Nl1SxFnDMPRonVnXIGr6vsc5RwwRnMybfuWvmaYFrREzfi3euPvdJNZkSjFNC8PQo5C2fIyR3PxHx2Gg5MxutwelcNbQ9579YSLfZrQRFf0vf/H1T/s1ea5znetc5/ri+qPsm55XrfWRHOnxv0ehUX0Vw/Jk22NJ67qWTF5n5k9/4P43/5nbf/6PLB9+B2VFG4u2ljUVPJLqU3OhgLT3vMVYh+u9MD5tL2VdRR3dgEjNTcTSb7HbC/KySNt9kj/YtNx4lCbnQjzMYkWjFc5J1rqMSorCWFVEgd48e0qS+cBlmolzgFyaRZFY3zhvGLcDbhTDe2hALUYBjjmJwl1rdBWrJN05dC8tZ93GE4yxaO9R1mJ9jzFWIketpB6lZRHrqukg65aCMlaYSuux7wQsGi0gvBxWYWCXhf2nG+YfPqBqEnESGmVdi5/MaGRm0Wh1ejM14LcDZjOKSX+FtJtIiwCnHCTpCWC4EAsi452kTnmHKkky1VNu7GUl3jcAhQiqoFIb8Oi2A67v0E3UVHMihkBcgqyhlajodaXUQq6ZRCLPESrNQxMuvr6mu7xiuLzEjyM0v9JaZb625AzhQEmrMKBavGaV69C+O82fVu8ZO08/Dhxuboi7fTODb48rqNZLpOVhj05y8SIXJvXkxqCMatZa4l1aW4KRXNAkYYi1wvceP3SMX13SX1/h+o6ai4yPpESKibjMxLBgvMFZTymVvEQB0srJuQmhjTAkCVqoYjFWc+IrvuNno2fuv+I7vuK29NzuA9OycGG3DEMHtbBGsSOTfPpVGE4gpySfS60Yx4EQgzCU3lO1JsXENAVCTCc7KOcczltiThQqfd8BEEIEFEpV2RZw1hJjQmfNOA7c3t1zdbmllMo0zW17mgm+APHcychNypmh70UcqTRDPwDgvSen9OUCy3Od61znOtdPrp+WrNTae8/vO91+FXjWFwKmB25U2qL1KNzJgTTvmX74lt3v/5n9N//I/MPvSNNOfC+dBSPCF2s1phTICusMZuxkzrPrpK3d+q81ZpkJpKUOhUhOkumtW2zg+ukHVA4tvz2exFclV+I6yx/jKK1T3eYk0boJauQUquYLWmompyJga35QPnedtAKVUfhOUpeMNY1QLmJ2HyN5FZZVO4tBLH1Mm0O1fScgzErEp7YGM26wXYf1Hcq603hCCStxd086TKT5QEmpAdke0w+YQdT/znl555o36DodmG9uOXz4xHq/R+s2P2ucjCXGRJ6EqTRWkm+UAmU1ru/w20HYT62hQtxNjQVt6UdKCVutFWoYMJ3HDZ3Mkir5PJVm3l7WQA6JkgqUgvYO5RxqUGJLZUXscmR2SwwybrBGSszAQ/iAgLGVsAjIrlYELdZoTD8wvLtic32FsRIRWUulaqQFHxMl7FElI1wvba7YYZxHlXpyRihAWSNhd0fYH1BK46wWxhElrek1kpdVmNFSqOooKrLYrgPjwEhsbM1VQGNMIgJrEbPWGdAaN3Z0lxcM766wXWMgYz612MPunpwCymn82EY2Qmq+sS3iVStqSWgFWas2P6swmNZVULihQ6Ho8h1bNbHTWz5ebPiYNCGsKCW+tDFEQoh0XSeJRMfpHKVIJaEyJKUYhk70ac08f7sdKaWwby34wzRjXWQ7jlhj5OIxJnKRi4aUIkqJn6m4hmWO0aDrutJ3nhiOs8DigtF1XuZKnfxOWtfAOA7sdocWI2oJMZ3Y21oLtW13rnOd61zn+svUT1DNP5/tPAqHXmz4ypOPN44TikeT+dqU0Pest98zff8bDt/+iv03v2bd3Uucn7P4UYQ31iuMVq2taBuwakCml1QVynEGMkl2fJQ/YLXNqoHGeoPxTp5jFKpCng6nVmFeEinEFrWYcd6Ij2MnLJW0TiVb/BhfmUMgr1HMtpOAT5lNdei2L+Ndm+1sKv0YiWuUVnupjTWSlru2RqI2texHH22YmjG77XsBs12Ptq55ThbqehD26+5G8t6b7ZLtR+xmK+36cYPtBjFVn2fiurDe3bPc3rDc35PXlbQGaff2ncx7VoVqCu6qM7kWjBKfST90+O2I7n2bh82kw0yJElNaj/PCugmhUBjv5Hz0ol7OWVg4SgPxa5Txh9TiMjsRT5m+a/ZLckFQcvP/zNJej4vk2SulT4/HEAnzwtIuDIy1OOcZr68Zr6/oLy6wncRClmZtVRs4q9MijCSlvQaHdhLXqcVqoc0Ly5zwutsTdntyijI72UYSaBcqeQ3UnNEaihHHB+ddi1G1zfZLxktyiKRJ4jxLKmDFgkqhsF2HG3v8doMfe6CSl0Cp8jnK00RcZSRBW/lelJTkAqvKPLEyipKyHFeSL6nxVsRWSoR2qtZ2Lpq1WQVbE+/tjvdd4G/cFZ+U4Q/3K6EOOO+53+2Y5oWvrq+EbUaRqawxYrW00NdF4ZxjXVf5OYaTXdNoDSll5nlhXSW4QVr1IlTSraNwNN4/GteLCb1prg6a+/ud2Gl1HSknjNHEJEKoGMUzNKyBy8uttONzIaUVazXOOGISBwJr/yyNo3Od61znOtcr9RMM7V8O3D8Z6TxZMD1nSBvzKYsAippWwv6G5eM3TN9/w/TDbzj88C3h/paaE0bLvJZ10vbVtv3hMUqMw51DezEsdy2qsKRETaVlcBdKzA3YVDBiAG+cFSNyo05zkHmRiMa4xsYmJZmZRLLEXSdJSKbNmypjBSzFRFrXZjgOtXkfVqVE6OLtg+G8d9LWVog3aIrildjy5EsShtGaBra8eHqiFCoXtNfYYcR0PW4zYpq3oWqt2rjMpHmWmdV5JS+TuARYi91sMOMGN17ixhHVddQK8bBjubtl+fSJ5f6OdJhatKSMNRilmrG+wvmuibcrqIrzA8oarPdYq9DKoKwlHmbW/QSlUmKWNKdmNaSsiHWMc5jOQZvTzSGf5kZLiM2bteV8G4sdOtzQy8WIFYW0EMUGrKHEQGojB5QmXFKauEZSFG/QuEZyjFhnGa8v2Xz1nuH6Cr/ZCKNWaFPNWkIHinyWoF28WEmC0lass5QMmrbIz0iaZ+J+T1pX4rxSsyjEJXWqzSLnhFYKaw1FN7FTEocEiSDlNGtacyWFQF5iGyURFwbJr+/othv8ZsQ6J1ZhQTxsc4GwiMUVpcjssBGRV6mVikS4mmPAQUUAfEsVM71Ht7nRWkrzoFUSw5pSi17VVKX4/7L3n0uSZVmWJvYdeokSM3MWEUm6RmowD4DXGhkRvA3eBC+CGUCkZ9DVVUmCuLsRZZccih/7qHpWo6clqivjF3S3ZGV2hJu5kqt699l7rW+ZbqB/euD9duQPSnF4UHw+L7ysDpUcl1C5LAumcUhrqRilWza8kwNE+06ptRBCaUYlaUb7vsOtlpgk2SrnQinhZmRa1yB/xsnneL2md5XSjFGKvu+4TDO5iN6zIgEVKYur3lrDNC0t+UlMVsYa+WxmQY2llFnvEZ/3ute97vWb1b8ZaH9zvv//DD7/a87QdsNDU9NKPL8wf/0zl1/+hfnLX1hfP5OmC3FdyUlu+sZpnLUYrW9GJOOF+ynTQieNWNMJllyJ0yKMxlLJIYuuq1RsZ3Gboa2WW1qSlZ+T+MYoqTRzuJlutFbYrjVjnZOIz4b3qbUSpoZbQowtSltBCllx5Wtv8Z3DeDEM0VaPeVolk12EgHKjA5S1gtmxVvSRzrXfq2RKZuX52qHHdKPoBnMWPevSIjevDW2I0kD7DjuOuN0e04/orjXrYWX9+sz88sL6+kJaLqRlFTNUa7ZUU1IYJyvqkosA+o0FrzG9ZLJLQ1AoMRHCCnkWMHxIuN5hend774z36Ja5TlsH57ASLwtpbprYJJpH7Qx2kIQl7Z00so0hS61o67HDIEB/Z/G7PcvbC+vzi8R8roKCKilJ89ZSqIanBzbffWR894jzfdN4muYUF3e+auSCes0+NxrVCZYJ32OaUaymRFpm4uVCmifRoTZZh1YK1XffPHkxkkOU62joJVspVGnqtEYhryEgeK4smtgaczNPaaxWuM1It93iN4O8ntfrf11ZDkeZyF7DEkqh5EoKCWU11vtboIEymhqjHKIKUIW/6rpemnHVZCalTU+zMG0plWo0br+n3+1Ef91iMamFd31iWI/sLhN7ZXnpBr7mgTk7UspysLxFl2Y671jWwBIC+91GAhQaEULBbZLqnaEUaYFjiJTakp2MTEf7zlMrt1Qrcb5n1KAYhoFaYQ0rIQSGQdb/rm0QQhRMVymVzWYkhMi6Bqw1rMuKtYau79D/ta+2e93rXve619+l/g2r+fKv/8F1QnqVhf6X/04JZibNR+bP/8Llx/+d6fOfWV6+sJyPqJywXpo4pcA5acZc51qcocGOPa7vpRFsDa0YZhQ5pNaAhrYabek/2mCdNIJ+M4hTPn+LbKRN4OJlaXghmYYZK7/betN4j7ol7VREPjqTo6wBjREW5BXXYzqH63vc0CZKpVBjIq8zKUpkpEC1aRnlTfPZohRRShora741n0MvK3rfYZpmsLRJZjoeyC3z/Tq5qspiN1u6/QO2H8RA03VghFM5//wz0y8/EU4naZiswhqNcmLIoFSMbklIVbUY0IrtXWsKveCftELlRA6RuEoW+xXTZLxMMJW32M1wy1W/XSpZtLBpCeRlaZNCyZjXTfN6bUKN940QUCkpYbsBN25kNd93Mi1WilQXKBL3GdaFdVqBilEG0/WMTw/07x7xu11ryERbWdGiB15nILcGX6JXq7borhP2q+/bmh8x0MVEeH0hHI+yZm/pBMZY9CCpUCVnqIWyNoatAtv12HGklkzMM+RCiqJLru1sVwCufxeImWzs6DZbuv1WwgSayazEQDyfWQ8HcggoK1GoGshFNKfaGGlarW0D0CIms2khLSvaKNzYJBXt/aFWMaQpI83tGkAb9Diw/fQd49MjRokmVmQYgr1aDgfWw4leK77rIk9l4Ydu5ue142vsSWorKUZIIwrymV8DTNPMOA6UIrqamJJoqpu+VGvdmKGSzKRNazpjYlkD3rWI0RTpfEdWhePxzGYzMA491uiGb8q3Zlgp1T6TinlZGIaOh4ctMWW00uiGnNJKsyx3jei97nWve/1W9d8pflK3/1v/tgltN9GyXli+/pnTn/8j00//iXB+aevjFa1hs+0Zdlu6zcj5yzPhcm7Z4rZpKU1rYgyaKg0LwsoMs9z4coiSnJOLrNytwW07/DhgWsNUUyadz5SGhkkh3aaHNdfG+QTXCVvUWGkkUpC1e24rc20stcoN0HXSbGIMGmlCdWt8S4zkJcjPxpUaU4vobN26NSjb4fpO4i0bdgrAdB47jGI86jzaSX492pLWQHj+hTTP1LBCTsL21AYzDMI+3WwxvkNbB9pQqcT5wvz8leXlK/Fyaave2Nb2I2FOoldUSJZ9KhSVpLEee5k+O9EuVqMpUZqruCzkeW3TXcAabDMcGdekE10nr3WLVC0xktoEVHSjAFXwWr2jxEQiY5S+xYKqAqYbsPv+m7628SnTPHH55TPnX74Qzheg3DSQbhjYPD2y+/QBv9vfZCVKe3COsi6k81t77uoGoEdblG/XXaMloLVMoMMi8P7zidoOANpalLNyfdUqMPlcUfWqHa5tku1aXrkclqz3skJeF3JsxjklUhBRGFTsdqDbCuBfCZ8I1Q+AYn17Y37+QklyoFDeQKqUhqjS+nqgkgMhJZOzNMUpyPthOicpVLpK2EDLaxdxKLjeUKtDe49/eGB4/170ziDyCa3Jl4n59ZUU1mYms9I4ohi8pasBv7zyPsFbeeLnZU8dHzFWMuuHvmOvNSFEUosVRUGIqTWrV3OkcEFLqXjvGYe+Qe8lNanWq4ZdOMPOWVIphBAxVkxUfd8R1tiwTRtC05ZSK7vdhtPpItNzK5/1cRiY5kWiSJtb/173ute97vX3r39DI/q3bvjmfm9TSlCUOLO8/JXLj/+R85/+I+fPP5Hjim6IFW0M+w+PbJ8e6Mce1VAu/W7L8adfKHGVyZu1bfrUTC8FaShzFuxNMwjlKOvw/mFLt+mlmTJyQ0dr4rSwHM6kJcqk0bW8RiUrdUrFdxY/NDe70hRkspZWiQW1nZdpGOJc1lZiK42XtbPEY0JNiTBdZNLakDky3ZTGVhmNHXvMMDSji5F1rlJYpXDjBue9EFNrBW0BLY3PNFFiIM8XCFGMLMaghy3d/lH4p9aB8/I+hIVwuUjjGVbSfGE9nSkpiwRijRhtBIOlr/zGQmmP0Y2jNBzOSHpVijJtPEXitDYEVVvhOisrd2cxfS/O98ajLOtKrhCnhTzNkCTHPafm2O4cymqKVqTpIpreRjUw3tM9vRMQPDKNV1Ya1BxWpuefePvLj1waCF98SxrTe54+fuDhh4/YbqCxn8SFbj0lBMr5ACVBc1lXxIBkNhvhsJbWqJdMpZDmQDgdyNNFVuxtalitw4yjTM2XpYUj1MYWVdB1+H2HabSEmjI1JEps+uJ5pkSZ4GsjGCp5bx39fhRzltaCA0PW9svhlfX5hfVwaJgyCTwQs5G8L9bK+p1am841i445S+wnja+rmv7a+F6kGw2ZphANJrlghp6Hp3fYoaGsSqYsEyUn4nRhfjsQF5E02M5iseRaSakSzhdyCJhSeLDwqL7wMb3wuj7xykdeoiWXgrcG66wEUJSCc5ZOOdb1my5zMw4oNKVmas2iAXXmNlnNOeE7MSsuS2RdV5YQedhvRDPbDEq+s+QkE05rLWuI0rTGBIpmaDLCGs2ZzWa4Oevvda973etev039+kb0bxOU2uq9pkB4+5HTn/5fvP3T/8r69UdSWKDKdKcfPf1mw7Db4LvuNl3DNJB2FIPQ8G7PNYKzRGlWYkzkkCFLA1NTWxt6gxt7ti2l55pJXnOhLIH5MhHnINzOUtBO+I3XLG5jLHZwks+uZUpZikyT0hrEqe8NKRTiEgXv01m63mAb9B6Q6NA1UFKkhJU0TVSlG55p+MYo9a0B9bL+pGRKFEaiHUZs36GdQ7WGMK2B8PZGXldYF5RWlBgoS8D4DrvbyZq572WKaSzVedKyEl6+Eg8HSopilCkFSsX5jjVMaGVwvRODTdMlGm/pdju67Yhu08xaKiUn0nwhzQs5FFKMGOdwvWuufUE3UWjMSwNppaRCLoiMoek15feJftF0Dt23RvZKAlAaRaZ72LL97jvGhyes70S/aC1oR5jOnL9+4fzzL1zeToJhShljLePDnqfff8f2wxPWXVe6BWU70J4cI+V8QNUsE2MkIrMoje0GiUOthbrMDTtVScvCej4RLhcxbDlLjYWqROtJqSJzaEYWfTPkFdxuix0GCU9o0oVaKso6+t2W6e1ImS5iwuvEeId1uHHEDR6qNOQVca7nWomvX4nHI0ohLvkKaQmENbAGiYh1fU+36cWAlYQ4kFMU6kJzfmuURJpaS//uHcZ6clwoi1yvtYpRyu0f6T98EJkHSppUo4jrwvTlGbLoT/2mIy3CbM1AXgJ5Xtthr2CsxnaWkgp7DXte+IOa+Klu+OfjjpPfYBsCK+eM85ahH3DOEkKQbPhSMVY3w1Kh1Ilx6NufiWLEKhXtLc4VjB1ResZag2mxs+sascbinMV5x+U8sdmM1FpY13iD1yuFuOxTbFGigWW9k0Tvda973eu3ql8d8fn1y0/thpSIx69cfvyPHP7z/8bpx38mXC7YpuOsFfrdlv2HJ/rt0HSQMs2qVHKMxGWGnNCdQ5JqIrUqUoiE80JegzShtWKsxGVqb/CbHj+0htZKJnmaA2trluIsEz/d2IJoQS0ZoyUK0GmBgqckkzJtZCUcBadzZRLmZhTpNh1+09bdSsDiMYi+EaroUxtySVlLKQ0u70xzy/smVxA2ozYWNwzYrpMpZhVOqLKW5Xzi+PNnLl+esV4z7jYYbSi1Yroev3+k2+6aNlXWkaVACivheCIcD9QUpYFTihwjKUXIDVQOgKasgRQj2ju6naB/dNPNUWXym9ZAnGeWkzjph92mMUsHaZpKRRVBJGmtQdfm3k6Ey0IuVTLNG4xfJo+iORX3vUgjSs5oY/D7HbvvPjE8PspUUva71AJxmTn+8gvnr88sbyfCKjnjylq2Tw+8/+PvefjuI9YYSoud1Jsd9FvyMlPnEzSGKm1SiJZIUN3iIeWpV0pJYgJr07ySqxyQzBVeb4i5Es8XyPH2mqEteuiwFGznWsLSN22sQgxDdtzcppVxXZleDsRlEfi/sQ211egM1qKMhxhZ5gvx7UBtGK9aK2EOzOeZFCLWyaS+VqE22MHTWUcKawP6m+agb6zX/RbjHHleBe/ktDj1Y2JdxPWvADtsGD5+Ynz3SIkL6+sr4XSSdKMqzSEoUkwsp4VlXrBa4XuZ1uaYKEU0l1ctdFWI7KYWjqfAn18yh90f4f0PZBRhkVx3rTW2RYlaI5IFf01qKgXvHa41187bFrebsdYIqaAUYsw4Z26+yisH2FpLKVVSoVozOy/CHtVG03cd8zy3LQVcLhP/8//yf/vv/Y69R3ze6173+v/b+rtGfIbnv7K+/JXTn//fnH/8T8yvz7Ie15IP7UfP5nHP9ukR3/ctk7u2G7gihUCcL6K7NAbT9433KYzHuIQG+ZbpBhWMM/itx4/jzXBxdb2HaWE5XgiXhbiGFjtp5eZoBHXjOy8ausajzEFg4iVlWd+HhDPfDFCl/f5+M2A7Jw1areQ1SA55iJQiRhSQG4ztPSiZpHgn0P1SQDmPbtoy4zqZflrbmjKEEbkE1unM9HZgPRxE72ot1ndU69HbPeN+j+9FsnBllqYYWc8n4jSRlxXVjCml1oaeSSIvUHKzlSmnYKncpmfcPGH6QRqDnCDLa5JiJq6iG1W14rzHdB4/duheXOzqijTShhoiNa7kOZKCJNAIpgeK0qSSMKa2MIHcrgdaGIBj2G7YvH9P/7BvMaTIpJLC8nbg8vUr5+cX5rcLKWVAYXzH47t3PP7uO/YfPgrYvVaqsujdCNZJ4/32FUpsE1Aj0kfvRQdKRRWRX4AkMaV5kejTeZLpea1iWvKCbEqxkNoByqhK1e2ANAy43QZTM7pF2grbvmKcTO+1dd8g+aKFQGtL97hDn7UA8NMiDvfOoUyHMxIXSqfphoG0f+D8duD842dhpeaEKpWu79FGsEgoSWWyDSemtZHpvxawv3/Y48ZBtMwhyOGgOfVjEO1vifl2QIqXE2mdKeGCLpl4makKrLGUKnrTuIpkIwfhdGprKGhIWVLNtGuYqNya/cpynlinwHSYeEflw2Vmqq+8jd9xVCNciQ2l0DlpsOd1JbVDX62VELiFRcQUb875lLMY5IBUEjXWWxpa12gPWmteX954eNhSasb77iYPoFbWdcU1E58x+r6av9e97nWv37B+dSP6z/+P/zvL8SgGCa0FCL7rGfZt9T70GGtvzYh0jYqSW0pOkpx03XnympmfT6TL3PBG9YaJ0cbQ7Tu6UaDhSmthDra1eV4VcRJeZY755gw2WhiJtnPYwbdMb4kbzAiOJbam7YqI6XxzgVsjUPwGzaZkcgzEc5CIxBAb69PIlLVxMY0Vg5O20qDVNt30zmL6QZifVlzLFWn6cggs54nL56/MxyNaFxQV663kvW/3bD5+oHvYN8C5AmStndaF9XIhns/UKLSAWsSkkVuko6RGCVuxlkSEG57HPvyNZjFXifO8OuCXQG28yqtBxllpYnUvRjLt5HUTV3glhSh552toBweZ8paKsFwRaYWk1ChZ7Xcd/dMj49M7/G4jRrDSmsGQCNPE8vrM8vpGWBbmyyor9NGze/fI0/ef6B8eML6TaXOtYAy0lKcaJkix0QusHBqMxvgO5frWeMvjFynETDgeCZdLe80QDa7vqM6J7OIyo2qBlKlNV6p8Y3rutqicqIlbo2Q7j/Ue03WSZJTzbQpbSiLFlSydVMOAgR28vO7GYV0PiPFPa0tVikKlJAjzQlmjaJUHe4vhdGOPdQpdxaykjZEJYO/wuy1uM4p8ZV2pV74p0sDGaZbPtTEYK9IM5Qx+N2CdQVW5boXtKg14vASWk0SNKgV+kGliLglKQhnRUUuU6ILSmpwS83FimQOlCtBeKdCqsps/sysH4u4DB/OROLznEgohFSrcmshaKynL4abW+g0JVZrpzxicNaRcMNq0OF7btK/SvMYYGcdeTEn9SIyRJURAXPLOWeGmasGsKXOfaN7rXve6129Vv7oRXQ+vGCNA8G4z0u82+GHAWvNt/VoKuUpjKaaNSi1iNMoxEadAvMzEy0IMctN2g0cZI9DyTYcbOnEY1yvuJ7KeJ9KyQtX/KqnH9f2N9WltY1YaMdmEaSZNCzEm4hwpMckNv63uxKEvTavxXm5UOZOnmTQvksZUW967zEqBgrH+lj9vdJumKo3SFj2OmK7DddLwKS9TvhIiYVlYDm/ML6/MpwsqF2ExDgPWd/itaD/9di8r/ZIlTjMlclhI8yQNcS3oNnEMyyyA/Ny4lNSbXlPYoAbnPbbvWuMGNTWc1JU72Rzs1jmqkecp4Hkr+fGuxYlSUbmgOk+32aKdR3cnUgjUWRr2QgFjKEkc7DVnijWYrqPbjAyPT/QPj0IFUIpatRh3ppn1dGQ5HiQNaA6EZlbZPO7p3z2w+/iJfrvBdL00FEmmuKVFPprcdKdK3O9ohUISiwSPeYXQZ3IUTW9eFzGCRZmOaudRzje8kxiualiFLVpBOSf4rrFj2O/El9WoAMoYrJIJqOs7lHFUpYVPSkuACispiHaZIs71mjPucSfcViSkQClFNWKSW5eF6fWV48+fiacJYw3dpm+Ht4yxBt874dGqIprpAtVY7GDx+41Mv3MWzWrDYcVVGLp5WcTo1RKgtJEDg+k7tKqiXc6l6X0LeY4sl5k4rahaW9CEFpNdTti2/hdebKVGiVstJbHMgRQK3neUKo17rRVlLN2mp9/0dF3kO37mbXpm8u94c1u+zhWMbY72QohJDFgpk60A8ruu4ypZuWoinJP0pXleMC0m9MoNLSUTU+V0vtxMjnLwE9NZqYIzM9rItPle97rXve71m9SvbkSffvgO30uOu/PNqFIlfURwSFmaotKmFTmTM8Q1EKaVMC0C7i6l8Qs7XOfpdgOu92Ii6h21lPZnpQmNc/u5CqUW0GC6XlihVqM1MsZqJqB4mghBMspTEDOUQrSmpvO4vsMNMrFqDiHKKk73HNoENCWoCmM0SsmUVxtp9cQEJExGbS3Kd7hedJ+6JQdp31FqZTmcWA5H1tOJeD6TwyorROfp9iP9bkf3+IDfbrFeDCi1FEFALRPhciaeTjKN0wplJZEozEGiH+dFplRKU7QWlqTW0pC7Dts7tP6mmctroMwLpRZxvBuHyjIZ1F7y5LmCz2+/qxNNn7HYYYvdjOLwzhljPSUmlvOFEAIqK1SVm7jWlm7c0D090D88MOy2LU9eU3Ihxki8nFkvE+v5zHK+kGKE1hSPTw+MT08Mjw+43UYeGxJJmZaJNE2Cs8oJM7b4UqMlD944tP9msqm1yDQ6rqTLhXi+kNsEUDuH0YZqrDRTKTX3uFwexRooGtcL8QAl+KIaIuk6fdSS8mU7j7JezHiliJGtyO8rJVNqotaM0lrStqxF94OguuRClo8VsK4Ly9sr05dn8iKfAa3F6JdKRgPWSrgAWibVysjrqweH20oCF8hanFzlM5UyaVlJ6yopYFXdAhS0s/ihE1ZplQ2FMpqcAjll1stCmINISBpAXpvmvu+shDgoLaYnZYjzTFwDKUo6krUG5xw5Z2pMuMHR9Z5+2+N6T82VnDI1rmzjge70C30d6fx7jnXPkjvsuMV7aeRzkeQjwWdB1zlxwlc5MOScGUdhia4htCZfDit+6IlJIPqd8uRSyFnc9c45tKnM89IkN+7v9X17r3vd6173+i/q1zeiv/++TRPkplKvOKWWDFOLpPDEeZUElDWyXlbWSb7MtZEGqRtH3CjMSdd5jDXiQJ9mAdTHLGv3EDFNc6mcE1xN51FWsuGvurMcU5scZkpIpDU0PaH8nb532M7hei8TVGe/6T6XpWGBxJErdCqZlipUm44otDbfbmJa1rbX6EnbdYIZarKEnDKXL1+Zng8SnbmsKFOxztBtR/z+Eb/dS/PZDxjfQ5XnkJaFNF3I80ycZ3HOl0Jtr3uJR6jyOtdUxSzknDSGxmDHDusa9kchzzMX0rKI/jbLHVtMYgJ0V0ZWkcaaZjaTw4XSFrt/wm02jfFqpEGhkNeVcDyyHA7CkWzNramy1h92O4Z37yWBZxxuWd0lZdb5wnI8CO7qfCKvkoQTQ8T0PZt3T+w+vGN4ehTHtjGy1i6FeD4Rz0fyfJFrDkEe1XkWXetmI5PcrhPFb4oSfblK8lZapHm/xl9WrcnoJr8IN20s0KJlHdo4MRo12QFt4i9gdTGfyZ/TMomuLbUrS6xnVe0Q4ezNRGe0aKSN8+i2Cr8C4sN0YT2fmY8HwvECJd+CD1LMjS4BfhgkeQzkwNCkJSIVaeazXEQHnAphXkiTTNBFO1GaJKLgOo/fjbi+kyl2vE4qJSp1Pc2kOTQCg+VK3Bfer1yDxlpyjOSSISlyWphOEzlIcIUfxERXUoGg6LeDHEI7kYHkmAR9FhMpJ9IieuxBHenLxK54LmpgVd+jzZ5gHRrJis85EWrTIpdCyhmrDalkLpeJ7Thi22QcIDYtqFaS4lZqkcNzKbf1v3eS7nY8Xe6N6L3uda97/Yb167PmjSa3yY7cheS/SsyEaSFOUSIWL7OstVvT473Bb3vRYFpxu+u/uSnPR9F71hDFUJRl0mGMwnQd436LMpZSxPFaG/KpNu1dXNqKMUo6UKVie4/rPd47wSNZK7DxUsl/EwN5BWAb18DZDeECbbJXcluDS1qT247YfpAGsvMtNUhRUmI6HpneTixvB8J5IscosPzR0+8l8ah7eMQ18Dxay+NZZ+LlTJon8jyLIz/Lyrm0piAssqY2Rm78MlZVmN4Ln9Q7SYNxVqZvsUV+xijxolHWw6a7xm46idR0zaGNrJiL0phhg3t4wG13aN/JpK3IjTuc3pjfDswvr4TDUWIic0IpzbDf0j89MTw80e12ordtsVs5ZZbjkflwIByPpOlCLTKlq0rhuo7txw9sPn6gf3wQ578Wd3hexdkdLxfy5URNoZlpFEqLLtUNo7wGXS+NK4j0YBI9bVoWaZKiTLrt0AOV2hKloOlbrwEDTXKhjWk6VG4xnMporO/Qm04aXmNQTZ9YciLH0Ca7jTeqtUzXtcE4j1ES/Wr6/haPSS2EdWZ+eyVMcu3kKchr7yxut2XwnunlVdbfvhP5RluLm6HH9oMwV3MkLxGUQXtPiiKHSW2zIKxaiRF1vZeDQucl5azWG3mgFCRCdg2kyyI+Myefw1or1ptbE1lBzHxraKxSKFXCAuzYSyNtxHx0TTzrxg7b+9smJccsMp4YmimwAqLJziEymsJDDyn9hZktb2rHQe3IRiJEU86QQFVFroU1rQxDLzn0IdzMT9ZavHMsTZLQd518r6UsZqckkpUQItvNiHPm1sDe6173ute9/v71qxvRnLMEzRhFLYq0roTLzHy4MB/P5DUJXLvkxqYcGfYbuu0gAPgGqS+5kmNqjEbhfeaGizFW43rHMHh872+az+u0Yj1NqFzR/hqHqW9aQgXkkokl03WWYb+Rm6sy1JgIjXVY2t+llKwjr2xI1zu0Fj5qKaXdtA2m7+g3A37cYIdBmg8rK+wwzUxfvnL5/Jn1dCaHBDXLdLLzDE8PbD9+oN/t5ed0m+6hyJeLNKDLTAkRssgWam76vZBaMyuNkLFW1ufeomrFemkilLUyyY2RPC/EWaZKNL2g0kqiLZ1Fa4UqBU2RabbW1JhknTuO+Id3uP1e3i9hQ5FzYb2cOX7+yvHnL+R1xbS1baUyPOzZ/u4HxvfvcV0na16lwBhyjCxvB6aXF+LlLAeHeaGmgLEO/7BlfP9Oms9eJovKyIQwLwvxfCBNZ0ozrFzNWdrJZN32HcZd8VoIgL9COB6ksV8WmV7GRIkNY9R34ARBRVigSHOplEG7QRKVcr5RH0prVCkV6+RgY7qhTYfluixVpsSlxobravnsgHSxcs1ppVHdIG5421GNIp5PXH7+hfnthZKT6C3bQcRvt2w/faDf7VBohodHwuUsq/pcJI2r76jGUK6oJhBzU8mE9SzT2VVSyHKQLYZ72NB3Xhz2Q6MV1EqaJsJlJufazHWFWhLGS9pQWiPWWfzob416rbSM+0KJYrxSVuO8l99TxeyjrRGToBKuqFKaFKIEJqyJMM+EeRa9s3eo3DYt2uAfNriuFyKGgo0K7MMXZo4chvd8DgPPl8KyBsa+Zxg8c11JKdJ3vbjmjUahWNaV3XbLfrtljYG5ZcpvNqOkT+XctKtwOl2kEb3Xve51r3v9ZvXrgfZFbjbLeWF+PbK+HYmrrHtLyWhrGN7tGZ52gnG56jJbBnZMMjktc6DmSlwjNWdsZ3HG4sYePzqJ2cyZEiWJJpRIVTRndkF3DtNg7bUWjK6EkgRwXirKSpM8nc4Mu61oLaeJXApWW7SRxCNrDViD1wrTNtmUCqa2ps/TbUbcMAokveXAozXT4cj5l8/Mr2+kaaassUU8ylrfbzxuHHn4wx/oHx8BmZzmlIjnI3E6UteZGqKgbpSmpECcm5Y2yTS55EK1gsQxg8dtBtzYSTqOsWAldlPMPhfCZW6NQg9NcmCu2KcsGkOZqMpErCiFe3xPt9vi+l4g5DVT10ReV+bDmcMvXzi/vJJCkGz2WvGdZ/vxPdtPHxk/fMSNowQEtOY2h8j0/IX562fiNDXneCGsAdd7hu8/ML7/SL97QHce6aRleprWmfD2SrqcAEmzQonhS1nd4PtbTDfI+2FEH5nCQp4v5GkizeLwvmLAlLa4jZcmexyFuvD6AqoxS0vF77YyUY5BNLRaUapMXa1RMoXsetHcKt1y2BdKChIV2QD9Nac2vTdo74Q2oE2jH8jhBxTr+cT09TPr6UBZml7TCJfTDQO7TzuRNnReDjBKMW4+0T0+sby9kMOC6TuhH8QkOfXOEVc5kIh0odx0x1Up7Kanf9rjt70IYLNMu2tOlKoIS2I9SZNrO4cZOjGUBcEf9WPXJDJyEBPTIKSQKSnhennOpUKeI0pVibL1Ft93aC/c4Lyu1JJuzNrleCaGKBPU3jeOacV2lm6/Fa3rNaZVQV4TY+94vx/4hy4zhws/Xwz/dPL8dFzIVLwzlJw5nye8d3RWZBPTvJBSZrfb4Kwl58K8LCJPaWlpxrTrNUZKzQxD//f7xr3Xve51r3v9q/rVjejzf/4L8+lMXoRHeY2u9GPH+G5Ht9sION6L8aKElen5lbwmUhaWnyqIFrHdzKwf8WPX/pmTpKU1yvrvaq5JmYKskLUx1FwIYSGsq3APmx4UKrlmetvhO4uKmXAW7aCx7jaNQWvc0OGtEb1flpVgEUAi3TjgW4KSNqJPVc4RlpX5ly8cfvqZ+fVILfnGsDTeCMTeS6a4aZD0+fkXaXqHDWk+Ew5vlGVpiCBpQFOIpCWyXmYxhzTOYa1VpAXbUZzYo8f4TlBASZqscLiwHi6E04laC3434vtetsmlUQfiKq7yrq1eUwHn6T59xD99wPYdhJmyztSYSalwfn3j8OMvTK8HccPLJhzjLJsP73n8wx/YfvyAvWlRM1SIpXL+60+cf/oRVSMoyLFIz1Mq/dMD7/7DH+kf34GxqOasR2tyyoJROr5CSmhvpXFBkER+s8E5jXl4kslmey/D+cLhx585/fwTWleGxwe6fpAVey74ccTvtthOcuZBYzYa5x3Ty7M060aYqGldb2iuisI5gzVWpB1tTV9balOaL6SwUmsjDVh9S+uybmgyCnNFzkIzQMVpZTocOH/5iqoFo8WEV0vFdwOb9+8Y9vtmGBI3Ps3RHqcz6XIRU5DfUnNCe0O1ljKvrKcL6bJgvJFAgFhl5ewt4+MWvxnacxG4fCmJimKdC9PXN3JbYQs2zZDmiKKIEcmItICWvKSspWojE9RlwQ8yDc8hM59nyZvfde1zLi782qJ3a8nkEFnOZ2qMqJTphr4lO8lE1ViL8x6MuzXpaQmgYNiO9OMgk2xgN2gedoo/vlv5f/7vR348O3j8RDduWJaFNQQKBWctQ98RQiSsAbwTM1vOLMtM13XUWjHG0vWiXz+dLqzh9Hf7wr3Xve51r3v96/rVjejlyyspRIwCPw50u5F+0+HHXhqNNaDGnkplOZ6YX0/ESVziMoFsphpn6YauTdFyWzNGaFDqFIVpWWJqDldJv6mlsi4zcV1knZ/yze2rtML3ns3QCYIFpKHQGtXZW7qRZKi7pgvMMtVBobsePw7YsW/OcS3rd62ZLwvHn/+Fw19+xOgimBddm+vZiP6vl/x5MbNIk6mtuIeX1y+Y0wGolBjkxlcqYS6kEAhLQDVQvbWS2667Dr/psaPoEDWiX1XI6xxOU0NaBYzR9A8bjLeSFJVTa2glTco0p70qoPqO7t0Huncf0M5Tlol6OUIt5DVy+vzMy19/ZD4e2yTRYJ3BWMPmu+94+OMfGT+8wyj1zdijFMu0cPr5Z6avX0nnM7qtYlMUs4yxVlBVSpFTIZeKKZFcRSO7vL0QT+fmvvaYwTfYfsZ6j9/ub/n2WGnQ4jJz+uULhz/9SDidEGI9XN5mtu/3PP7wPf3DHjcMosW85sqnRE2JPM8YJXGXaAVJsud1u0Zk5W8F+aSuxAJIqxjKSknSaKIpIYnEw8o0U7S1wmnVLdUorYHLyzPnr8/kZaVkcJ0n5UQthc2Hj+y//w7rr8EFVVBSKMqysF4OpGUR7a2zzWykiTExv5wok6R9UQvpEm9JUv5hQ78f5RpqU2uyvN/L4cw6rcTlGm0rpqgY5WDhR48TBUIzPUXWeZYmNiTCaUYrhRs6Sq6UJRFDxDpHv+nothJfS1WSgDYtxHURpJVWxClgDLhxpBbIUVKitHFCoOh9MzhJs9iNPcN+h3GuSSeQ52Qdp8OBz//0Z/xPz/yjNsT6Pcd3/yNrHWjBpqTUdOa1cDid2O92OGfpB3DOCRoNwT2llHh6emAcO9Gf3ute97rXvX6T+tWNqNaK8WHD+LSnfxgFxdMYg3GaxdV8ODG9nYlTwHrBBxknfE9lLHYUU4SqbbU5rzL91Jo4BcmpjulbE6mgUJnPJ+I0k1NqzljR33nr8UPXcuydTMmKWOqvK8GKRiuNaRGk5CTGBW1ww4DvJYZUZHKVWmVKOf30mfPzC9OLNGXdrkMbQ1qkuTDO4rxMy1BKml+jpAmxTswkiJkrB7nxyvQpsBwulFRQWpNiQqmK6zt03+G3A24cML0XVmebzpV1IZzOrIezrOxzxm+8RDsibv0SV5nUdk4mmdah0ZjNlv7T9/iHPVoB6yrg95KJMXP85TOHv/7IcjyhasZ7ad5dP7L99JH9D98zvHsEo6gx3Rze0/HC+aefmV9eqSVKWEDfmqdScaPHD72gsrKYpi5/+TPr8Uj/+ES6HOTAUSvGOezQ1rdVIh5NpzGuF+aokSloOF04/vyZw48/E85n0b02eoPxHcPTI09//D2bxwegNH5oBeTvL7Gt7SlNt6vJuTFmO48dR3TXmtdSqMqJLCUlcmiuc6Pw40a0rClhe4u2HtOLCUrLaQScltXz8wvz8Y04T5SQJPLTSkPkNlsefvie/uFRDHIpUZXIQGqt5BSI5xMlR2wnfNJy5eseL8R5kWaZSk2FnETz67ylf9xg+56aiuiAtWwU4pqYvrwQZ4nzLCULBkqJ3tOOPf1uFAlMCnJADPLZTCGTVmnOtdbC5Y2JXAvaObrHLd3QiT5bC5khz6sESqxBuKtKNYwbuLb2VlbR9wO6reCr0hSUMGd9xQ1bus0ghsSS0daSU2G9XHj9z3/l8PkreQ10g6dUTR9eeDqv/OHd73nZfuTHcyJXjWrfBykFlnnmdMo454gx4b3H9Y6NM8zzSgihfZ3c3Ur3ute97vVb1a9uRD/84w84Jyk4VxNBVYr1MrMeJ8K0tEmOotuMmN5JrGDnWsyiQpdKPC2yHtbcflduOKjUzBQ55wbQllzxGAJKVYnObC7rcdPTDb0wIJsTWBklqThGY50WY1VqrNAiKTV26HGDaD+v05GaMqVW1nnl8nJgen4mXC6yptNGUnKsRSvwe4+xThJxWoZ6zRXT2ds0zVorWKnMzfUbp4k4raRUMMbifWuArKff79h9/xFlDXldBJbf0DzGWJbzhfmnLyijZEVqDZjWODQZQ6mtCamVuKwY79HbHeMPv6d/epLpZVioNVMLrNPM6aefOP31J6bXN3KFrhfwvN9tGd69Z/PuiW67laYsC6Irl0o4T1x++ZnpyxfhW1qL6WU1W43A74Vx2UuEZEpiEnMNtr/OrF9WdOfbzxlxwHsvjFgr+CxqRilDQRGnhdPPnzn8/BP5Mt/SuHKpdMPA9t0Tu08fGZ8e5HBAMzehJPJ0uYhrXsm0VlmLsp5aCgYhNFjftXhJLRNHKnmehbmZguhRtW7Sk9Q0zoPEgKIbV7dhhGpiORw4f/1CXMSEQ5H3XjmH32yEErDZyAesSAqYgPgVtWZKEvSUrKrHNllNhPOR+fUESYD2tWTSGkkx47cjw7st3aaDKugmjCaHQI6VGAvr20n0rblKEtjQN9KTpn/ocb3QFWoU047pOmLKLBfJtvfeYTsrTWySJthuerpd03Nm4fqmy5nY0r5SjNSU5LUDSki4QQ53WhusF+12SVmaZifJZb4fcL1g0mo7tGrlyGFlOh75/C8/shzO+E7oHLVpjas2PHz3gXe/ewCV+Pkt8+My8nVSTC3V6eXtxKeP727O+Zwz0zTjrMUYQboZY+ju+KZ73ete9/rN6lc3om4YUFYmHHFemQ6zrNCDOIy11ditrA1t73GDpOeUJPGclEJRipRLiyWs0BBPGFnZxhTbDTPKOqxUclszG6Px3uJ7j/deUpGck5t3KajS2IpOtwQdMWNordFdhxkH3GaD7fpmTCqUUoghMR/PnL+8Mj2/oErCeieSg6bzc05ukmIzobm4lcSJNsYjWoM11JhZp7Pci5PEYKY5IMYb4ZoaZ7FDh99v6fZ73DCKZrRk4tQRw4pWghQyzrF5eIAC6+EAKQrUPCdykDWzqpJ9jpLV9vD0yObTJ4GT+0Fg7stCvJwJlzPT64HpyzPr5YzS0G0k3al/eGD8/iPjx0/ymJqGNqdIyZnldGL+LAYkMad49HaUqZFSrTmXiZP1FqVbxrzWmNEJ8qpJI8S8IxNFlRN+s6Pb7NqhRSQOOcN6PnP+/JXDX3+mLLMkaFlDUdBZy/DwwOMP3zHstzd0U82FqmRqm+NKacgnWROLq1w7j/G9GFS0bY22IJdyiNSayWERnJHS/8V/5Eqw/YjtRxAIGFApYWGeLsyvz8wvB4nOtFbiJr3D7zYMT+/oNjsxLhWZVmJE2FtqEXlFkxAIHkmQZuF1Ynl+I09zO8xpSWAyGrqOzceR8WEraLSUxPRjNGldmd+OgnUSkavorbXCOCvXeOdlLd4mncrKlDDHxHK8MJ1nSiwYAzlFcgwSAztIOIMbBxQN5B8DdZ6IayBep7QlCzoqJSrQjT2m76m5Ya4KYm5SGu09dhwkuc07cdE7ITnUUljnhbefPvP2118IcxA5S7sutIbu8YH9d9/R77Y3Gc7vHzXf54VfXlf+5aUyPbxDlczheCJtMkZrnHM4K3SJyzRj7Tdc1b3uda973eu3qV/diM4vR2kkp4U4rTezku2cGHUGhx+Eb3h1vt8wREmYnajaUm5aMkrOpDZZKjm1WE2JsHTWUhSYqsT1OvQS/Qm3RJyqVcuat+gqvaCsXRW6ZX27YcAOA7rhk3KKpJSJ08z09YXp5ZlwOkvkojO4zdCmNArjHdY6MTUhyTRVC6/TeIkG1S3atMRImWZSKsIhnFdKlNQj62SqagePHXr8doPf78VAgxJZQJIEIHOVGWiZ7gpkHvqHHTkuLIcZYpPtaaQRUQY7bBk+vGPz4QN+GOUxB0kSCpeJy/NXLl++ShOTM8ogk+vO0z8+ML57x/D0TviWxlEVpDUSppn18Mry9sLydkRladTd0AvXPNebeUiVprN0mqpp6Kge5SSHXLW8dQHCF3KUpKdmt5egAOupLXXp8vzM+ZfP8trGiOs7jHe4caB72DM87PHjINebcIMocSWvKylKpKZqj0O1yZvSGmWNaEC9k8nyNSAhLaRlEgOSuQbPK+JFojVde20kaUoOJigxlqWYCOcT8+sX1suZkhNQhB3qHH4zMjw80O13LTCBtlJXLRQiClh/Xf8VWF0pRZgDl5c3wnnCqBZo0KJNi3EMTzv6/UbwYzWjjaViiXEhr5H1eKYsCY2iKDGOAeAcZvB0m0EOWOtKLplaHGVaWKdFonIXIVfIry/UonB9R7ff4DejHAxyocZZDp4pSbNaKylJ2ppz7mbGM1YiNfMSaEJwSkjfGKObjRx8qe39kq+pOK8cvz5z+OkL8+GIUuC8aQcLix837L77wPa7TxhtbvgubR1pDcyHN/SXZ/64Rtbyxs5veLUd5xyYg7oiZWUT0lz215z6e93rXve6129Tv7oRDefWMFCbbkuQS65zbRLRtF05Ey+BHCKlrSqh0XlqJYUksX9BAOM1ZVBttd5W0tq2zG19zXP3WG+kEbWmJdJYNIAxQGn4IGlAre9w40ZQRSDr8ZyJpzPz66vgpw4Hcghob7GdBa4No0Q+GqOpSqDyEp9osNtBEE3X9W6LqwzLSjhOQgJSirRGahZ4tvMevx/p9lv8dtPSoQxKGclLzxmUuWlilVaSttNwT8v5TJwuMoVcZ6gy5TLGol2P3e7pH5/oHh7k9xYBtafLJAzP56/Mr2/E6dKabUe33WC3I93uQWD7uy22625InjjPLMcT05cvrIcDaV1QyBTb2OYQ14qcJItcg/y9BWGQO9EEayvTX+lYS4PTpxZ9KQYUqsgt1sOB9XzGjKMkN51PgsbKYkrrNiP9w57+4ZHhcY/rGhC+jalzytQwk+aJGIKs1quwVLXx364ZJeYhZQWLVEumhECJa2NxNqNPooUVCM/Sb7YtYcrJzyooJZOWmXWaWA6vpItMismpBQj0+GGg30sDanuJceUa5ZmTvA7td5WWS6+MJYdImCXRaHk9s14uuE70wKUUXO/pHrb47ShShlpQ1Qh1omrRIp/OpEnIEdZZed654rzDdBa33UgG+7I2rWkCbdphU/LkBU2lbngu7RzdtqfbjWKkU1o4rctCCquYybSmItezdbbFlwoxiqukpUhna5rcR1lL97Bj2G+xTfpSm3mMUrm8vvL1X37k9OWFmhPdIN8JCon8HT99Yvv+PX4zygWRVrQxojE/XSSE4Sys3xwTPn3ld/6Nh6T5GkcO7oGFLVlvZZnSWK7OWrrO//d/w97rXve6173+m/XrOaLGYDtZuwtIvKUjldKaDIGG59jiDRvz5zr9ikEiP2MIN/NISbVNLMxN22msNIHaGllnmrbSHFxD6Ajr75oZrZw41o2zkq5jHJrapp8SG7icz6ynE+F0Js5LS2ECO3TYzqAVMqVS+ga6V0ajdLuJKi1NVd+1qWu9JUpJqtRCyW1Sa5BJqvcMrfnsdq0BVUryzJWwVa//+2rQEGe3Zp1Xlrc3Lq+vxNOFqmTSSK247Uj3sKfrR9zje9zuUTSRFfK6sl5OzF++cvn6TJoa1D1LvrndDmzeP9E/POB3W9y4RVtNrYLyifOFeJaM+/n1wHq+CNJHa5QT85d1tq24Naq2iV4FzHUK7SS5SLVkIioUkWekZRFMVsnSgNMQU60pjetK+fy50QdUW/0KTqt/emJ8epLmRwtsvWSZpqcYSIsYYWoSraVSSuJOO4/teozvbq+hjPYKZU2UmsnLLNPJdpiKl1kOHn2P7Qb8bo9xXQt0cFStCevK8vrM+vZGbFNUYcVmVAW/2zJ++EC3GbF9L7pTSXUQCHwSggJKU5HpptaanAU7th6OxCsPNGWk5xaYf7/fy2rbNC1syWjvqMowT4H45SCpWlkiXktz/tvO4sdBJst9BzWTThfyKvIBtJOI3mkhhxYU0abySguqrdv00lAr1YxDEqMaQyTFglYVreWzUK1BF90OoSLdqFnkBmiJRDXOYPqRbrfFb3q00nKA0BaMZp0XXn/8zOGnzyynCa0UXefFKGg03X7H7offMTw9td0C4so3hhRX5tcDy9sbeV3RudwS2lAQpoX1OLGriqftgdluOOYn5vEDpyKfi8PxdG9E73Wve93rN6xf3YgO77aYNq1TSkHOpDUQY5REoSwxebXUlrstbMj1MjFfZkKQ6Z81wmasSmGdJP8Y1xqcpsk0LTXpOnmUdb9Gwm7EwGK6ATuOuH5AuzZRRCayaZJ19HQ4Mp/OxEtLL6qIlrXl3Lvey5imqoYrEn2cNqZN/SzKe7lhdp0gYEIQduIaSKv875oL2omDvduO+N0GN4rJQllzg+WX1tQqJRpIbZz89a1ZD5cLl5c3lsOBNAmeSSlwozQO/fsPjO+ecMOA8R26k/V4PB9ZDifm52fC2xvL6SzooPY+uO2G4d0T/eMj/U7eR6WbOaQUltOR+fmZeD6T1yAu6Na8ymvfEEydAy3JTiULPkeblps+dPL3KaDqvzEp5ZveUYg710Y8i4klBIHC53pjf4qut2fz4T3D4x6/3UlUa4vErKWSo7jJc0oyec/XVB+D0c181CI/JcTAtuYpk0MgzdcVvCYnSbDS2jbcmJXoy3Fs008jUzstOeXr4SvrocVxhqZ/NLJi73Zbxocnuv1O3iNzbUDF7V1rkceL5M/Trg1VDMsq7N31cJaGuggovpaC7TuGhy3dTriy0JiwgLJWQhxezoTjRaQvGnRtNAfn8Jsev+npthuUghharvsa4DpZLjJtr8aAMZjWGKeccYOj221w3t3iV2sRac06ScSuqgqVuUUBWyfRuKolllEqJcnKu1QwvWd83OO2W+EPN6A/RqD3r3/+ide//MRymiBnnNHtMKowvmP//Se2H941raloT5WVv285T8wvL+R5vZnEcgpoo8m1Mk8LcQkYZXDeYol0+cAwnYkcWcZ3XOwjr8kQwh3fdK973etev1X9+qz5FAX0ncSpHddAXGKLThTHcC6S5MIqqJZ1XgnLKhGeRuGskf+0KEjRYVps16GdgSoGHQWyajQabUSTiRYtqExkR4n5NEac8kgW+HI4Mr++shwPklCUM6VUcrth+94JqNp9iw4tuTbdpxGTjbOorq1xG9apxEQ8y7Qwt+errRbkTalUNP3DlmG3wY0j2igxwDRMTW0xnVzZh00XB3LTXs9nppdn1reDIG6q4IKMtfSPe3a/+4H+/RPG+dZYCV8xnM9cPv/C6cefCJcZpRXOaazVFO2w48j4/gPj0wO+F6yUUhqqrB3nL1+Znr+wHs+C1WmmI9NZdFaoVIDWuDdO6tV1L/pgj+17QVVpRY351nDdjD5tHVtb3GOOTbKhWmNWJOjgKq0wgzSgmw8f6Hb7W967NO9FojtjkCa3yNpeo1DOSOiBFU2mNr41Nu2l1pqSInmdScsiTZdVzRBkUEbIDn7To68osKYtpYpB5/L6zPL2Rk1Bmt7r7zaWfjcyPDziN9vGobWt8UrSUMZV/pnzTS7dolCraHGnz19Z3g7kKNGuNWdqLpi+p3//QL8dMFoJR9RokbJYMcMtr0fytNwmpxhLbu9lt+tliuksCk2aFkoMEjWrtbA1VcYafbvmjTWk1TEfTsQ1kGshnQo1VbqtoJ1qrqznC+u8ShKTtVjnyCXfIlONt1gjoQ9VAdZQaiWlzLjf0u93+M5/MwJaS9Wa6fXA8z/9icvXF/KyYiq35lerih89+999z/677zBGSwJWm4LnVJmeX4inAzVGyFVicm2lZMU6R6bzIjKV9jir1uQK1hseNh2uy5T6QrETX82Wfwp31/y97nWve/1W9esbUWWIoRCWWdaFpWFSWtJMDIkwreQUqUVuADEXSssGH0aP74QpaZ1rCSaq4XQkUlMpSdGpjfWptAbr0L6T9WjnmobOtGQiRQ4r6/HI+efPXL6+kXNuMZZtSgb0vcM5uVGilWSeN7SScQ7fi9tfaY1u61ysIZ4mwtuREmLDyoiBqdZMjgk3DIxPj9hOEmTQpnErxXSFsjce5RV2j1JUpSXN5XRkfntjPR7JQZzdioKyhv7piYff/4Hh/Xt5viVLU2QscZo5//Izl19+Zj2cbhGOaE2IFYti+7sfePzjP0jEai0tJlKTYmR+e+Xy/ExeZ0pIUOU9qFXW06WlABlnhNlaJcZRHptuCKyWy45MoUVeaIjzJAgqxOtTYpL/rf7GbQ3NgFKpQaJj7dizfff0rQHtRI9LasSFGFlPR0qKrdkVh5F2VugCvpc4U7SkEmkjq1olzWBeLtT2s0opcJYSImld6J+eML4Xx77WbeJfqUo4oPPLVy4vX8khYMcO3VnyGiml4vd7hsdH+s1GVuUtf70WyWmvJcnramXKSCny/88QY2R6OTC3hutKchAmraH/9J7x/SOuEwNXrZk8z8R5kfNeSIRpRucqRAKrqYh50HuP3wy4oYNaKSERp0k+y8YRwypJRUiSlKRuSYRrCpF1mig5ioYzJHKSzz7klmmvhalaCr7zWOdJSaJ++61wWFWRTUnN0ohWVXF9z26/E3STbeER7fOcQ+TlLz/x/J//QpwXvDeY3pFDBi2pbNYbnNPEwxtnKv3ju0b0sCynE8uXz+QYRH9crgqCynpZWC4z6xywDcIfwrcm2njH5t2GbtM3Tm/BmERf33i3KdzrXve6171+m/rVjeh0PFFW4W1qe20Eq6CcTjNxWamlYn2bNpqKUwb/OND1XnRzfY8ymtDQL8JlNDLBUhqlJLMb08kKve+x40bWeyh0AaymAuF8Yfr6yvz6TLic28RNJlGl1hZJqLFGoRH9negZFRgvbNBOANZKG3JrAEA0gnEJxOMFckF5g9701JipVcxa3cMON47CFNVGJoLQNs9eJAxaCf5FXcFPEENgen1hPbxJRGmOgoPKYH3H5rt3bP/4R/rHJ1Qp0NiXqhtY3144/vWvnH/6TJgXyZXvHCllwhowSjFuB7wzmLySphP23SeohTBNnF+eCac3dCmk9n5RNNYbsJIprrJEHIp2NLc1apFGvpOYUeNFplCD8EErldz0mleWrEwCK6XKmpbS9MBKN/ZqpqQKxvDwu+/ZfvqI2+zQXgDnwhCv5LCQl5l4mW5ygWvKknZeMFON/amMo4YVjOiTS8nE85kSvxntFKIxzvNESRm/2eGGLcr3rXOWpiOVwvnzz1x+/rHFXHbYzlFDIqwB63v2nz4xPD6KIUvbtt6WqXBOoU1bFdp1lBypQdbguVTm1yOXX76SposcwJTwNbVx+I1n/LDH73bUEMnTBTtu0VYa/eX1SFoDJYmcQVvTJvUK03f43YBzDlUzNUh2fAlJTFBU4vmMClGuWyMazhxFNhDmheU83abNsm+Qpt90Fus8urTwBufwgxwAYkrYwePHQTTXyEFMPlVyiOu2I33j0srBSN103vPhxJf/4z9xeX5FUaUJtaIxrrbiB4/xVl7rIglj05fPpOlM9/RetLbLRKXF9qaMcv6GewpToISEb7KbUivWdpjR0G07xqdtu65kK5JDksjbORBejv+e79h73ete97rXf6N+dSMaF9GsSeOmWaaVMM0NOyP6LTtcV3sypbJeeKLKGLkpC11GJqNDf4tVVArREWpwmw1+t5MVa1u7ywhNANPL4cDp82dZRy6BqjTaCZJHN+e51S1FhutqXFGt3MSUkwbUOGFOllSoIZCvRquWHCTSAWSFWQTdNOxG+ocH3DDKP6eKli+35BrX5AJFpjE1ZaCAVoRpZn55YT68sZ4mypokFcgIemn3u+/Z/f73+O0OUNS4CuTcO+bTibf//M9cfvyRHBPWe/pReKg5ZZSCzbbHeXHkSyegWV9fJMd+Xphen1Eli1HDCE4qhQKqknNF1Yq3HcY6WcWmCGihChiLHwa0l8aipAwlkWIkhXjD3VynriVngZZniTGVXT4yDU7SmqhxYPf779h9+IDfbARV1NbjpEiOK+H4Qg2rxGuahocy3CQB2nRNalDFNNdbjO8pYSYeXgjzhMqlSTsEG4TRpMuEdT39xwe087IuLxWVCzknzs8vHP70Z9J0wbXmO4coE0RtGN+/Z/fxE3boRHva1s/kRFxXclwb/aAB/NvUsSjN5eXA+cefycuCtZ5uGIlBKBN+MzB+90GMeaVCzOR5pdaE6TuW45nz51fSHJrhRuHHXtK3KujR0w0eY+TgFk+NOuAdqusIl5n1eGkUCNFUq5zFILcshIsQB67JZbQ/5wfPOHQ450HZNu0tsu53htwOoL5rDFglRp9aCzR6QLfdYPtOmKco8YZRKbry9s9/5ev/8U+s08yw77FaEeZIydCPHrzDOtNkDbJxkM+NSGjC6SiffZSQN5wDawnzyvR2YV1i07QKoF7lirGabjvgHzfyHdWCCrQxokPOldPbmfU8E5b47/6ivde97nWve/3X69cD7UdLLZr5vLBOMzUVbJtouk7jnaXbj3SbkVIVVWv50rda1pzNZa+0TDRoCTRKCWhcb8Vh7ocBrSUCVGlNVYq0Lsyvz5x/+oXldJF1nlaozqGUpPJY0/6+KlzPnIughJomVVaXrjnMa2umZA0ZLhNxFje/bo79ksTc78eB7ftHut32hpWqSstzQImZybm2Aq/CWczlZtRZl5nleGQ9HkiLEAVKzOJ+fnrH7ofv2Xz4gB1HgNtEsaKYXl85/OnPnH75yrqsGA1915icVR6r6zymmUFqmwqWCnlJlLIQv3xp0y7V4jYFVVVyFbOYUljnWzOVBT2UwfkOa4VIoLRMxUrMFCVr5zg1R31FpnkVAdjXSlwWOSTExK2lac5rOwxsv//E9vvvccMAykLTZNacyKcD4XAgnA7inu4HnDaoFIWO0HVY16OBGgOqG8D3t1CBPJ8Jb8+UkMS97UXnK0gph9Ya9/Thxjat1lBToMTM9PLG8S9/JhwPGGfwQyd9cVgpFWlAv/se1zBMStumiZ6FI7os5LhAbc2QMagYG4ZrYf76RjxfKMssJrMUSLWiO8Pm0zuGd3uMl4+k9pJMVkokBzh/fiU2zSbaiE66c2KqU7olQ4kxq6RMWtfb70m5sh6P1JjQVQxduVauHqLpfGY6nmUarBW5FkoqWG8Zhg7vO6xxgG7NpTSotUmdrbPyuYsVpRNkQItEwu639NvNzWiWUxAHvfNc3o788v/5J+aXg6Q6DXLN1SKfD2stSl1Tl6yksaXQCBkeZYXgoK0lTeGbPtUY4rxweTsR5ojVFmUVa8iklBiGAb8f6fc9WhtKqrjRoF0nOuS1MB0vxGVFKc3mcfPv/Jq9173uda97/Z/Vr+eIrqsYHQpoRGOnjRhZuqGTxBsviCVdBTAtTVeSG5KWG0yNQRBISqO9w203dA8PuGuEnwQiSa71PHN5fWV5eyOtKzkKjsb6NgVt+dlKKcnFvgKpQSZgQ0e3HUUb2owjJRbRq8VEmlfiFISVWGnRmQaspdv09Psd3W6D9h5SgZooLUdczFLiSqcWSIkSIzkF0rKyzhPr+Uw4nVsjKA/Mdj3bT3u2P/yeYb9DeQ/ayhSqiCM8hYV4PnL88a8cf/6FGCK6EQuK0XS9F8MXgu6pWtiTqlbCNBPmVUxcShFDkmbRGmKMgliyBqNqm9hdHc2yPlXOY3tzaySUAkqi5NqyxhfyuoqkwliowmhVKaGsJoWVeJkl1cq0mNVSMf3A9vvv2X73UTR92vzNVFkawfD2THx5/qYRNhqVEyVbTD/gfIfpBmla04rStckhCnWN5OUCOcj1acTcQi2YYRANqDaiH1UKjOhBy3RheXvj8NNn1uMbWlcBvCst77VWdNsdm48fxXEO34DzOZJiIE4X0rygrGvc3Ey6rKR1Au0EIfR6aEEOpQUzibzA70Y27x/pdoMkZLXYzOohh8hyXojnmTQtkt/U9W3iJ82k0xo/dHKGWCIFoTnUqlBOE6ZAjRGjFNUaYhEZBaWyhkBcVlKKlNZgXmUifugZNgO+8/TDKE743DLtUShrxYxkGz84tajZVCnG0I3CT7XOfyMGlIw2jpjh63/6E8e//IimMIydHO6AkrJMV70Spq93lFUmmqpUwMhUFtUoG5Z4nihF6Bu5ZJbXI/NpolaF7Xo6awSRpaUxf/rjD2w+PjVe7SQyD2OoYW1GNYVWhr4FQ0ggx73uda973eu3qF/diJY1Yho8vhqDcZZ+7PF9J/rIVMTQUoXJeTUz6VohJarWcgNr8X3dRpoD5T0gpqaSM+F0Yjkemd8O5DXctIZKabStovu0BtNQT0oZUpZoxFog5SKGqVqxGtxmoNYiJo9lFZA2AFpcxt7irKxutbG4jcDnXd9/037WCroCXtacSsvzqhlSwwEtE3GeWKdJbu7rQg65AdmNJOu8e8/m0wf80KGMTHTk14gJJc8TabqQoxiXxnGgfnji+HLAtpu76xzaGhnXtgazlEJYGqezFJqHmHUNKAzdMOB612QTMhWspTmZa2OyNg6r7URvmZNgl0qK7bkk0rKibxNUTU6SRY41ooFck8RjpirIq77DNgbo5v07/DDIml00D5KlHgTDFI9HyKFJMdoatfOYzUY4nFrW7qo1Nkp1Nxd+XU+3CXEpqnFfv7Eq3WbXVq4AVQ47y0w4Hrg8P3P65QslBPzgJdO8Kqoy9NsN4/v39A8P0jDHxBXInnMiLgtpFQe+6az8XFaNehAJrxNxEa2ozqXpojXJQLffs2lGJNUeE1rL89OR+TSxHC6QUkNaNaSYleZL906c9M61CegsBwTrUBpSypTL0iDyLb2rmahKkpjeHINovrU87pwrWmu6bUc3Dlgretxc8zW2DEqWz/52RKnaaAu1GdwMdjvid7Ld+HadVtAdJWeOX5758p/+mXg4SnBE77GdFXmIUfi++wbBr+UGoFfa4IYee53QN7lOPLbPi7HMx4nlshInCSXw3t0SWY31bL/7wPaHj/hxAFVx/YAfRuKyEOYVbTS+6+lHw2a/Iywr0+tBDlb3ute97nWv36R+fSMaa9OVafqNox960WVpJdO8Ft2n2tqc0qI8VRUA/ihoIzcMMolr+s1SKnGemI9n1tOZ9fDWsr5r03wqlAGyuOydc62pUNQCVVeqVoCR6VTK8ruVIq+R6fWEdwaSYIdQqt2WxeRhOoftOkmJ2mxl0tkkAfVvEpvQVriit8lNkkYqRtbzkeV8JoeVXEAVqLFiuwG329Ht94zv3+O3W8HF1CQmoCSmoTRfiMcD5Ei7w4pRKEVZV373XlKkFG1FqZoBJRKXSE7iPMcaVNFNHiBTLd/1WNfiSJuRS0DqyCS575q+s92xcyHnKI1ojqSLuLS1Nt+aWEqL0YzC3dSaWiTQQCkk+nG7o3/3juH9e9zYo2qjLKAo6yLPeVkp6yINXpE41FoypUBKFd2NuP2TJGql3P6eZkYpiRqD5Knbb5Nb0ChvMf0oWKma5T0zllqS8F+niXA6sxxeWacLqhbBUxkD2uK3O8bHB/rNiG6Gl9tjL7lNhldAmmVJiJLnZzpPPF9YjxfSZWl6YySK1Vrs4Nk87BgeH9DOUNZF1vy5EC8rKSTSEshrRKVCJUtYgHVob9He4keJrtXGUFOmhNgOBJbc9JsaOVzULE19iom4BAHdl0TNCa0N1smhRBlwvZYkoV7idGsjNQhbVbi+bhjFiCdQX/kkpYzpBrr9A36/bXJgI/GpVrTC63nm8Oe/cPjxR1RJ9JuenAray/TdavBDJ9KRigQdpEQtLSjB2xYn3N6PXChLIK+B3DYB83mi5orVkvamAK0UfjsyvHugf3zA9G1Ci26vRcF4z9D17ZNXBD1llLBkh563H3/5e3zX3ute97rXvf4r9asbUdt3Mo276jO1ElOMMTTG9M00UatCW40fHGYYsKPkvZsWXVlzJqVMvpwEj3M8cXp5Jc8rKSbQCmdEj6a0kgjRXsxIkkQjTaIMe9SNF6mdxTRsj66SU62RwaVEMzZclFIiK+g7/GbADtJwgKCoSosnFEIl0P4+cqJkwRCF84kwXyQNqGVr15JR2orh6uOO7vEJv9u1VB8tP49MDdN0Js8TeZWfa/tBWfEnQf7ItEkSgqpCXnelCGsUqUJzTtPSoFBQckUZSz8O+O2A9V5es1zk8SkwnejhBNxvZOXaVsI5RXIQlmnNiZIyWpmGX0rQGKcppmaUatnh3tLtt3T7Hf3jI373gO03oiUsRdzz60KeZ9J8Fpan0k2OUAQ0HyM5FtG4FlCnC9p1uO0G1/WtcWhoHmhO+XY9lEReFnm9dluMdVwN25VKCUIRCKeToJKAbrfF9J7VXai50u12DO/f0W027TAlTvKKJuckuekpQs4iOcDI61qVZMp7majabqAWiOtX0rJgtMVuNxLzOjpha+YsB5cYZeoYMstlpiwCXbedo5pMTqC8w17fTy3Xrkx1lyY3iS2lC2no4fbZKDmzzjOhpTSJTENRMAK9R2OcFpc93A5xGGHrKitUC9N16KrgKuUgivFMW/yjIKxM30GMou9uk+84TZx++pnT56+EwxFVK7aFRECS5tYZrLXy3RIzuQp2zVrBlalOKBoSI1va948h58y6RsIq0hdrPUVVtJKptHaOzftHxo/vxByJvDBKyWEop4S2zWDYtDOqJTpVBctlEn32+fTv+Iq9173uda97/bfqVzeifrjC1IWVqVWbkF51hLWgjBU3s/O4zouLvGV8V61IIZHXhRyC3ETDIlpRren6jtDW8MYavLONAymszwotrjA1Y4xoEFUp2MHfVo+uOcCNFlg10Nywsta0Q4frZUr4LXFH0o3UFWCuVIPqy3MU5zxN83kiXM7EZb6tpiXpydM97fDDiN9sZR18bW5LIceVvAiMvaYoYPd1vXYMVI2wIuNKTQ2A2FbLmipTn3mVtX9IbS0twH6jRatrrMGOPW6QKEbjHaWl2NQsmlDbezHuKGlAS4iSFd5WrLUUdK0t6Uhak5QzeY2kNTbGpW5axoI2BjeMbL/7QP/0hNts0FfzkLLCpZwX0vlIXiaZYpaMUpaqNCUsoqFtTUYpVaZfvsN4Q5oEtq/3ewk5QIkWE0UNi7yWjc1Z4irO/POB2m8kcadU0jKL5CHMsiY3+krTwg8j3f4R4zrcIA50VcRIh/WUWqRhbDpKVXJzYEu3rLtODlm+E+0mFe07IUZsN8yvr/IajYNM+0ppDZBM7OMSgHpz7aMEXVVqRVmN3z/Q7bdY79BKSdOZCzXJf6coOuzasuCvk1kUxGVlOpwJy3pr7EqqhJBFY6mNRNcaCVzQpuku24HPjh3WO0SXqajXbUKWaFK3f8CNo6ReoSghNAmNpdTC9NOPnH/5wvz61pK4Gg6qKrRRGGNxXsxGtUCpRa5lZxqPVTVDkr/phUUaowiXhel4YT3PEnbhPNoo4hKpGobdlt3Hd/RPDxh/BdK3CW6Rz9d1kq6yYOmu32elVk5fnnn9019ZDscbYeNe97rXve71969f3YgaL4lESmuJ5K4CaVdGIPDGO9wwYrr+hkJBS5RnDJE4T6TLpa0xxRxUlaBSyhrRgO88Xd9J0s01jhHIpZJWmfoYp9oE0DSpgKLELGYjpdG+pRhBy7RX+L7H77bYYUB3stq/TtVu0x/dfq5mVM7fOKnLzDpNzfl+Ji8yxapFjA/dw47h8Yl+v5fm22jRf7qmYVxm4vkkK+harg8J1YxJ1wSda266NlpMU00ekGNiOV+Ia2yT0krKlRgEmt+PPeNmxLUDgOmlgUM3c1YqoO2/0teVlClVGpkcAmVZZdJFpcbSEqeKTF2DyA+otekNRVJQaqHbjmw/fRIG6L5NIbWst2tFolZPb5T5cpskQlvlA2VZCHMQwpWTyFGjZaJ71bPaRjxQ1+bBWJnOLos0trVNLZVQQsmVcj6S1wUzdwLjX1bR+SqDUu3601akE+NGrlljxLDV/p5SFPH6uLWQGATVlahGkpjcdpDH18Ds1wx7tKSB+d7DbtNIDE5eV0C7nowi55lrWpUqtW0VxMSnnKcbO2milKKukXSN/FSKuAbKKtNh1dinRYlJMK2J+XRkOl6EL6vF4EZV5JJFX+2sXK8NcWusa9euaV4uwa+Jyqa0z5K0ctp3+Md3+HFES0Zte30VKElcOn75yvnzV8msL7WhlWghEoZu7G6fOdnylxuxAtuicLVBWddiZDuZQufC5csry/HcCAKNK1skvKAfPcO7RwkC6CWF6kZCbSloV8avarpdOVRkMJqwrrz++AvHv/5EnOcWO3uP+LzXve51r9+q/k0T0WsyEEjqjO16/MOD6NXalEg1vmFVkNeJ9XgiTQuy9lK3BrYUgWdLBrxkvBtzdXEr0QmW0lzIFeUFDxNDwg4SK3m9xagqKUxat0ldqWhj8PuRbrdt2s+urTRFT6m0TNauTmWusHRjqWTCNDG9vDCdDsQ5kOb1xj2tFexux8M//AOb909Ya274IJppKq+BeHojXk43APt1FZ2XhbyGFg8qU76ScouoFAd9mpY2AV2aTlbMWTFIwk6/7Rg2G/rNBjv2MggrFWUbU7NUQDcdrKznS8nUBCVGSedJsqpVummAlTjcS4qkuMrEV2Zn8rqVBCjcZuTx+49sPn3Cj5JqgzEo2wluawmE5y/E47PksP/Nc5eJVCXOs7wGSiZzV2yV6XrsZoNrzbVSGlUzJUeUtuQayeuFcLnI5Wiu6/0ruzWhnKOkBC0NC6VFXBHk7/O7B+xmL3GyrZGpJTfYfCFOE3ldqSRpMptmsaQkSVzbnayqm15YkrOKpDWVpvG8XGSSa67626adxrCeTqRlxZjr45bPk+67xi11jY0fyJcgOs0CysiqfT5dyGuUA0uF1Nb7vnes5zPz4cJyuRBiFt22Fk2zNpZu7LAt1UobJc2abdIWKxpo1bBqxIjqOknYyhlFxW73uP0eY61c1zJKReVMzoXTzz9x+vqVODXtq9bkIkEH1wbUdx7nRVubchbDnHVyGGqw+yuD1QwjUKi1kJbE9OWVcFlwfUe/GyXi9DhRATt0PHx6T7ffo6y6flWJkTEnqpKgBlKQ983IxL62bc58nnj785+5fHkltTACe01Lu9e97nWve/0m9W+I+NTQ4iftMOA2G6xv00tAxlpicIjzmTCdydPUjEEajCOHQoorcZUcctWQSUobSmy6xFoRSIyS6UhLyNTa4jvJZjfKoLJMaoyRG3xNmeol/9z1A26/xfWjcD6NhRwFW0NDEwkgst1HLfiemhPz2xvLyzPL+URYVmFnxgT5qgew+L7D9RJBqbsGFC8CNE8xkZuDuYQojw0lzUzK5EWyzqU5bUlPSONMqZzfjiynC6oqrBM8Um19rLaWvutwfUe322J9d7vRUjO6rRBrvaYPyQq6tkYpB8laj9OFmgquG75pbisti73FtNLWw3+DxOr2O3Y/fMf2u++xm01rkGTEq7QhnC8sz58bCqppV0tpf64QltYAl9qkHAbjusZklSSt7mGL2+0xXScN5jzJdWE9OSXycpaG2BpUKZRlEolAO0RcdcEqi2ayaEVNK+SC7Qf8wxO2H8A7mfKm2IxpinC+EE9v8mytBZRMU3MRucl2jx83soLXLa4zSy48WlPiSloukqBE+Yb2aqv2NAXSdIaSMFT5V96hijRf/v07jNaEt9emd20aXO8pxhEvE+v5gq5glBiRSpvAllI5fnljnS/tn4MxhpIrWlds57Bdj/MyqddG4bo2yW1xudpaVKmUdUVZg7qupHPCjlv8ww5rfbsainyutYGcmF9feP6XvzC/vGGcafpdJTxfFLZzDIMXyoZSYhqLSTSZSuQexksYhnZOTIN9RymFdJyI08pyOJGWIKxho8XkljPDXuQwm6dHbGdEQlBpmuz2DeQdqiqI6y0Ot6Yk142zXN5OHH/8kfV0xliF671MnudIWu8Rn/e6173u9VvVrwfabzfYfviWMd5QMKoKdilF4Yym6UKJKyW1qYq1Mv08H4jLImtArbG0mwHN+Vsya0yiZfOCEkopU6PoN41XGONwTow5opPL5Jox1jY80gO2H1DWy7RTaVQt1LDe2KKqBMmCNxatJa0l58Ty9TPL8xfiNDVzTZFJq2pRpErR7zair0RRU2T6y18gBba/+wMlBNJ0Ep1iVbepTo2BElZyLGLuqVWaZ6vJodzIAeu0CPC+SvY1VVGNNCrGOrqWJe63W2lMSiauM7WA7zrhSzb0UE5JpmcxUoKsclNYCaczJQSB/Pe+rUUzKWRhSS4LOUlKlFKKkhNFa4aHLe+++8Tm+x8w3lOv61BAGUcOifDymXh6Q2tQxgjQPsjkKa6RdVpvqUogTbXuPMZ2kt4zDvjt2CI+tfxszVQtee/pfKCqivZOEnaaSadmGs1AHNLo1oyXBtNPCtN1uMetxGQaC6aFKqyzAPhjYH07kOcJbT3KG1gXCT3QFrvd0u322K6TNW1p6K4rezNH8hqbxMNTew9VXP3F9hKa8PoGuWC0mJyKEqyXqhazHfGbDpUi69cDcQkoCsYo6DpiriyvAumXrYEhZdGZUhXL4cJ0vFBKwnVGUF1ZGn/jLZuHEec8Wls5rBhNiUkQTznjOo/tfXO7V1Tf3ab7OWf84xP9wyOkKP9RCppMJy2LRKF+/sx6nATx1phJpUhCUd87fGck3jXLGj+nDMahjMV0lm43ops+U6v2ucuZEguX5yPpvGKsonvYio6zZEHKecf44Yl+u5GfUU3TjYISGnt1EERWySIHAuECK02qcP75F5a3V8J8JqeIQslnYs343cjv/q//07/rS/Ze97rXve71f16/uhEd339oa04juqlaKC1hJ769ihP51pxo0IUcM2k6U3JEK03X2TZ9azcabYghEGOWe1dLRVqnGb2skhZjLNb04oQtBaqmanG++rEXIP5+L5B02yDpV4B2Fc0lWqGLOMPRGtUJzzKvkeOf/8r89TOlRHFJlyqwdi2u5YrB2x7rDNoZchR4PbVivKFczkx/+Rdx3TonQGytRcsXAiUslJzJocUidhZlLSVmcpAGbW2mJWs1qkJYI7az9MOAdQ7je4zz+LEHSsP7BJTR9NsR33co5wSXowx6nllOB3GSpyRBBG213e224jRPWbij7RCQV+F/lgI5J7TVDA879j/8wObjR8wwgHWSrJMzVUFaLoTLWZ7jssr6O4n+t6yraIPXJBI7dc0tV9KIuw479Lixx/ct8UnbmwO+5kjJlTSfyWFG9T3Kd5SwUmZBLiml0V2PUgbVMsZptITa9KR+t8cNG2HCghACUkRrTYqR+fBGPJ1FGuK8UB+WAGRMm6A63zVH+jecUa2yVs/LRImrMHKrFimDvmp8O8L5SJkmrDVUZ2XlHxPKW9z+ATt26FpJB+FV5iiGPYwh2454mSnrKuY7bSg1owA3dJQYuLy8sV5WNBVrLdY4kaZozWYvEgc/dJQoHGDX94RlJaeM3ww4629oLTklNIkGoMYN/WYr+e7LpT0uj3KaGjPnly8c/vqTpEWlKJptJ42oIKEMw+gxxlKTNLWKLPrazUgBQaf1neS/5yzvec5oHUlrIEyLSAIG15pc1Ri3mX47Mr5/xF4DEpTQBMRSlcF5mbC2sAashSxw+uo8cVo4/PxXMVPNQQ5wDUdX0bz/x9/z8X/6v2Afn/5e37f3ute97nWv/6J+dSOKlSlSbhrHeDo285E0Zcpa8aQ21mMOK2ltq28nzFFA1tGlENZAqWsjQAnSSRA5Gec81jmJmLRtcqmAZi6wXSconO2I9l1zv4q+saYkq3zXyXAsB1RKomOznlory+nM5fkLy+uBGFa63mOdoebG56yKknVz3lcoiporISc0YHqHHzpc75r+EPRmlClijKQpkpdZGrYqzU8pYLyYt9K0spwnwmUlpdzc8YgUoFa5wW4GjLPYrkNZmYaWGCR1h0q3G3FDL6ttY6BqSojk5URJgTRPrBdZa/uuw3YjtYjTvoYkIPZaqakQYyJn2cFrZxjePbD//hPju3fYcSPTJaXldUhZXOiXE/F8pAQBgUvUqialTFqbTrKIftdqed9zEXSQHQf6x3f4saUEXQ8wVx5pWgjTTI6rZKp7Lzre9phVOzBI/Khpkg6oiL4RY3C7PW4YxWHfDk5XzWBOkeV8JhwOEmiwGUX/0a5l03X4h0fsOKCMkA+EUcoNa5WW6cahpJnrlGpNTKmiM71cWiKXIrefN10Hwwa33+H6jnw5Ei8L8SIyEAzgrEzkXt9kQ9B1QCVnaaCtd8znM9PbGU2l68XdrxUoU+k3Q9O/SviB8Raz21JjJqcVbQ3j8IDuOuHrJtF/1tgCGDrP8P49fjNK04ySeFTfTGjLzPGnnzj+8kUSlXKRZCQlyVKmfaaN0WgMJQqFQGvhuapGsHBdL6lnqorzv2l8c4hM80JZQjNICrKqpEJBGtzNh0fGxz2m69uEux0+c5KUpV4oBqpKbGnNlRqjQPitZToeOP/8E+F8IS8rKWQqYFC4ccO7/+EPPP6HP2D6jeiN73Wve93rXr9J/Xqg/bIS15UwXUjzhGqAceU6VIWCANDLvFKvWCPv2w3aiEGpZtFQRplUDrsNVIinmRgrfhzpm2np6hxXVRJtlNX47YZ+v8OOoyBVru79BtQHiah0Wv65mJDqbYobTq9cXl44f32BlDFeGIlFNec9Cq0tVhnJoI5ieCkloazBd+6WPqQbWN40tExJUdKRVtFXVmpjaNJ0lIWwLKQ1StJTyKK3tZoUEhRhtfpxoB9HjLUY227AJVKSxvgBN3aYTlA+SouAtuTGyVwWUlyIk0xhbXOeK9OSknK6MUAlcvGqH63Y3tNttowf3rN594T2krAkGlVFDYG8HImXI2meG2OzSpOVxPxFkmjWvARSzFjn0Ko2vqrBjz1+t8E/7rFd34xoomMtaaWsgVwzOa4UJWDxNK/yOjfQeV4CVWmM76TJj1FW8kokImYY6T98kulZawppE8ycEynG9vgrbruT/PJaqSmiTIcbB/xmKw2OahpPFFWLcz3HQFonSoiiYTYyKRdIOiJTOD9Lo6yM/Fx7nrbrhKk7jpAT4fkz6bKIr8wqtO3JKREus0w9vb+ZaYw1dNueUjLT25F1WtCq3lbhNUrqmO/lObiub0pO1fBIhVIy2oobHjQlJHn5VSNgOIN7fKB7eMAYI8zRfpDDZjMdrYcDx59+Znp+/ZZ41gm2SmI6K0Y1fTMy5ZRmHWpjAvtxlJ9JDZPVNMm1VsKysBwvlCjqTkFJGfKaKKVix56HHz7Q7/eNjlEgR4EdaIPynTShWoMqUEQLWmIQSkROnH76UVz38yqufm3QDiiV8f173v3jPzA+PqKtTJ2vh5B73ete97rX379+dSN6/ulHQQ3VKk1YZwWvFFbRx7WVIUqmHTUjzWCtpChg9IKss93Qob1gWeK8oq1j6EfRVtaGg2mNjus7/H6LH8cGnjet0WubRG0a+1OjawaKoJGahrXElThdmI8HltOZHBPaiUZSMEUVUsVY4WtSqqzNU5TEl96DVtihb+54QdxgpflIMZKnIDfTLE2x8hattcRirpEUhNNZq6y+S9OKuq0HFNbLCtEPHjf0Yq5qcYqlFFll9h2m627JVbUlV9UsAPo4zQKiF6uyoHC0RFGWdsNXVVz6pQiORhsF1jN+3LN5/4Fut8P0vSRl1Squ4sY8DeeDTMBTao+rtkY2C5SopRpJM6/pusZwNRbTbfDbDW63lZhOqjBAlaFqiQfNYaEoSevBGFSW+E6MxXSOG+NUNWxXW58qpSk1Q2lpUPNMeHvF7R4w1jbTVRGM1jxTasY4h7bi3q8xyoFgt8eOW2nArhINIy73kiJlORNm4ZDKgFiSkpQxkjK1BkF7pYRRkkBWr8wBIzpTvx1RNUEKhPNEPM8ygTQWZRxxnSnzirW2TYppKViVnDM1COYLCt3QtcQkeazd2NFvRpl+GtP0raKfpebb36ONocZMLfEbtkhptPf43Q6/f5BUpavEAUFtrYcD09sr6+FAOM8yoS+SmmQoaKXRutw2GAUa9kg1SUFpZIAB3XtUhWoQBFepVK0pSyBNKxqF7lw7xEJJhWos2497Nu8fsNdDgq4y0a1VkGm+E9lH+w6hQo2REgMxrKyXifl8JE4z4dLicJ0mrxljHPs/fuLhD3/AD30LSmjfNFc6wr3uda973evvXr+6Ea1ZINimgepzjsT5TA5ZTCjmyu+UNJicxZxTUm6Qa5mwiKPbSDZ9Kigs2jWETpXlqjJaojfHkW47CkIHyQ4vNbdkFdsyy5FpDvmGlpI4w5lwPpOmi2SlZ8kJ164lpwAUya1XAqG85WIrrYSN2nlhKTbtqZIBoDRfVzNLuWrf2uTX1KYzK6zzSppWSsvndp0np0xIScDyVjA9vpObtzaKkhKqZLS1YrLpO9GdXoHiVd6LHFbRKEZZg5fWUFAEzJiLrCiLABShVmlKc7klEmmjccOG7R/+SL/ZNW1g09ch/M08nUmXMyUuzeEPtcrzK0kYntAyqHTTYLb0HNt3rQHbipZTt8zzZZYJlbHUtIrz2xm0EaRPWcXYpL2k80hkarhpFykFfIOs5+tjMA0zVFjfXknritvswGjyfBEnuGvw9pQkvcc57EZMTLbzN46o0uK8TjFSQqCsMyXMbbraDmKNGJDmiXSZyCGI0Uc7uJIrlcREmmHA9T0oSHMknS/kmFFdJ01vyqRpwhiFf9iKhCKL5jWX1J6fvG/GGPAdNSVS44dqZ+jHga7rKFRqbmYgrUBHTHUY6wXBtSyNV2pbxGaH3+/otxtJPtPqm6scRTgdmb5+ZX57Ja7hFmggaooCRWFaOpK2BpSgoWhwfhTEKJPough+bYhbSa9KK+lyIcfarm05xCjfeKLtve52A/27R7rdRlK+9PUwFuXgaxzKe/k6yKlpVOWwV1JiuZyZj0fCtIgBr8UAa6WIa8YPI0//4ffsf/+7bxIia+X7pFrJsr/Xve51r3v9JvXrIz63e5majJJxHZdZ0oHyQq2J1Aw8Sss9qOQMaJTzN5C7QqO0xRgnQ4Y2IRQ0UUMvdTL5M10nN3wQo4sxt5uVsB/1rcFSWhiZcVkJlzPr6USYJ0kqSmIwEfi9viW/aGUk1jK2nHYlEaGSICUJM7brBM2ErLZziI0IEFG5tJV7S+kxAIqcIilmUkis8yqxikajmz4Tq+m3DXLetK+Kxqms0ri4TUur8R3aOkhB1qNFJrBxmmRliLwEV0QOKEkjCoH1smC1bo1omzJfMTm2uZWtSCDC+YhWBjduqTkRF/n9ZVnl78nNHX6LH1W3KFfxgSiquUanGtxmwG2F32r6XjS8WhBOpEQKcjCQlb0C5+Wen5NIG1aRKqCgttQgaqE05qtWSAqRVWKOSZBDlOc2dDfwfLicRWPaUFFKS+OqtMYOG+y4wVzlI7LbBStM13g+kmYJIVDIdFppLXITrYnLKqirEKiNVypO7UxSBjfKilym2JCXuUWyil4YpahJwhyUAb8RHXWOYjDLKUkKF1V0nk0HnZdACYG4JpQxuL7DOovvfGtYaaECBdUYrfo6WW1M3pILylr8ewlisH3ffEq1GX0gzTPT4cjl+YXw+iLTxXbQM1qTW4a9sbKGvwL7aXpKZYy8X8hkWSVp8GouXJ7fCJcJ7w0qQS1KiBZaJuo0cL/tPP3jju5xj+kGefjaiGIiRXmkvkOhm75Xf8NqpUhOiWW6ML2+EpfldpgG0TrjHPvffeDhd98zfvyItl6oAH+jdY+XmfXt5d/+zXqve93rXvf6VfXrXfMfPjZHuAI0qhtJsbAc/iS54SA31ygmEmO15KBXJALTmJZoottkVNab9tq4DH2bPoq2TLSf6QZKV6o2ZNA1/10wMCUlYpgJp5NEcE4NxF6vAEyFLm1i1+JEtWo39SJmItNZjLOYocc425iU0lSVWonnEzkkWWm3JCR15S8iCKSSChpNjivrNEsTmgvGW/r9nn7/SJovkCJWG2i3xJIL2lrcdsSPG+w4SKSh6BykQY2RNE/y3GKUxqrxSQWHg4DLjWrNh8J2HWkNss7WBm2VpOdYh9bCyDTX1fI8MaWMWxd0ipQc5bmmxoo0ihpFUlAyLZigUougiHRjwfrNgB067HBNx2raySwNfF4WUgyUHG4yjoqGGNqENVFjhKb307SVNFVkBqkB4JVCl4TGNLd044gqgwZKw0/VlATDZSUzXRmD3eywXS+g+eupyRhAcFUpRNLlQpomQXVpOWho71HaklKiri0MoIjcASPXVCkV7S2mFyObNuZb85kSVEVRIpegxdnawYuJrSASi2UlpyCRpUXQZFopaozkVNq/L5jO4zsJaVBaU1CCu2pudduJG15ia9uKPWUwBrvZ0j08SBxrc6JLd1db83VmPbyxni8iR1CCe4pFmlurK0aDNRrrRIMsDbsGa4TCkMR4pa2V114bcqlN01vbtJLbBkQ7MbtdJ/vd0DHsd9ihR7kOtBVpSQoyFbcWbazg2XKUz0pFQieMJs4z09sLYZ1Ja/zWhLfH1j09sPvhd2w/fZIo2Co6a3JCW0MKkfX1lXg83g5997rXve51r79//fqIz87fkkji+cLl5Znl8EpOcoNMUVJ4rPdokImilkzp6/8TgLusXO1mwPWjTD/bDf8ae4mqbYomPyPTkn+d9yy6xQvr+UBaZuIySzqRkwlXikmmn0bMT7pB1Wsuwu/MCdMZuv1WzCZKJpTX9W/OldTA9HFZuaar1HzVzilKjqIzrZUSEnFNhGUlhYjvO7afHth8/MD44RNusyNME+c//4l8vqComM7Rbzb4h5byo9qkF6AUUphIs6yxcwwyhaJSWgyndk5u4DlSUoQkj8/2ns3TQIqRdV5QVWF0m8C2GEfdIh2l481oCixncmkr/sZ5FbNJJi0tqrHljddaZIrtHG4YWub40NQRuRlcKjUkcpApcsmSC399/ShJXO01UkOTTijTDDQyPWv+F1JI5BCw3t+uC6VozaZcL6Ah12/TvZJlQqYMdtjgdjvhltbGAaVCCyOI80QOMzkliZx1LXMdhXKiNY0xiEmJ8u0xtBjbqq1MJ73DOrnO02UmhwTWUo0Vd/YyoVAY53C9HEhqm7av5wthWdr627QpsmhlU4g3U1i/3+E6MQnmklHKUBC6g/EO4y0liQxFDHNNEzz0dNsNbty2CfH1fTbN8xMJ5zPxcqKmRDcMMqVdO+KyUk4T1ILzBmutQOOVFhxbW+mHNZJiwvXudmC8OvfjGilGYUHStNrPG9+a0ChT3uHpgW4jXFFlLCgjSK+UURTwzRGfM6R00+sKpD4yvb1yef4qW5uUbjgrIWJUdj98z+7TR3w/SiOeMg1Ii1KKOM+shzfKsghOVd+Tle51r3vd67eqX92I5hCJy5nz188sby8Nk1LJS6Skgm16PrTkvzvvRAtaRS9WqdjO4rcbuv2DJKcYucGra0INgL/GLtLW74jWTTX3bAyky1Fg7SVBLS37XaGxkEErg2/cT9UMRlCpEZmsOIvRTqajvmtJS1WSkXIip9IMO8L+1NY2k46s4ktbHWIQY1ZMrKcLIQT8Zsvj73/H9tMHhv0jZhhlva7F6W27gdNf/oQzqiXVyM22NvwMFPISWA9HibGsMuGxnTjQ0ypJQGbosN6QJ9Gq6jbVs2OP3YwykQqJznWtsbyubdtNtWRwSh5blkmq+DKEFVrWIM2naqaPnOW/qdLcdw43js1h3jXCAdQs0yOFIs6TSCRyRmt1a2KpCVTjnl5NXtp8CyBIidrSiETTqqAUgb5b28w1nUwcl0UaZN06VooYWABsh3t4wm02GNeyy69NdlIydZxn4uV80xArBLOlrBXcV6mE6QJI+pV20rTVXBogXWH6Aesdxhkx8YRIOM9yhvKOdQmky4QuGWMN2klsaFoCtWTCPDMfL6RFYjslqavIe18hU6FIEMI1w15bQ0lF2KUlo73Hbjo5MOVVDoC331Nx40j38CQHtWaiqiiUEn5rmE7MXz7L82y8YJSiHzdEbSkp0fcOY1TDScnEuQLKWlJMzKcLSlX8ICERuoi+t6SE6T0KJVxgrdsUXxrtEjI1B/xuQ//uETcOYqxSWqI5SwFVUEZh+u3tAFJjbJGgAJUcVk6//Mz08iJ60CTbC0B05+PI0x/+wO7dI6okVArgeznoVrku1rcD68uzfF+0abO66kbvda973etef/f61Y3oT//b/yrmiXmh1CKQayXrXeuUNHjWiS5OK8o8k3NAadWMRz2uH+geHtFd/43bmCIpJXS/aWYHmvGnGSJU4zIuF1JYKGvjLSJ/zvYDBUU5TuimARSeohLIe+OWKq1w21FwSxppyIqSVXuKpBwlrenWqDXdqBUEE85Jwk+Y5RZupBFI08x0muiGno//4z+y/f4H+t1esrNb4k9tj7YCqiZ27x9kba2FMND+BWldWd9eWQ/HBghvcPxcoMRvutWNFmdzyejOo65pR76jVMV8vKBTknW9tcJC5f/L3n/1SrZlWZrYt9QWJo5wdW+ozMrKYncD3SABgm984B8mwJ9AEAQJPpAAARIE2VWszFBXuTjCxBZL8WEsM48C2FmeIt5sAjdvZLjHMTtm22zPNecY3/DkWkmp4IPHb8cWg1jaE7QaKM4Ly/FMXpIaR2+ly/TSWFpr6fd7JTxttnr+OVPjrMbdoBX36URaF6rzmGFoDmYdHMqyUklYl7C2Yl2TIhSxZIvs2JhasS4ogalNck0fmpNahi1ybWY2IKupKTXh7u4Z3v+asBkhJ01Bbbvcq6gI0+ePlGWWgck6clbyU9huMV3Hcj6Tz0fxZBsOyrZUojgvVOMI40g3DrggBNh6nCgxq9k0hunlhTzNmpQOAwar554yMS2cn5+J5xljrN6XXpGXkn9w/TyUDClXdg8bpVm1n2Fyboao4WoeM32PSYk8L9jNyObxg5zmVb97heY6NxQq559+JL48CZlmzFXXLCf/ynI4UGOi3+2aNEdbAOt7SVfmmbxGuiFQnVF+PKaZzSQVKalJqa0R+SJXaTazdN7j20c2795JU+u8PqMp6T3xFsJWlIeo6+MiORHZAKbnJ57+/GfiPInju0ac1WYD49i8ecPbf/+3DNsd+q0lSyEtYDtwjtMvP7J8+iTdcNC1UpPSz251q1vd6lZ/nfrmRjSeTm1q0HSRsWCdw/WKoHTet2lboawN1dI7+v3YJhxyyteUMT6S5jPz65E0LSzzyva792wfHvRgxlAp5NLg6dNJq8eLps9ULikqJSbqkrClNs3j14mliaaZc7xSfMZe080qgHaOk/73MZHbWlC7OLWO1er3rXllPp2lm6wy53jnmj7O8fb+kYff/obhzTsIPTSDkbEGXBCk+/AC66TJjjHNaCWjRo6R6ctnTp8+k9eV4IOME1Ya0WotZpRJrKxLm/gZmZ9KUYxqraxPT5iMQOFjL8B6QzbVHLE4hu0GMLBGvZYhwGaQAeb5QJwWrTIvMY1ZSB439ITNQNhsCZttWxtfYi6TGukYiZMmgabr6IZOAP2UqVk4qJJWcir4XpgqSQ0ixKbza2oM45yMQV48SGMDOE0S8zxTL1Ngo4kbWZpWM2zYvP9Ad3+n11/pBk2CUKjrzPLywvLliTRPhHFok0FN1uwwEivENh101gGWEjPGQYlC04bdrumeHb7zisycV4wNhHFgmc7E0xFnDd3jvYxJOUMRsH1ZJpaXV3KKdN2gg5NXNvtl7W+dpx8F1E+5igvbDVfntzUGv9tqG1GyPplO3MycMv7uns2bN7hOQHxi1PvQzHVpmpk+/kxZJiyOmgAfWvBDZn55Zj4ccRVRBao2INSM8YrHXFeZhsKml/4yV4z1xGlWlKzp2uXRom3b9P9SNni2798y3N+rAQ1NepETxUANA6YbcCUq1rWRC1wv01heF15/+pnDTz+R1qUxdSOmVEo1GCyu6xjuHjRNDb3W+7UqRtYqKGJ5PlCmM36/VdRoM7URs4I5bnWrW93qVn+V+nbXfC/AeVoiecr4ztPvt5o65kyNWRO0DswQCIPA7641a+RCMYX18ML548Lh4xPnaabznmE3Mn/5jLMw7PaKpYwybNDMJrY0I3XLmV/PM+l0lk6sxTnKfq6Vo9uM+O0gvapxuC5cm9C8rKRpkv7y0mh5JyZjVYNjnKU0LmRcV3LKSrXpe2GKamH/+Jbx/oFut8eMW0BuXtYV0w9ylR+eKPNRmkUXtJK+rPpshTDy/KcfOfzp93Shw/c91RhyLbhuoNtu8UOn5qKBzm2bhhoDsVbi4YCp4FzA90HxquuK7YJc5VVUS6xrOC2ZgegGubyfX4nLIsB5qS1O0rRsco/fDPR395ouWtuQSXK817iSF623K0VNeDNjyeGdMF2n3zVHrHW4+0cqagBqM5ZVjCQcNeOHHrfdKsXIgO1GSJrG5xjFXe0GqqHlkS+Y0NO/f8vw5m0zIUWhhLwaqJoy8fDM8vnnZj5x+NApBSyu+L7HhQ3xfCKdTk2jqchRO3SYnMmx4McNXRewtrRzl15rYy3+/p71dGR9+oQiaDdqluZFZqNcyGklnyeW0xkwdL2kE4WqeM+mm+w3Pf2woSKqw8WYVGIEoBsG3DhQ25qbLKkFKWJDx/j+kbDZ6lCV4xVNhpemc3l5IT4/qamsFWPL9b1dpol1OpNTxFmLa5gscmPb1kJuZjy8x3YdDYjQtLuGcb8DaKY0STALFVMiNWdc3zHc7xj2e8XHWqeEpEt4QozUlijGcqJSGnIJTditYz288PL737McXkWhcE4HXeu0Sanguo5+tyU9P/PlcGB4+8j2wzvCMGL7DXGeWY/POlB5r2a9Rh2aL/rcJf5rv2dvdatb3epW/xP17clKuSqvPME4bnC9F39z1STLdg6/HeVytQ47CL5eG/A9LSvr6yvraWI6nCm10o0j3dBphVyKNJFNe2aM3Mi1tCmqs6Q5srwciadZTWHwWnVmxS6a3uDHnq7fYDuZV0zVdE/RhDPpPJEnoVxKNS11KJFSm9I4S0b4l3qJcKxaj2IN45t7rWOHkW67v+o/6zoDBnxHNZV8PlKTGhTTwPCX5k2TVwdphfXE3a9/pYnv6SSMkLN0d1tcP2BrpS6aOvkmh6hGDW+cIzUlur7XRBqjgW4zoJguyAhWBAQvUVpNnKWUSnp+Js8Lit8USstap2jRzhOGDd1+oySgi6v6YlDJibjMpOlEzrklPbWM9Zob+N1ACEImNTD/5f+vaaVhSalrUgxqLfihww1DO3VoDby+HjEpSY/ZCaklN36mGkf/7jv6h0dcN8gARYV+VJOWMvH4wvL5I/l0bhPtNr1vjnI7juScSYfPmJK/opwcCmSYV7nUd5tmrEPmnjUqfcvL9b788hHSive9pr8U8rK2VXAmzmfiukKuX9FguZBSJlcZtYyFEDq60OvQVLLc9m2FbZzVit85LuldpU0ljQuE/V7YLGtloqpAbcYuKuvxyPL8pM8LFyd5kUyjRuKyEE8yVHVdwNLYtsaC1TQzlUzKyBzVtNQp5iuKDWOldb2kf1lI9cLvBD/2bN4+MtzvJZcwthkhC8yr/h08zijWtbZDFI36UIDTx184/vlPOoQ0ral1FjsYSnYiLFTDsN/igleC0rJwOp+Yfv6Z3W9/S7ffE58+S6IQo9i94ygD3HKkLJFSv05vb3WrW93qVv/29e1mpTkRuoAdtA4V7iTix04atc0gZiQC0+dJLvaySk+XloV8mikx0Y3NXdy0WK7zMnsMfXMzK7byMk3Jy0qcFuISqTEjWVgVpgkZVbqxo9tv1NRiNKH1Ws3GuLaJ3yqjdPDUpvkTX9NQTCGnJJ0hiqq0FbqxY9yOVOsZ7u/Y3D9Kb2cVf0njaeK1Hi3TkZoWrFEDWkppcgKD8QHbKRXG5JVqKsYHBtfz+Nvf8fKnP2JSbBnsylAnF6FugGoF187LTGlOfuO9zDMlt3W3cEP1slpf05VzaXxQxOfhqDSsUgEjCVwVlNyNPf39jmF/pwa01MYSjWAFnM9xJU4HSoqKRB36q2OZfGFqtnV4SdTYwgZsFaqpxT7WWtpzAxda9njfqzFo11eNUY2U87jGKlVqkMft7ugfHvBdaNddoRrX9MeZfDwwf/nMeniBnIWt8k7540aT+2osaZ2oa8Qad5Vf2K6TDrgUwjjSHEqAI0/rFXJeS9Gk9jxTkb6UWsWTXdYWpar415Izzlj00liB/CuKbEVxmc6HZjxrEhAbBN93FhtaCIIRhqhmYJUe1W0H+rs7XEvlUoupjvmCxlpen8nHg/S33rc1vcV2jrxG0nHSdDiEZpjSwcOETtdyysQcKRVc8HL7p8z5cNY2424HOEILaqDh1TAWayxuDITtyPD4iB/0GRKRzbXDSVLcZtdja5NrGIu1Qde5tcRl5fDLz7z++QdFnAZ3xSsZ63DekNYMeHzoMMWQFum/TUGxrzaTjy+s65k8zSJ3DJKKlLiSZ31PUQsmy1R2q1vd6la3+uvUNzei3TAAah5C14mXGDx+GBTX6T01ZvK66qY2L5SiVaMSiKTr8n2vGMLOYUOH3/Q456/u3rKujbkok1KeFJ9oO0/oAzhHyUk3XC+Xvus7fNAazzTndM2VdD6Tl6jHN3yd1DQdXTVtunPJX283q1IVgxm2G8Y3j3S7Pd04qkmqWm1S0MS2tsZonTBp4TI/qbaqgbIOnCZYYlc2b1AYMBTKupKnF+o6sxkDJemmrSZTzeQlpWo9HcnTJLe/9a3hyUJm9X3TtAo05UJo7EhhlEou5NOZvCxNqwiXuFBpfTu67Yaw3+PHUUSDxgtVs1rJy0mZ8LUAGd93LXSgyhRSzfW1qUX4pJpT08MaHQT0wC2eNGP7gHUeF+RoFxtW0zUxMRsv0looIgb4zQ6/vcMNgw4lpVKtTF91mUmLko7iyxfyGjHNSHcF0hsheeI0KeKzYbNKatP90Cn2cxj13MvX+No8zZRUKMZR1pl0PlNyIQRB+9MkxFHFEJeFtEjPWkppGkmB7CvSnLohkEvFGIfveuGrgK+UA0fnvKb/zl2jb0ERq37c0D/cE4ahMXprO4jovcs5E6eJ+PJEXRb9Hd+03t4pSSkpQYqi+FOso140s87K5LYsxGVVGlcIkiSkzBoTNgS6sQcc3ndCXxlzJUEYtKkYHu4k57kGVaBrIX2NsnVdh6lJJqGLdtcHapGs5/mnnzh//iyd6NCBszgT9DNqJUaDDyNdb4hLJOXSzFmAqYT9SH+/FZT/NGFHSRyMdeRlIk1z+w6SIfKCfrrVrW51q1v9deqbG1FsxVpPGHvCpsd1naaC7YazHM6UGNtU8bKja41h685s8Liu5aYHfwXU55btXXJukYqrMuBzuWZe41r29OAIbmyMRPEHrdPq3RSxJtOsZqGmJC+NtVe8UcmZmBLxNMn00YDkLvjGPLW4fqDf78RrHEbFKrY0IYxRvKMxalzWpaXutMkiF9i98D/GtWndBWLemoASF9L5wPJ6kBvbS1dpvZNZolTKksgxkheBtk1KeK8pXS7SsvoQNKFFeKLL2lphAqlNeBY5qkuL47SeaoW0CUOP34qxGcaW4d1wTTWba5xomk7UmrTODgFnh2uCTcmX3PmqyattGKZyid+kNUdAaYxMvS24sf8Kvsc2lE7GGjE+TVFgAMbhdvd0uztN0oEGkxImrBRKjsTDK/HwTIkRY8APvcxIF95nKTporCvkhPdeKVEt2tMFTy3KZtd0UHKIy2T74laP80JdZmyTfpRcMDlTrSEtK8t5ukbACr/Qnm/SIcm1g5XznpRKm14qCetyODAGnO/1m5aM0SlJRLOuE4XiTgxaJQu1BvRCFVgW4umVOJ2htMjUFpVLY6nm+dKMG1zf65DRErKuSV4pQik6xHWBsB3U+KWkaNAQoBqZt9oq/jKFNdbS7zcMD/f4cZQBrwoeRdZkW2lrXoatqseqRkloWEtaZ+bXF06/fOL09AK1SgttDDll6VcxeN8Ret8+b9JC49p/do5+t8EPnd7HAnYz4rtObOFlJc9nytqu50aIsC1u9Va3utWtbvXXqW9PVrrb44YON8iNjYESM2ldyTFpjVpo3E2wIcgp3Ew+NgTcZsC25KKaqxq5Bpovq9zEOWWtxUwzJjQjku0CLiixybZ0p2t4Uq3K3l5m4jQp7rGKfWO8YPb5YlJaFuZlJc4R69RcumAZnKPb7xju7uj3d3Tj5mqcKKXKJX6ZjDQ4e83p62uR1SzZfosNfeOgNjzUZUoF5NOZeD4r8jHF1oR6MSGdGpYYtdYVqqY1M6UlDDl3TUTy/YBzjQfZ/juDEEZpXsVaTWoeLwk8F1u67Tq54Ldb/Hbb3q/GbLRWE69lJk1n4nTGmIobOzU6KUnV0FKdjHOasqVy1QTW9DXNBidd7KVhNBa8t+I0Orm19bjtvfZev/PF4N3dEfZ3SkTq1PSQVjUspZDOR9J8psRZEPklYhs27DIpLilDTo0HW3QN+R7nHAVN5RRbWq4cW3IkW7Fjq/WkaWY9HnVAKlp5Yw3OKN+d4HFdx3ycSCljL4eo1gDXXHHOEe4GfHeZ8la8qZIj5KoJnPOSmDQMWY4ZcqTEivUdfrclbEa9Hm0S3C5CCB1xOrM8P0FcqSmKgIDV9Wst1EajOE9ys4dGaKBgigFjSas4sjllyUSMUGMuSItcSm2hCNJtahHRJBcNu+THge3DHd12KwpEO4DUFiZQQRN16zFFBzXa5+kiT1hPR9bTK6dnxYK6IB2yC164r5SxxuFdkDkPZJK7yGGMmMZhN8o42QIVbJOApJQoUQe2EhUte/leEW/1phG91a1udau/Zn1zIzo87LWKzkXGo0k6KtNicK6TSaMJVm4TlNA0oMZ3MhwYpfJcHdNZDVOOQrOUUtvNz+OHQLfdyJlvbUsHauvNtkqVu75iSlH8YtHamRbpCEZpRy2dJi6RlDKurb19F9g+7tm9fctwf4dvgPt6geD7Tq7mHKlrVOyocQ19rgaqGo/tN9LwuRbfeZkE6tZLjivr8UA8HJUhXqRv0/QTMEXTspoxVGyRDtBAi2gEh8X2nVbHlzSbglie1lBzJM0reVma1FYawItu1KDoR78ZccOADz2291ALZTpplV/RFHWZKTFSyXIuGz2WMt/b1Ne6poVVYlOxWdOmVTn1WKPJtb8QDSQHsFa3eLmwi16vkptTGYUaOIcftvhxq5hI5zCuAe1zolorvezpVXivddWwz1ns2EtWEPTvUhIgHqStrdG2TtdVrYqFxGBtlW6xURNA+sC4rOQ1U5ZFsZwXI45+IWoIhL7DdNJWbjuPP51ZXw/Utb3XXmlEoe8JY6/Xkax4dB+otWIpuKDpva1FGlVQItWa6fc7xod7mZWuoHWZhQiBWmF5+sL68kxdF2znsaHTe9oCCVzXkeYTJa3XsIdSgVKarAXiupLWVYlJ1/QtQ4mQSNioTYUNksRQG0KrbQysc/R3e/r7e7pN00Q3QH5Ja5NkjC0NC0V01tKuVYcxkhTMz8/Mz19I89TMRFrVl1IpyNXuuw5vg97eJUrSEjy2ijfqNz3dbitqhGnveUtpy8ssE2HOzbyoz6sCFCrGW4VOrTfX/K1udatb/bXq213zpbKejqTzTIm5TUQs1TTHbVAuuyD3Dj8Ogq0XQcJL0bo3xZU0zc08oklVWhatmo2ax2470O+3mho53xKWKpRKrlrD5VVSgMvUrbbVqet6wuCJ88wynWW2WVObfGi62HWB8WHH+OaR8fHNNU6wtknXV9SSodaFmib9d9iWtmPU8NqA7Vo2vG1NVWlTndYkpnkivr6QV6Gg1HyrKSD0ytFuE11qwdbmNPYG0yvfPMcVk3JbX7a0qcvE0FmohTxH8rReoeY5psadDG0CGui2O02nQqBpJyjLLEMRjpRWTWuXSVPXriX1JE1/q+nUgBvli9MiQ2tF2JuUZIJKUeaaXuEBNUtbfM01r7aZbapy3VqegQABAABJREFUx62h2tCacIMb93T3D/imRZQd2zU9YaSuM/HwTDqfMFXvqfHNjQ+47ajp8zJrStsaC+n9WpNZjdawMWpyGZoh5jK1S5n1dGadJtLa4PreX5tQQKvozYjbbASD916T2E564m4YmJ+eICny0jaJgHGmJYzaBo73iiM1WlvXomCFmrP00P1A/7hl2O9QX6gJKk0HigukGFlfnynnM6Zz2G4rkkLTd1bvGd++pxtH8nJm2exYD0fSNCs+M0unWauaPCVlSUNcgZQLFkdZC673+KHTwTPrWqMWST02A/12JIwbhTq4pt2lNhKCxw49zoeWJFav4RHGiq87n86cP39ifnkhrYvej5gbW7ZtGorCLFzw1DVTSxI9oxRqdITesb2/059nRf/aLui6WAt5XcS8rQWTK7kUwAlBZg0+BErJzOcz8YZvutWtbnWrv1p9cyP6+fc/UlMkXDLRvZWztrnkrdPaLoyjMtC9IadydUCnuLIejuR5vbrVfS8QuDFWju0+KP2o69WENLNMKTJ/mOAJ2xETPNPHn8nzrIlcBeuU8rTMkfPxQIpRzUNbeZIL1VTGN3fcff8d45u3hN2OS7SlTD1KJ6rVqEGrCazsP9YrjrTmBC5gx72iLUvRWpHaTCRAi+lcX19I57MwUEhLKy1dwPZBLvhFOexUJQQZH8DU9nO1xnTWYzqv1eW6NvTQ1zSgsqytEa9iQjpLre6q9+x2O7r7Pa4f1H62BqDERTdxCimehCNK7c9KxcRVOCRjwEhLqQm4pbGNqLElUkWxMg0WOw4QOpprSVPdDBd9Yi2tKaE1sw3cb4aR7uFtw2L5tqYViopaqOlMfD2Qjq/kdcEY16a1kiRgHXYcRQaYDljUPNbSKAqWpvdsE+sYhSC7SEC8HPdpXlheX4nnWddywyCZWrAXHat3+P0GO/TSvfogCULOjcea8cGzub+Di8Oe63CR6hTOYJyTwUgj6+vzS2sCZxke39Dv766mMExRs2wcuE5u+OOBNB31x/0gk5F31LgSj2fc9o7duw+E0Cloodvgvrunf1g4//IT0+fPrMsZwR8Ctlwmwi2fHaAarCmEYWzQeaHZSrv2Xefp7/f0W02waUEAmnpHPfd+xPlO72UzXVlrMS3kodbCdHjl9OUz6+tJZrKGTbv86jWhGF9rMYlr43gJXzAV/GDpH+/wfSBPK9ZL7mGdJa1JDOF5uj6HsmZN7217H4B1XUnTQl5X3M2rdKtb3epWf7X65kY0TSv9EDRhcxbTkl/c0OM6J+epC80DIY1YqZl4nJhfzpR1FaKGizFEzYcbB7q7nVz07pLj3Zq6rNQdEwLdvYDqtgsyroTAofyBcjxTgOU4kefIuqyUmgh9TzcO1JJZpoTf73jz21+x//57fD9qShfXNuGz4AdKSZTzCVOSNITGQUYygKybldns1Yg3E5K6kGauTtKara9tWoeR9tIKRG4wuM1GjvpSNM2rXzmpxhuMLQ3rUzHGa9rczFw1rY0XqWY5X0xd5WuetjSahm7oCOOWbr9vyTpitSoVp6OWxHp4lbZXUkUxRDs5kNO8ktaFsBmw41aToyZ0NU7A+LzMMqcZcM7ieh0SymWqzKWJNNKW5gpl5bKnN8Zq4jfsGB/eEsZBzvnm/r9MmGuOpPOJ9flJ+l/v2xS6gUid9JQlZvLxFVMizkr2cGlSi7cNpaTXqmRpP+Vw18Ol84nlcGI9z+TUmsTGySzNYFO9k9luHKE5/Z0zkFfStApptOp9sn2PNbqWc0vIclQddCp4L2mAKUAY1LelCGnFbjaM797R7/YyIukdxtgG6S+VNJ+IpwM5RkHnmyGs5kxcFmqt9B9+RX/3iK06LBC8jHQFfNfjd3vWn36ktGSyuETivBKGAddJBmMzhM7L2OWaGW6ade33Hd0wMOx3CjyoXHXTcqclaU+7Qc16+UqwMLQG1HtyzJyevzAfnknzBDXJQe89OUbKRbtZbdOJ6zNpTIvbrRXTeTb7jZ63d6TzigsBG3T4idNKms+sJ5EOrLENUSUjZku/IKbIOs8QK10/cD6e/xVfsbe61a1udat/qr65Ed292cussN2As4oX7EKL/pOrtyyz3NrGEKcz68uRvCaZlZzW6yVnjHd040C37XHDiOm75lyuUBS3STSE3Y7x3Xf4ceCqhUO6xDBsGB8eeTkcOb0cWc8zpggtNW521GLJueKHkbe/ecvuu+/UPBQ1t7UUrZ59T14jdTpAnmX+uGhEiziIpuu0gu97aQvlspCxxVjqGlmPB+bPX4jnE8YaJTl1QU5ta3DjAEgjhzHU+Bdoq2ZCsr2iUNPLC840LWxrxkqWq7sCaVrU7Blz1cGq5Fb344bh7Rsl62Aa29O2tKdCPh2Zv3zU4aDFmpo2Nc4pSnpRIeyb01lIgtbkWmpMwhYtS1vdGqoL0DUz08WZhbkGAxjTsEWXayUn3DjSvfsVw5u3OLi6n00FnQAqZToxffqZNIv3aPu+/fiCKRUTlEQVzydNjKXgwLU0JZnKFEmpcAHbnOeF6j0GByUTzyfOzwel6FwiVhuiyDqDRY2pv9u1tLCvJIZaGrbsPJHXCUql225kMGoHGKxrZIWiz44RRgwuDaRMYKZWusc3jG/faLWeL2lL5srczNPEcjxSo5pBOfubvpdKOi3YYWT34Vc6OOakfy7XSpWe+PlPf+DlT7/Hh0C33xAPE+txBm/Aiq9rrZW7v9PrUZKiNrEG2/X093f0d/fYIKrFRTtNWqFGXTrjvq3xk65RL7mIyUriysvCenimpBULOOuIRoczZ5ou1IHzkgOYICxazYWyRPIqnbHvHdYbbDdSYtLBBigxkpLYrrUkNaBWemVKFLEjymWf0kohazLcWc5PB56+vP7Lv2Fvdatb3epW/2R9cyNqxk68zrHFdjbHb1rWr1zDGElzIp1nalSTYzp/1Y5aY/Bbwdq7cZCBqaFWSpEOjArh7pH+bqcM7Wv+O2JUpsRyOnL6+Avz0xdKlsYv9B7vBHfPCYb9lu337xlb1natRWYj5Mw2fU9ZI+nzL21dGbDdRuv3GKl5Fabo/lHT0eaKNxfXTY5QYT0fWT99JJ0OMoP0TYvWpmDWd9heoGxhZIxcvaleTUB+s8XvNg0lk/BdT12Fbcoptqla8/CmrNVs6LVqbtIF4x1us2XY7fCbTZMSiI9p+p5aEvHwyvr6TL6scUMHXYetMmuk1vTYS9iAD1DzdcVPzsLcrCtlXqHpJsPdHcYrSYgiLI8pmogaYykoOrLE1ExCnu7xHZvvfkPYbqnrfIWZA6ISpIX1dCAdXqAUwu6OamxrVqVhLBXyQQlWF26qJsmGXGR8Mk27aH2nayBnaX27QEmFvEbmw6vSk1xg2O3E3lyWpgWt2K4n7O7kVA9OsgNpHCApBlKs0YL3coGnKAKBtZq6akjoMS5Ir4hW0aW52A0GO4yEzYawv9O0t7T32lxYnwvL8UQ8zTpYBCd5iHcYSps4w+Y3vxP14YIXs0bxmdZRU2R+eubwwx9ZD68EozSuOCnGttv0+KEjF0NeMn5sqV0564DIBa7v6e92DI8P2NC3L4mLnlgu/2odbrdpOKVVZIdmAiQnqgvMpyPp5ZMOl12Hc454Puv7oKGusJ7gmonItzjfirBsfcAbj9t0uKZHLmvC+CBNdlzatZ2vOfXVGLnuqy5vGyQ7SVHsY+sD1jrmw4nldGboHbe61a1udau/Tn070H474scN0PAsqRlurEwf6TyTpuWq/yvGYJuhyfmg9Wjj+XnfUXEtz9xSkm7Y7m5LGGVAMM20QeMZlvnM+vrK8eMnzp+flLhjhTvSJMZSrWPzcMfu3TvGN290g8lK6MEYTDeCceT5TD78Qo1qNmwX1BTXrIbTeaW79MN1kkvXa4rWeJz5fNYKfjpLX9gp9UasypZXHzQ9rSVL5mYRrgnRBXAe14EfPORIOmt9b/uOVAv5NOuxzKXBEj8SL+1drbWZu7aETd/c5UaPE+Sur1l4o+XLR01rvX6GsV7mr9NZ0+HWtIrP2lzyjSmppluHjrwsmqD2QRzQELS6XiVzMAZNHqWIVCRlH0hrpKSJ7u6B4cN3hM0Gg6VeUnEaH7UuE+l0kuaxZDUdTqD7mpW04/qRkhPx+KqprtX/Fj2ihqmlYkID/yOdcm0pVcYU4pSYDyfSNIGxhHGDtVZNdow4a/B9jx8Hwt1ODV87hAj1VNV0JTVnX7k/Ql/ZxvvU9FaNjAwzmozjNYklyojlxpFus5EhjTZVdv6K7UqpMH/8BFRN9s2lF84yf1Vwmzv6/YMIBOuixs3p969U0jzx+uOPnH74szBIFfKaSbFoArjp2ito8FYHGz/qEFeO56ukxnaObi/TW45JvFzrIC7UddF7kyrhbnudPmM7MI5aFS1agOnLR/KquF59n2ic7YcNbtwyvx4p86oDQRZgnlKb1ho1+N4RhgHfhytqyWAa/myFmolrohorDFVMlPa9QQXb9ZScWY4nStb2ppbS1vc6CLibSPRWt7rVrf5q9c2NaBhGReCtkRxlNigxC5Y+LQJLXyIBnUMSz6wJWCzkGEkxYdcV+/BIN1hpxjD4TVBCk3Utx1sTr1or+XRieX3l9YcfmJ6epd0zBt/+nGLoxoH9+3u63Zbd27cY31FqVdOEGlDjNZUs54OMSFYNMrK0cHHKm0E53VwA4sZQrZdrfF3I88R6PJLPJ0yWbjLXjAmadOWL+zkX6tzctrWZYxr6yI4d3WaHDe4aYSkpaBZPFBDcXO5g0zRxxntNRbOmfm7s6fcbnBfgvaRMJeu9qZl8eGJ9eWY9HARHH1p0Yy3CCuXSjCMV4zQZ0oPLVEWSPrMkreprKZomW4P1Vs+/VHLMyoh3DpIc3xfQgbEylgx39wxvvyNsd2r6c6ak+aonrDmTpkkw+pRwQ69c8Zh0mCiajFVgPb427I6uBWPanLpe3OQW571W3kXgdQOaElfLcj4zPR9IMRH6QdMxA6mlThkvU1zYbpUJ30nnW9ckTBGKl43nExaxQS+4JwNfn5dzwrY6Iaxsmy6WLL5uSdJBdvs9vh//ws3UJnc5U1IkzmfWw0F6R+fJSQEKxkuqUauhu3uL3+6py9Sa+3o1tJUYmV+eOfz8I/PzF7y10Lipvu+bmVC/l+863NCiRLmY9qrkON5hg6O/2yhlzBhKWoinjOt6TFyZDgemlyNpjYTtC5t3b+k3m4Yv1edhTYl8PlLiinOWckEmUaFz5FzJ84LJuWHQrA5PCIOW5xXfkt1c6CSD8e56gErnCUrUZ2CO7cBmyGs7QDRWLM5QSibNs6bazdhobMX3Hd12y7AvDHf7f8VX7K1udatb3eqfqn9G1vxCNes1VaasK6ypOclrMxNobUewgsUXyDkp7/zSldRKqUUmmmEjHqOhMS/VxJacieczy+srx4+fOX16Iq6rEDlt3UsIdOPAeL9n9+aRbrNt7M/GKLVOaUxtHVnOh3YjLO0GLgONsQ7TDzK/GK1DTWkRo5mWrT4RpzN1nSnz3EwSRuvdWoGA7dT8ltgaJExrqltjah3GBSGVGpaptgQZclFzkosYo+sqzZrVpNXYNmVsKBzXKbNbsZjNwGIdNihpKC0T+eWZ9PqqtXXfS8OXdSDIWYcG27isztLA6F+Te4QRym3C3aavRpPOy3Oxvk2SG/IIAFvFbGyhBcZY3Djit/e4frhqCGvT/KohW8nTURnfbfBVY6LUS6NVBHtfZ0qODUgvjaVpcahXHaVviV85N6h+EYUARW4ur0clb1XaQcSoCUHNSbcdtYLfbMRstVZJO2vSVK4qtjTPc1udt8NBkjPcmKbDNIbatNE2XBij/opnss7Tbba4rlMTZ5262CaPKPWCSztCrYTNSI2ZNC3tk+s0hR93hN1ek+kkzagJl5z4Snp95vT5E/Pzk5KivMM7R44Z14IGiImSKxaDDx2u66SbbClpxln8oHAA3+laNy0JjJoo68J6OpNPZw6fn1gmNZikzJRX8n5PtxNlIs0TJS1Y7/C212MUNbpUZckvr+LCussav5n3as0Y4/CDo9+P0uhmmcgu56eSpMvNayaeZ8C06W8lL9KsOq/DVIra5JQs7TLNoGYbuqnrO+4+fGDY7f4l3623utWtbnWrb6hvbkTX8ywszqIYz69f/M1NHiwW6daME9RanGp1Fq4L9Hd39Ps9w+6ObrNpN22BrKs1gr4/H5hfXpien5kPJ+J5IcZ4xTSFvmPzcMfmYc+w3ytjuwHfte5uK8CcxRnN59Y8ebCBmqP+nvW6kYeh3dDEylT3iJqNdSHOE2maxOVsyS01KQLQNW2ZrZU8zy1XvV5Xq9VqVWiHATduBHJv/Mwa17b2rlQMfuiJcSEdJkyumqD1AdumatYHPX4nSoF+TjNLtUV4mYWbSYeXawNh+414rzER10jKmZQSVJnN+u0G11igF47qBfBd23rYmHp1zV8mcW6zVRa7MZoUp6x4UaOpUo0RO2wId4+4vhdR4cK9NEBaiNOZfDoJ72PE8rSuyshVMnmRCSXPDQ11WUdTlWfu9T5zSdG0LcSg/kXjHDzreWZ9PQpgXtRIOww5Z0rJ4t72Hj+OdNuNIlObBjqvyzVxqaakVKAGta9WcPV6gbSHDjsMTd/ZpoiDQg70nieM8/huJIzba0St6frrqrmaQowLsTWhxjlc16lhz4276YwiWfcP2H7AlERdJDGwTdsbp5nTTz8yf/6ZNLeIz0a6MM7pmo2ZnColZcH2QwfVUJb49WDoHX7sCHc7HdqsGrVasjisqz4n85NwV3leIGd8P2KdoaTE/PJMTpGw21+DHkqTN9QmOamlMB8m5ucDJSZ8CPr8tL+TlhnnDf39Dj+2A0KpTd7jmuFI8b46NLY1++V6zPlqLiwlkWKD4jdCmG/fIYWK7Ty7+7eMd3u6cQv225OQb3WrW93qVv+8+vZG9PWgqU25+mLJOWul6y3GVCFxUpuQosmO7wa6xy1Di/rzrmuA+gYFtJa0LkwvB6anL0wvL6ynM/OkaM3LpGq427F9+8j24Z5ht5GBAtSZuA6CNHw1Ra0TU1R7dsEwGcBUaltxWxda5nmFKKi3/veJtExa065RLmGqdKulKuqwGyi1sE4rpcVGikijfHBpA5vutRdZwJivmCXd8Zp+dhykR/WWkBKmWpbXV0zVFNSNg0DpRpxWvXSlSSB8uwEvrPNEnWZYVzUagxrysibW80KctH6sVtnoNnSCts+LEFxGv3uOKyWlxkkXXqii6akiXhXTamxjwFIUdYpRvvm6toz1LI1wv8EMGyxgSqJkTdDi6xPxdMJUg3WN4dma4VyKjCa5CPGTlbQlZ3lrkGsRFB4afL3QRrtCLjlHyoXpyyvx9cgl1lOMVckRMAbrHf1uwI9Km3K+a4Y1TVSvLv+GkcK4pmXUoYPL+7TZYbuuyRtERVDjF9o2wGBDj2/pW7YFBtS2gscYSi3E84m0THr9rpPJdugAzDgQ9veE3Z1kjrOCHapRilW1luV45OXPPzD/8jPGpGaYkjRBRrrCek6UOWHadeUat7XkBEWNdOg9YdPrPbfuauopqw48+kdxtBXkcm9EDN9fOMBGGs4uYGtuRjLJUGqSGarkwvJ8JE0LLjg1+SlfD7k5ayLab3bKikebCmtd0wfLSBXPk67xWnC+wwUvpFrJasBrZV3WlmxGa1KFKus6T78bqM6zfXxk+/CgA0lDyt3qVre61a3+OvXtHNGYlSFvFLWpyUGLwaz5mjOfYsJYw7DdMjzcM9zfEYZRN8MWS2gaaiZOM+fnL5yfnllOE/G8KD40rsSU8V3H/uGRu/dv2T4+0u+k3/wvYgLHHQVLmc+Cr5csLIxR/rqmcEasSTK+ajpqLtO5IndzSZl4PiqaslZtqUttwHPhdyqCjed1uTqlaZGVtOxxN0pzaMkCe2OpVY2AqW0F3poGF4SFMkYRnC44Nu/e4/q+5Wp7JT7FRDWVXIu0mV7/W3yAXPBV2rlkqswppjWFbYW8zjM5qjH2LY4zp1Xc/LxSS8SGrq1Ji7S7LT7SWIMfBlzf44ZeE+E1UdLCRYdYc9NMrgs1J+x1In0gTzP9Ghke31DTSjq+6LAQVzUlKcvFfOW1VuJ5Eeg/F3znCX3QFK7JKS6NnbmgoqwDQlvvFnIuLC8vLMez8GEGZc5XtNrPFRs8YRxwfUfog9iyoEasXibia2NYFkLwcnE3Q4yITEEbgL7HXDSe7pKM5XQdArbTRNyFDkMzvjgvw1KUjjlNZ9bXJ/Iyy1AVwvVwczHthd093d2DDFzrrPfg4h73gZISr3/+PaeffiLOEzUXfOdwXYvqrJW8ZtZpIc2R4LWGv0SFKuayCMu26XGdlznONod5TORUhEOaJiWkOYNtZjDrLP5uh6lCUtnO0e+2hO1GBqWYyMZI91uVVpWmmXQ4k+elyRg8ZMi1bR28wzttDFx7D4WDM81Ht5DXSJwW8pJ0CLNO0a5Z6C3nPLlk1nklJjWhJTdDWZGeN9dK2G7ZvH3HMI5Nvy42bY0XjuutbnWrW93q37q+fedkJPivVVnwmNpW4frjkpQtP+5Gto+PDHd73Dg2B7WMRdZpejG9KkP6/PTSjA1JEXut+fP9wN37Hffff8f27r6xSpUahLHYcY/xPaUW8nSmxqVlbyvNRSu90hJwhNoxf7EyB64r4hJX4vFIPJ/aal0NNcZd1+MVS276TZJ0guaSjW10EzYNneScwaSkyVsplKzXxhSL7xx+GK/sT02GDYWqaSsoX965xn8s5POs5x88trZGviI3eGuSrfdsH99y9o750zNlmqk1a/UcpansehlQSs6kNQme76QXtNWQY25r10suvIxJ4f6BsNtByeS1Nen1gtUxlGquzUBtmdzF1KsJqcSV9ekjtsrBLJ1eey+rwXXSyqZlJcVCuUxusdeEnlIbEsoIVG5aY3QRlGp1nqipkpeZ5XCmrBEfPGE3Cj9b1Sxb5whb5b3bIMj6ZTVcc1a0ZoU8T8TjmVyyWKoXcxxtsuja9dE1sH7KgsVj2rUqPJbf7NXsAfhwjY7FKBSgxMJ6fCW+fNbE3DTeQJvqFgomDIxv3hPGjVz0q9bfNvTgNB0+P73w5T//I/HwqmvdgrtA6LHkIsxUjoukBaEjbDZq/OMq6YVp+uNxwG8GXafXPHjFp+YlkaYzaZmbuVCHDtd5arZKU6Piuk5r9NApNKGWRpRo1waWeD5RFunML6lWNRW9rkOHcU6HhLFvMlH9XlYRWZR1Jp7PpFU69AZSpRq542nPb42R+XCUWdJZXPD4PmDb9bPGxPbhkf37D0qGu+qOi+QUofsXfLXe6la3utWtvqW+nSPqDbVmYXhaU2kAUwyu79i+vWf7+EjYbLTSlWivGYi09j0/f+H88SPz8UCMkem4UNZCXLXa2+12bN/es3v3yHh3jx1GTRBTotaiNe8Fyr4c5TgvNAdsywjPrSnd7PV3c4vgbEYco6giclSMYzqdqFVAa3fhWFrB5QmOGNcWX5k0YQke6zooi26AxrD57jv6zUg8HsQwNAZDi9i04KzF9x2267nkniuDW9Gl6rO0Fs+NwyjgfaUa6SHLMhPGB5zrW2KQNIxWTiZsN7AZtizPR+bj53bTtnjv8UNQbGRUcx7GDmdNa8Is1qjRliZQ0gW33eKHHoOlrMJyVdpr3UwkaZrV2LQGwCCMlkxnFrqObugEXC+NI1pzOzA4LKWtowWDLzljqPi+x/Ud1WhiFZcZVzzddtsauEJt0aO1FEpJxDmyniY1/dZjfZAppQUK5FJw3hKGHt8Jqm7D0Fb8RfpBpzV8PJ3J84zpHH3YtKlkbu54J74qF7ZqgmqpDkWGGjVMftwSdntdv9qLNx5uxvgeqmH6/Avx6YsOQJdIzNZs42TUCvsH+vt32K6HtMoUZQ1m3Mhws0y8/ukPPP3jHylrJATLumZ87+m2A2mJ1NTMcCm1RlCxqNNpEtgpJnxw9PstYeixfYfpumYORNdrhfU4Mb++UnPBhg5FgEobbCqkVVGz3W6k2+8xzsqNn6teA6cJeokyEpXUcGj6hmmHk0J1rSHejIpXzeLoXnUv3l+b0DhLCmLaQ9SsLYfr1cjO5zPT6cQ6rc2o5ChzxAbLOIjKcPfdBx5/8xtB+61rmmdtB0zwuP3dv+5b9la3utWtbvU/Wd/ciJbajCzUazKK957x4Z7Nu3d0mw22801DZ5DlHPI8M5+OTE9fiC8v1AIpZ+bTSlr0d/rdlsdfv+f+3Ru67Q7re6FvADCYYcR2g/BGcboaHgTEp92gFznlfZCBw3vdtJtmzLSfldPKenxmeX7RDbVFhtYcwXsxGvuBnDPpcGhaNE33ZNIozOczpuvoP9wTQpCxYj7TjT1xlhFD+fQOH5RKY4yjxLXdSEObfAmllJZJ09YGQK9AcQZTKn4zAhYzbHBh0HNp01QTGtzbCkn0+od/JD4/Q1bT5LtOq/0qU471Hj/22rrHCDlhxw3OGE24ncVtRsJ+Lw3pGinrigkOfEedZwpaV66HA6WxKk0XMH0HWWkCFXC7HWHom5ayuZlTW506vRvLYWJ5OSrKtQj71I1it+a0yqDiLMN2c21ea8qk80mTW+fIy8L8eiBOK8Z30mE6hzEX/qYmt2E74AdpNLGXyRxqNkwhpURetO7OMcnJ7losKtKu+rFXEEIplPMkk5tp7M0krTDjSP/4Dt+PmGbEM75r08CEcYF0OjJ9/IlyetFhzlhqia3B16rbdr2SrYaN1vg5iefacFDUyvnLZ17+8R+YvnwBDMNuJC0rJa9430mSbPWaWWPx/QbfOVKMLLEwnSfGoOn7eLej2+kQabuACQ1ZVkzLsz+RlogbR5wPDdu1ShcdPGWSVGW42+C7XtsHe2F4NRZtqeTzTDwJMq8psyEmaWS9NTgjnanfjsj+iLi5cNX1pnmmxAWsgP61zJpIA9VU+t0GsJwPR5bTmRILOVVyycQ1qsFfLVOsfPi73/H4N7/RBqRFxlbt7rH9AMOO5fWWrHSrW93qVn+t+nZ8U9MYWguh79m8ecPm8Q1+GJChyGsyVAqmFNIyMz09Mb0+qclIhRwLcY2ajJXKsN/w8KsP3L1/p0jEbtQNrJarWae6rjl0p7aOVHqSTEiVui5U1xBMDUGkzPu2IrUCnOcYiWc5keUORw2ik6nCv3kE331d968zthYZK9okdZnPZGB4uBevFKgpydDk5cKu9QJC79pNfQDXtUQfGadMRe72OFNKm7zky8pS+lG/30JK0iG6TrGEDWWjpCBPtYb5fOTwww8sX75QYsT7TkQC22QDqCHzfSdcUc2YapRo1Jq/dU1YZ+j3e9x2J4rBGlvkZKFGQ7WKQlzPJ9LpLCNOEB8TLsxRGWy6hztNRFc1CyUVytIy5p1lPUc1T1EGMYMV7qetmcsaqTnSj6NA8rW2hiqRTi8YG7DGsp4X1sOxHWb2mi6X0nSeyjQ3fU+324gO0PfgPXlZYZUGtRatdfO0UpIiS32/1VR6jS0G1OB3W0wIkJTkZZuJDAw1rgKrv/tA//BGr1vO0AVwoSG6ImCZn59ZPv0EcVFDSW1QfAOuYi34/R3d3YMm3437ijXgPSYXyrpw+OknXv/xH4izgPDDXga+WmHbCa+1HmescYS+09SybSacc4QcidYyvH3D5m4r/muu1M6oUV+jjEgxcf7yQi2FMOqwkeMs2bR3VO9ZpwnvLMOv3uOcw1KpxrcJuD47OWfSeblOR2ut5DhTq1WiGpU6BMKmo9tv9V42rTephRP0XlP4ZfoqC6pG101p1ITQkXNhen1lbbKWkpPeM2vpR5nR/Djy7t/9lt27N9A4wqU1qViP3e2oriM+f8Jy04je6la3utVfq759NW8t/W7L5vGRzUNrQEuW6cB6NY0V4rwyffmsKMm4NONMZZ4WObStZXzYs/vwlu27d4R+aOaO1jwmpSClmInzWY3v7l4xnUXcQo1VddOw/Q7TD00oWP7i38poz+vKenglzTMGsGEg15Vi5PT2o3SCpRTyOrepXryuL60rlJqJ1bL5/nvlbrdpa4HmSLYNRwN+6AnDcM2lr9U2XanA3DUl1uVMScq7h6Z5cwLElzWCM8rV7rcNOo8aaiv0DhbW84nzp49MT5+J5wmThHgSM9Sxns7NrBLohk56S2Pbyto1t7ZerrDdEO62uDBQjVdTGS/sV0fJsB5PlHkCKs5/XVFXA5SMC53g797LER2jnmuWprEUmVXWL88s09JCsQqmWpnevCQLJa74PtDt779qQYWHpaaEdR2lZM5fnohrwlsvkD62Oe1XTTu7jv5upwnrdeqdlYGeMy1+qUWptgxyL4d7jasOGcbhugF3QTLVJqkw7ffKmui7cUP35h1hu9N1aYCWUFVrpqaFvCaWlyfKdBJay49gWh6tD61pHgj7R7rdXk2vaZKTpsMsa2Q9nXj9/X9m+vQRgDB0Yn+2n+E7T4mFGishiAzhu6CDQankYkhrxHY9b9+9ke5UnICGZzI6OKyR9XhkPZ6vkb41Zkx7S2qpmGIo80zXeXFCh67JXJIm4S1tap1XltcjFhE2qlHznYtc+6H3WO/o7vf02027NhvvNzcjZMwtQrjFwYKed8p4A3Yz4vuB5Tzx8ukL1hhC56SHRr4w+doMu/dvuf/bv6Hf7q5Iscu0Hyp22FKrJR+ecN5gTPhXfMXe6la3utWt/qn65kb07d//HZv7O3wQUsbUhjIyaHX38sR0ODK/HijLAsaScmpGHbDBcv/+ke3jI+PjA2G71UTIXLA94vzldWE9vBJfD9LlDQETeoJzwixFNaBm2OJ9r2YirrqhgAwspZDmidga0FqLJjVtYmRDkHu80hy3Z8n4nNcK37rG2iyE/ZauH9t6MSlbPDdQOkLuYCwuBCW8hAETlDpTUxSftCGAak2agBoZOkBuZuPc1YDk77Yt1ca2xltaT4LW+TGunH/5ienTR2F7SsXgsJ3HeGlaTdIUKvS+cVZ9M4sZairENYsPudng9zvp/YpSfAyabOZcqNVQc2Y9HjSJbet3rauN0m+sJey3hL5rGj79uQFNo0oi58x6mkhnJRdZY9WIWou7mHcquL7DjZreXX7v6j3kSp4n0rqQ5hVywlTo2u9maiWuK7kUbBjoBku/2xGaWQ5Ma+TWlhKVr5P7nDRtdOPAlYvbnrvv5XYXaFJGsZrSfxGvGvb3dPcPWN+6Zd8OCxIoUNaJ9fBMPB7bNFvBBjVfuKRVjNjdvZrv0IgFLW3LVKgpE6cz55//zOsf/0A8nYTyMqYdBox4t7mo2cMQhr6lTlmMl9EqxiRm6NgxvH24pirVmP7ClFTIKRJPZw4fv+Cco2tmQ3M5gNDQrc7SbwbCZqOG2VnpUNHrVSss5zPr6xFTlY5VUtJrZQ2dG3RA8ob+Ya9mukkmLia2UgvVCjs1vHmkxJX58yfWw0EHvKLPjcFyenrh/HKU1thaijXYJiEqKVK8Zf+r73j43e/ww6jvjFzEZzVy4hN6cszU85Oc+dbpMHirW93qVrf6q9Q3N6J3794DXL+Ucy2kqKnJ9PSF5XDAYDXJXFdiVrMyjAP7Dw/s372lu7vTetT6hlNCTUaMrPOZdDpQ5kku9C5gbE+lMn36hbrf40zF9CNuaE1s41IqjUZJQDlF0ulMOp2lyfSuAdWd4OM5UVCaTlnXlhJkG4S8OXtR3KUfNrhhVGZ1SpQL/7CIbeqctHS+72V0MDJn1dT0flXA7FIipazC7DinyUvRGtZ6q1Wzk8HGOLE7CzQSgLLL43Rien1hfvpMnbSOtd4L01ShUoXzKVkTxX6jJq25+qlQqsF24iv6ocOPgyaFLe3HYK4xrTlGUkMJ2SqzSJlm6hrV9IZA2G7ESHVW7nyM/DYNkF/WlbQovUZNK3rNjN5724Du1VThoboOqE2/6cAGyrIST2fiNEFJYkduBqyTIa5ERZC6ztOPPW7sCRcZgrFCBTWdsFKyVqgyq1njMEENW7msx5Hb/ZpG5b3kAkVyERDz1G+3hO3uaoq5QM9rEVGhpEQ6PrGempbWWUzoGp9UrneM0TT18S1hdy9jFZcELZlu0nliPpw4/OkPrE+fMKbSj72u1XbNp6ZjdoCpDh/EnTVOqKTSghqst4Ttjm6nLYBtjWHNYqzWLBNRjooy9d43ba7BbboW3Vs1vRwGxboG3z5b+kzVUsFKerJ8ObCe5kvqKpWmMy8yDdmxp9/tsGNosgH9uUauVU547+gf7+l2O707Q0/YblkPr8xfPpMOR+ISmY9H4rR81XcGq0MYlWVasWHD49/8ise/+Z00rsY1eUaSRtd3VOPI80SdTm0Sevn2c//Cr9db3epWt7rVf62+Hd+UMrW5q9d5Zn59YX59IU/SbgoDI1Yf3jHc7di9ecP2zT3D/g7f9TJdtAkVQF5W4nQiHV+J52NbWcq5qr+HED8NpG36Xu5hg6agRQaREhvzcZ1JMVLW3LRpmg/VgpSSpZLXSF6WpsdsD9EiI3XHNDjv1bxiqHFWxKbzkNSQWO/x/Ygbx4awaZOTWq8NQinSHGrUadqKtWkKG8Tc2oDrxCy0rXHSz6iNtVqIpyPr8cA6HRWPGDO2XghAhmo8hvb7AmEchRuqVigog1zwvZo017Wkn1rIy9rSfTymarWdplmPs0rTWaG5pusVwWO7nm6/I4xDA9THFg1aKakQxoF1mlheXqmrXNXuMulD8k3b4iXFRXVY37XeqzXxJVHXhfU8sR7P1FoJ7XewwbfpZWmHlo5+MxI2g7SQ1mqyt66UZW2udDWbtREYjBOCqbRVsjEGE/xVW2tadrlSaRWFSs7YblAE6LiRhhPa9dxWvCmT5zPr4YUyC6N1SaGvSQismgthHAn3j/jdHtdJxkED4OM6SpxZn79w/PFPnH/5SF1mSUWGQAhO+tY2qSwp4XLF+q4dPkQ1yCmR1yjd68a3LYRkDJfQAVLGtkZ8Pc3kJWrCaB3DbqP3rBn1zNCJ9ek8fuhlrCu5NaBFsbTOk+eF5fmVskS6cDEd1uvnzDpLGEfctsd1gYqjtPz3WloUJwa/GRnfvWufxUuTajAuMNy/wVrL6zwzv7yyptQa8orzAd8PDZRRGR7u2H//Hbv3bzHhq/yiZj1f22+Ub386UJeTJqOufVZzMy/d6la3utWt/ir1zY1oTIXp8MJyOLAcXsnrrDZFNCRSlClm9+aR7Tv90212Yh3aNh1s/MmyRtJ8Jr6+kOezVrnWgfNKKooVPwyEQfo8N2zUGLSIPtokqMyTmIazVr5C1AjTZLuAMY56RZDLtFCrcr6tbWvE0lBD1mlF7Rqgvk1lLg1rLRVrHH47qJnrOjWqLXZReeiJvKxavzfKgPEOY1xLXdL0yBmDHQw+qLE2LdVGsYqFUg3r8VV8yVVTyJILJDWp1bWVbC3UvGJNi630MveYFk9pGgjebzZ6zsZQkiJaS6kNz+PIMV0lCnma5d53rr1mSiHShGkrEHyvhq8W4XcozUyEJsbL4SjYeRKbsukdrqEHxjncGK4hBxjFu5aG/6GqMco5kVuwgfSnym5X3KUaF78ZCX0vR/sl3rO0JjQnmZFypC6p6XgNtpMmUe9VxfhOk82GIbritS6ZokaRtW4Y8JutwgSg/bn+Mc6Rppn15YV8em6RpJfDFA0RVRUDejcyPLzBjbuvcaAVPX9jSNOB6fPPnP/8R+LzE86AGXuMD7g+iBPqKmmJlCViTVVSU/tZJSdKFevXBUfYDLhxaFKY9oYYqNZSbblqT/Na2u92kR4YbB/ahNvgug7X+Ybwor3G+fo61ZyIx4l0PmNyafIBq/U65noIckOH8wZrvdCpFJ09ykUb6un2CsOw1gjTFi6BBRWTImleOP38ienpgAW64DDVt/fKa6pbYffuLfe//TX9fickVqnURdsJ1w3UEMipEJ+fYFWIhPFBn68YpQUvlwivW93qVre61b91fXMj+uX3vycuM3malF6E7p9g8CGwf39Pf7djuH8gbLZKZGnNHLW5ZpdF6JV5Ia/TdfKHazdsgyIxu54wjEqiMcLAGGPkQK6QpzPpfCLPs1avKcqxXnQD9cOAGzpN12Kmpq/Z7W7sIGp1aoPHhh5rG4TQIHc/tfEfNXW05qK17LCha7D6NoX0l4jBSXGCuU0hncxFF4i3c0oCMpdkpyFouuvU0Jmq576ejsyvX4inU2vavLLtY8Y6Zaf7YWC8f6TmzPnTz5hasKFXw+ukFTVBTZvpesHv1ygiQG5cx9BRrSdOE+k8CdWT0lXL15K4lW409HS7Eec7cUbRlKhMc8PwCLye51UmrJQawgq5RIxV42gqYQx63a1t11Btk8tLo9jMWZfmL4RrhrxxUK0B4/EWTHCKJ23IoRLT1aldYqKWSM5RsoALRL6pKMuSyKnihh4/jq0/M9frrbbf0ZgO165H34eGTlLCE236WFJkfvqZ5fUVm6MaK+e+mmqs1rx23NLd3eOGEeek7WwfIjCVkiPr82emTz+yvj5T5kUsV9OQXilSIxScImiTrjXX3Ps5JjnfjcFYQxh7wqBpu3Vty2CNDjVVh620rMTTTE0VH7z0s1XJU6YPii1thxLnnSa29fJepzY5NqTjmXg4iwva5B1kXUfGFiWJ+UCOK+s8U4ceZSeUdnCi4dQ6uv0dfhgwJUsyYZ2+qiqYklleX3n+4584f3qipKjr3IBzllLEMzXe8+bX33P3/XeE7Vaa7cv1YSx+s4UwkF5fSK9P0h1b9/UayUURr1Ts/uFf+PV6q1vd6la3+q/Vt+OblpmyJtISm77P4seRzZsHxvt7wnaPDQ7jxcxUydiTTkfS6UBe5GjG2TaZqeSqaU43jsqj9l5TI3fJOS9t0lVI51Ob2p3azc60pqdlr3uv9erQC5lTZQi56EBrLdSkFWy328r1n8WRLKVejO2K9UQrPhcCrh9w3agepjl6wchpH2cxSK2lNn2kfq7g3fVifnG+YSJNoww4cNIg1pJZj69Mnz6yHF4pcbkC2Utu+e0V/HbL+PhIv79ThnnJ4Bzx9UnTzoIiF7uviT+1QFmma2rPhVCQcyYdjzJzrZrgXqbJOWVM8ITtQD90kio0uH1tRIJ8OimGsxQk67PX11MNtA4XaVHWeRgCLmgta7wy0algYmwG9ta8NP6qtMSX6adiOmn6Sdc5ZdR34TqZTdOs9yZGJQgtM2WZm4Ne08Syyh1fo3BAojF0LedeU10DlLiIgDBu5GBvjvmvSDDXpouWOE0sn38hHV91AKnlK/i/HS4IPd3dG/xmqxV3I0xQcqMCWEpOrM9PTJ9/IS3nRi0AYx3TcSKtM4aCDx3GBiG/rMG5JueokLOuNdt1dLttY7IKGXZFfxVk0EmFOE3SYWagVFJc2/Vh5frvuquT3nonM591lKjr3zRDUfzyqgQw2gS9ESRqi64l5wa3bwfRWlmniX4bGe7ucE1f64ZAt9l/pVI0s5UQTjIhTq8vPP3DP3D68qzrvVaCiK3aiORMt93w5m9/y+Zuj+vFeS1rJDfurd8/QrclPn0Uy7VIy21c03jHJCmAcbi7eyHYbnWrW93qVn+V+uZGdJlmwOA3Pb4f2L19y/jwgN9uMKFr7t6oSUtrIOQWftZ/fzEhWEdepduzXlqxfrfDdReMU5uCUq/NapxPTW+4St8FzUShGyLG4MeRbr8j5UhZNSXFGWw/UJPQN7bvCNst1lnIWv1irED4tYBtck5r8V2HC2pgTOj12I13WBqrssS1YZWsbvCpXFNyFANpCV1rWqy7Oosp9ipFWKcz8+dPLE9fiNOs5sIHjHPkFCk5ETYDw8Mjw8OjUDpGWjrjA5v337EOI/PnXzBk/GbAhY5cteokJ0ATYawjzQtpPimYoGk2rXeNiqWm3u83jG/ucU6JQkYEVGpeuWCQaoW4RNKyqkFxDuMtOI8tmi6XNeJsxQeL78QcNW3SfIlOrM6T06SYyAtMvWllL1xHE3TAkKFLUofLFL1EYZRqFs81rwtpWaR/NdIZGiv5gU4aFbsb8dsNoPWwCb5NgtVEGSscURgGNUIlkZeFtEbc9k6Tt2WVWeb0ig1OiKilJR+FZjirBTuMDG8+4McNpuRmUmrpVFXPPZ1n5k8fqSnhfYA6sKyZ3AgL13MdAarDYbCNopBzau9HxYVA2G3xmw3WiTtbsJra5oTJmvAtp4X1qANUaOlSWHQA9M285yymSTJs8OD1M8p5asarQJoX1udX6hqF0DKGUpIMejlrkOl0OK3OEE9nTckvKC+OpHVl++Yt47u3hHGrsIosuYeuJ9euvsL5yyee//hHpucDMepg5Z2RG79UUiqMD3d89x/+ln4zYlwHxlOWhZqiDH7bO0y/JX76mTq/to1MkytY2uGgUkOPv3vQZyAu/+Iv2Fvd6la3utU/Xd/ciDoH48Mdm7dvGe4ecP3mGlMpWLfBhJ6SE/OXX1ifP1PXVZM5r+lKXi7pOpZ+f0e/3+O7QUlN1jUEk8FaaRnTdCLNZ/J5olZzNTMAbZIJtgt0455wd48NAyGtvP7wZ93UCYqutIb+7h4/DErOmaevsGzDNbHFmYr3HtePclNXWkDUeuUjlnWi0mIJ7VekT27rTte0fKbhoOTubkrVIkGtMY54PnH6+BPL8RlbKwZL6HxD7cgcETYj/e6ObrfHtmmmKRXIbf3eU3PCdYFuv7sC5ktMmDVp0oOBbiDFRHw5KIaygexr1Zq+tLW0G0c2+x1hOzSXM5gik05ZZq03HaynhfX10LLla5vCBui8kqzWRLUo1hTTknqay73xN03XkaaJ5eWA83Lxm+Cp1RLnBVNKazoFInfdgAsOWiNaYtRBwLh28Emsx0OTaRT8EKQBLJWaVjXT3uLHDX630+tCyxNPWufXNeH6nm6/x3dNB1orFSOts9EBJuXM8vSFMp3wo/5eXYUaMt43s1rF379lfHwrU09LnDKhhxbXWVJm+vyR9emzHO+hkzu/QLAWuxmlfU5nvUauk4bWaJNQGvLMWkvoBYJ3vTYSpuGYSkqUtKhRz5k0RebjuTF1ewqaVoZhgxsHXalZoQfWudbwFuqkSM5LYtLyfGB5PVKK0GilKPwhxaTpaQjS9PaC8pekQ1JNmXiYm2Zczf9wf8+wvaNStBJ3ip/V58tRqLz88Q+cP/1MWlbWtZBixntLxhJzAmd5/N0H3vzmV3gvCoWStxptwQfs/g2pwPLzHzBp0e9GI1PkJMRaKSJzbO9EMciRuk7/mu/YW93qVre61T9R39yIvv/7v6d/fMQOGw0iqZDaRLAbyKmwPH8hPn2mLEszkmwwvVzupWRMcAxDR9gM+P09GK+hp20szVJI68Lrp4+8/vADkLn/7jsMcqQXIySQwRLGgbATPsgGTT5qW6/uvv+e0y8/K8pvO2oCWhLp8Crdn7XXRCDx0muDgrem2VpNmZo2seRImidynL6ucK2RQaRqBW99J/Vhaz5rIwPUnKA2raDrKKlyfvqF08efMKUoUQghlgyayIVhoL9/0Aq+OaBrexxcaMzHSjofSPMZrMVvd9CaDWMttg+QKykXlpcX8rJqrdsFcSObCalUrSS7ux3dftNiKxvGyFq5/ivQjSzHE9OnT9RFznbjLK5zWn+mSpnPaow6QeYvbvBaigwizmGHXjGd05n4esQPA37sMECcGtOViu+lJTXW4DqPC5IcGOtJa6RWTRZFSpiE2GoQ/W6zw15MUjW3WFGHHzaazqUmD/HKFa9Nz9ptRkHpGwFBmsEqZ7W1pHVhORzI0wnTJvqk3JriSI0rpVrcbsfm3XvcsGmbgKzPiet0eCv6Pc8//AmmBoy/IJsWuertMGJyZj6/4hvuzNmOUhLLPOv51aqp+/2O4fFBk+ScGsDfkJflq5lwXomTNNUhOEoB31l832Osa7IaI2h9Le0av2C5CqQFUy0Vy3I4kE4T3geM8cR1JZV61UeTM24zYBx6XVZl2VcsuRb84MkJhvs7Hv/u39NvdmIPN1uhMZeNQcd6eOLL7/+B+flFn51D46WaQkqaXrqu57u//y0Pv/4AWKxxVGMpyySn/rDB7t6Slkh8+glLvcbsXmKCazM7EgZcN0BeqQRYl78A6N/qVre61a3+reubG9Hxu1/pRpoiNTZenwuUJbJ+/Eg8nynrIl3lZnPF89QGfA/9SNh32Jwx4xb6EZNTM1ZY0jxz+Olnnv/wZ5bjUVNRY1jXH3n33Yc2TCz4fqDbb7TGayaKap3c5EnIIVME9K5omkZSxGipBdcFJbZUGRx85xsYX3pLY2SuwnsqKAf+cABTsU0TVysyrKSkJqXrmxveNgj5RTIgPmmtmlIuL1+EvTqd8CFgg266KUZSXAnjhs3jA+PDg5q4pusEIY4u07Y8nYiHF2qMArFbo8lPRWYlJ+PO8vos7WTOONOaptrMJFmvR7ffMTxsG+xfY1BrrSDx0yRZQ7VMzwfWl4Mawz403JVewzitQFFGeN83PqihYiRpWGdMUGM5P70oCapW8T77jrykK2qolkoYOrqGaTLNHIbz5FRJ0wtlWTHeUuLKejxichajtB+gG7Siz1ka0m7Aea/pl3VQrVbdxlBaE+qGnn7bMErQ3mNpK+Vkt8yHA5//039kPR7YPt4z7DbUYqUtTknZ5yHQv/0V492dNB6lIZKs1UGpZGpJLM8vnH/8AUoh9J0aSCMDXMWAs21lf8bmjB9HNZelshwXXOuyXRcY7veEcfjq3jdO9AFziciE5Xhgfj2T14V+HDXp9G1iPXzV4tZpUXPrg5iubUJYc8UYT44r0+tEzpngtLW4TJYNej/Xecb2DtsZ8qRELYwhptgm/fpc3P/mN9z/7m80wZ+lL71IcWh61vPHH/nyxz8Q55k0razLSkqZXArVWkqtjLstv/7v/gP79+8wWYi5khI1zkJF7e4wu7fE04ny8rPk6dbrcBB6mbty1MFl2CpMIU7S8jbt6AX2f6tb3epWt/q3r2/+hq0VmE5azxpDipHl0yfi8YBpmrUwDsK9oClbXiPOeYG/Q3PR90aryZy0posr89MLrz/+zPz0LFTQxbFeYXmdeO1eePPrD4TNTjflhqG5rPIppYHmK2k6kk4nNY59x4V/ibc4H5rpQjpEdzEL5dxA7NI6Ktt+Jc9nckqYYL4+ZtX0RINK8UNdaFDzlFrj4dpk0ZJTZH55ZnpWFKdWxeYqExQGy7B5fMP2/Xu6zbahnzKmNZY0Y0+eJ+L5QFo1cXaX/PMinnqphVJheX5h/vKMN5ep5gXYjn4/LG7bsX3YYp0iIXMRReDSyORlIZ5nlvNMWhac7whje6zLKnZdtdIPHj92iv6u4qQaIM8naTWDdKXx42dYkzBAQ4/xljyvQu00QkA3Km/c9t11OlszpPNMmibpZtOq6XE1kmx4j+vUAAvGHvHeireaCtXR1rxGzV4GrExs3f0j3XaExuRUwo6MRjhHWhdOP//I8aefyNNM8J48nZkphH7EYCgVwv07hncf1MymtWWqoyamVEqM7Vr/TD2f8MNArZnSUrlMra2BLlfeKbnK0e8DNSfyMuOcxdoOO4rl6vte128jMtScGmHCka5YphVnLdX6JtP2mKCEJ2P91YCmyWxLF8sZKNK1ek+KhfVwxmDoNyPUQpxXmbecrgED+N5jgyMtq97TxnQtLQij2wzsf/U92/fv1b6uUa9TSxiTNKBw/PQLLz/8ieUspFfOchIaq8Y4V9i/eeT7f/+3bB8epCl1QRPudQHvsZs7zO4N6XSkvPwiuoB1Oky7FqFqog47oceRYF2w/dDIEPo/X4nDt7rVrW51q3/r+uZGdHp5YdiMxPOZ9XQgn+XsNdbJINM1I0ptLvGc6boO328wvm83R93s8zyTlpXTp08cf/nIejxpnewUk1jRlNOFwO7NPePDPcPbN81day53CKjNpZuzwNp5pVK0FmzTyVqSjBjOyLXd2J22xQlSkSmiVUnrFehuvaXbjtSLtrFkGWBCwIROOjjbuIrWNVe8eJp5WYjzxHx8JbZmgFLxNlB8pZRIXqHbbNm+/57h/l7c0xxbeqicyxiB6cu6ks6vcpDbr5O6kmVIyjER54V4OlNLIYQWnfqXVAFrcMHS7beKOCyFMudmBtJrkGMmzTPr8UyalpbMkzFEvPdNU1vItVD7DrcdlcBTkiDhyjMlxURe5fxOcyKvM6VUuk4ufGolLYt+F+9wLhCGXklNDflEMyyt0yz3fIzUKi2fYkubc7wLml4npeSEvsddtKRVUbQyi8nFbbC4YUM3bhs6SCY0maQgZ2F+1pdnjj/9xPr6gnEGPwyAGl/rAoWK8QPjm7d0m42m7zXRTmLSGNZKijPL8ZX19Iop9ZrmJCNUJc3zNVkozZochq7D9A5j67W5NgYlWm2a2arF1OoQdImdLRQc8XRmPp6wxtJvNuQ1gjX4rpPEoW8sXGuxGcwwYILXJHctkES4yKWSXk+kedWU0Gj6mduBMSfpw6txxDViaiHl0mgXOgTVoveo3+3Yf/jAsN+3A0b+C16rPtd5XTj88jPnjx9ZzgvxrOjWnLJW9sbTj4Hdm0fe/+1vGfZ3AC2aVN9H7u4e028w/YZ0eCIfn/Xd4pQSZUInNFOcIQRMGCSdiEpuk6GqXMQ17fvmVre61a1u9deob25Ej3/+I+lur7hCY6XLDEIEuaFNryrKzW5ubGOb9q0ZX/K6spxOnD49cfr8meV4BvSFb42R9ssaus1If3/P9t0bxod7MRfT+lUnWUrTdCVyXIUxMrZNhlpcJ1xh6z50+H7QCj10bW1a9e824SypMTApmoJ4xVjirKZbpsjwYHxzWoe/WMNLr1eBuCyk+cz08kxe57bazFgahsYaRXBuRvzujvH+HnuB0xdFlZp2Y1ZqjowmOa6SGnSNZWmcmqZ1ocwraZrljEb52nm9uKnVqPjeE4aOMPZUI+akafpQY2nYpkQ8zSwvr5Q1XidUPgRc8JIK1sqXWnkZOz6NI6/BM1rLZi1sjGNvMm9LpS+GsiZKbElUXXdhw2viV1ujEhx+6PXnTglGtVbKPJPSCqkIx5QiphnPrPVQstbIIVwJCi4o7UdvvlbCF+QQRgYYcUE3LU7U6ODU+KEVKMvC/PLC+fmJeDpgTcV3amCkHdW/bdfTPTzQ7R8JXQ+l6QiNtKdUKKWwHo8sr8+UdZLkwYovWlsjqmuvyRJWHeJ88NLvxkUwdaP31A4DdhjEFrVOa3FjIEd9NhDCaTq8Qq507fMJQjr1QkLI6GYN1oiYYHuHaalpNIZsrZW8JtbzrGljRbnwtZLnRbGxGHLOOO8oJVLJpByv0bItR4sw9pr4v32n1/3yHjUEli6KwnI6cvz5J+bnJzFvSyGXquuuRY5u9zt2799w9+EtYdxhwiUeNAIW24+YcUM1jnR6oS5HsX/b95jRBQglyVQ4KHRDU9QBUyWnqO17puREPJ3+GV+pt7rVrW51q39OfXMj6p2jLHLBO+8pbe3rvMeFrpl05EA1l1WhlWkgLgvT8zOnp2eWl1el94jwQ85ylAdXGfZbxrs7No8P9Pt9u2lpVX7B3tQUtTKPa9OfAsZhvdEa1Hql4+Sk/O1OOCMTumZMMJh8SUIqlFUNqKIl9TuZSyZ8jLAWDO4aw2napEui1TYpqbDO55aGdCCuC3lNMhq1KaptOsWw3dLt7+g3WzVd0NKEmlHDfjUnlabHLW0CbJsEQBPXSJxm1sOJuqxqFJs7u+REWtTshM1AtxvxYzsslPa0nRr1mhMkvbzr8USaJjVKqEm3IbTJc2XB8P/sAv8XW/kThdfzieIdnfcM1rF1lvvg+fvQ8ZvzzHcZ3vXQGaUdXTiPCi7ocIPiMo0X7sjUIjZpXPVPqVeOaM1ZMgJjtfKFJonw19fXNR1oTYr0vExBjZN8wnW9MGHt0KTmMmgYlyNpmjl9+sT502dqWqWFdZdDiwgRpVT8Zsf44ftmJjN6DY3kFpdTV1raFPT4qpShdh3ndYGWsFRz0vR5noTNCv2VD5vXRTIOI7OWH7fYvpdBrjW65KKmqirqVJG5MxRNPi/OdOMclhao4KQ1vkxDsUifWtt1mBKlVtK8tCAAKCVhqiEvq0xuFlzXkXPCFtcm5Besmm2BDtKH+35g9/4D48Obdo2apiPJmuCWQl6VFT+9fCEdXjHtNTSl6vGNHm/39oG3v/6Ozf2dDpX2L9KWgtKQTDeQY4R4VI/bDXLCX7jCWfp20w8Y42RcymszdWnrcd22rAvL8cDy8vqv/qK91a1udatb/f+vb25Eu7vdVTNVqTgnQ4Pre7nNufhqJH6sVOISOT89c/jlo6ZsrTnEanKTs6I9t/d7du/esH24xw+jHLzGXbWGgsUbNSd5paQVuDRtbSrU3OrGKLHH2oFGvJY5wTZXctXk78KcpCg//avNmjaNLNRl0e84bnSTg2Zi4bq2S8vMejoxPT2xno9QFY/pmmYPJ8Zkt9vR7+8Jw6hpa8MCXVieGN3Ia4uorCVrfWhaw9sa+7Rm1tdX0ukkfWXKMgcZgyGTWrNnG86n2wz4TpOsmltqkVMaUDyfycui6M2sxtQCpa3+1SgrpefJGf73JfF/WM98cr5Nh6EsK8fzWW+BsXRd4I/A46bn15uRv6uV350n3p9O7IqQO24ziKjg2zSzOa3rMpOX5RpBWlsDqpQqMSpL0WTOD8N1QmcB13A/NZf2nJ2A7D60ia7iTu1fYJloK/tSIvPzq9bBz6/UXGRwcl4TY6Pm2fYj3f0bhsf3+HGj1/QCpTcGg6XkTDwdiKcjaZ2vhzPgmnNfrVXDPc0tC94RLnKRpoktjcXqu0AYO0V0tskuWSaiSzOXloW0iLnqh14TwpjJqWDNV4WjcU6xrk5bA2MvutKLgS3j+p6w2eL6M+dPn0nnkxpCDGme8V3A931LMitYkK71L7TRBjC1Mtw/snv/nXTPpmXFm0aaqJqypnnm+PEj8/FFwU/es8aVdYlNj2ywwfH44T2Pv/mefhgUUBAGHfLaNgQXKC7o8LZODd+kQ90lOrUuk972YactS+OqGizYBumnGcXWifVwIM7TNVnqVre61a1u9W9f324HbYaXkgSB32z3dIOYmcB1FQqGdV00Wfr8xPx6JC8yS3jr5EI1lRB6tpsNm8c3bO53Mjq1VV1tufTGOk2N4qLc5+sEtJHnL8u/tua8uKPNxYjQQOcUoYpybsk6OVJSm8i0BBylL+nxDZqguN2DmpcQrm55EzoMhTidmA+vrKcD8XwWjJ42+WwoHmMM/f19Y5huBP1ujaZ+h8vysgHyU2rZ9Y3X2EDjWGV9z4cT6/MreVqkyfyLhCdSm8r1PcN+Sz92mp6ZZtApwhFZ7yhxZTmciIcDpqDXq+qZ1GYCq6VKI7sZKM7yvzsd+T/mzGHSitk1iYNM0ULerylymicOxyMfQ+CPw8h/3O5423s+1IH/UDv+2z7w667Du7+IpYwzJMkPcktYyjGp0bGGHDPq/ivOe8IgSoGc/5pW2lq/pkcZRcL6rscPo5pUf9GItsMLQv8sry+cfvmF5fmzEqzQ1BDnG0mggHf0lwZ0u1WzkpphzV6kIIb1fCK+POmgVGlmoIbCaq9Rjonl8pkwltAPuK5T4mbRpD4XIbC63YDve63GG6Wg1rYdKIlaKnFZKKkoLtbUFnEKeIv33RXn5foeNwxf1/jV0MjzunaAsL+nu3vQkHEYMcOG5dMnli9fSOuKDZ5CZTkcNdmuVQzeUjDG4AZHzgkXOnYfPrC9mLeKUpGqdaKBlQrGMx+eOf3yM3k+N1qFJafMGiMxRgyVcbdh99179t991+QdTeNp0IQTfSbX45F4fMUFR/f4FuN6KFFGr5Qoi+JH3fYR2+t1uLrhaxXIzVgqhbjMrIcDaZ5lcOxvrvlb3epWt/pr1Td/w8aWEa/RkGGdzoTdvrm2K5TMOk8cfvyJ08dPaiCTIkFD55t2r+KGgfH+jvH+jjA2o4u5rNWbmSBrapnmEynKpGG90VrZGmncLtgYJ72qDb0a2dC3taU0hLUU8jKT09Ji/BqEv630S1za5EsYHdMaEON007xOXAHjOnIuLK9fmJ8+E+czOS5QKqELYL1MIbVegf1hu9fP44KmoZlahJvK9WtKU8ktd7tNjFwn4PZ6OHP69ESeF3FH25r7Mv3LJeOHns27R3FT4Sp9sM5o8mwUpRpPE/PzM2leMVUNW0mZVOvFLwLW0g2duJoh8H/ynv/YjzxiGOcz0zSR4no1UeWcMd7TbWX+WZeZ07xymheeDwd+GHp2/cj/px/4vzrDvy+Z/74U/j5lxpTJORIb8D2XrBVwBd/3OFOJtYrT2jkoqUkWLglFasRjTTgvTagdh0ZqkBv9YkSi0RgomRxXjh8/cvrpJ9I0X8AEamSdAVPEXt3t2H7/K7qHt1jfwboKE2YdmAaNz4np6RPr50+YWoXUqhWM0q/IWYSIeWZ+FUnAtUYRYzQBzklpWBXC2NNte/yFYmDr1fhj0AQ5TSvpPKvn3GywzpPOZ+lMG9/VWDDFNnOeb7+XUGc4o7X3KiZs//iO7u5eh7Gcgcjm/oFhGDh0HdOXz6yvr8ynMzYEvLdNB0uD31tqSXTjyN1vf8fm8VFbg5qvnzUun4KSef3lz5w+fdZjtS1LWhdyzJSYCd7R70Yefv1rhv0dtpcsRWlJKPLTSO+6vD4z/fQDlEq0hpQzw/1b/NCL7TqdKBj83VtJH5reulYFQ+hnAaWwHl5Zj0fyujbJx9cUr1vd6la3utW/fX171vxpauthaebW1wN+u2fY3xEPr5w//cL09IX1NFGypmkGQzd0WGexIbB9+8j45g1hGBuovWm3vNe/jSWvi9aaixoznJUOL9X/YtplnbSpxndtktkavXVprvMqzuT5SC2Kj3QuUJ0GQel0Yv7yirWOzbsHrDXSYPqvxobrf/CBgmV5/qws8HmGKoe2IhkLOVXIhX6/Z/PukX5zJ2h+kamjDfSuJqRcpEktOZLnVcYqK+NQAax1LEtm+vQL6/OBWuVSrjWTSxbjsBQIns27twz3d4Tg1aRV06a64PxAzZXldGL5+ESZV6yxbd3YGt6GsMppwY0jQ8MCWQN/sB3/t8f3fGju8jkuHM8Tx+nI+XRiLkdiPFPmhZjzFfTfeS+OaCmcThPH48RHZ/nzMPA/bkb+z97xt97xP1D5b1PhuwomKkqzILi8Aapx+KGTTKNUarVSXBiLc+K6Qhvu2UD/8KiJ6SUIoBSwFVMKFMVqTl+e+Pz7fyRNZ4H3vcV17QDS4jBtCAyP7xjffaewAAzEBje3XtcchjhNTJ9+pMxnTS2z4mRlqjKwzJSYmV4OzIczphT6fsB2QSasqHV9zlmPud/RbUZdLJdpam0XYpYrPJ4X5icxXW0XpCduOlU3dI3w0CQinUIBalzJU8NtbXealCdFlvaP7/D92KgBBUwBpxW67wd2Hz4wPX/hfDphraUbtAURag19doxh8+aRu7/5O8Jme9Wu1ku0bzNx5ZR5/sM/cvr0kdB1YBxxXkkpcp4WTIF+CNx/eMfdr39FGEe93l0Q57fQYnQtpcL69IX49Ek58ReXfopMn3+RhMPKCGl395p65qjGMkaRAbK00NTCejqyvL5S5oXqwHY9tUlUbnWrW93qVn+d+vadU6kyuBRhUmouvP7pTxycI50OMjnE3G5Omnw4Z7HeM755w+7DB/rN5jpdBK5rNaqmT/F0kFmGi7tVN7LqLGZUFr31cq1fOJ0UwOnva0WvVXeaTqTpTE2p5bMbSpypsYL1pOOMCx2bDx/wXtnwOE2oNDGVuaOU2prsz8TDAeccppbr5LCWQo6FbhjYvXtPf3+P8f1XqYJtzTYyxOScwFttRlcBv63z4Hs1AblQUmY+vLC+HllPM6UUuqHDeUNaV/1o7xge7xnu9zIU5UyeJun+QqBMEbcdiPPK+emV9eUAOQtjY5oarg+ULO2o7xz9/VvcIDOaqbAcjvxvy4n/93niu7ffMQwdu37Drt+Q9ne8nk+87g6cT0fm04kLCivOC7WmZtDqrvrbXAvLtDAtCy/DwE/O8//a7vjwds9/mCb+V/PM3znPYJuDPRdp+EzGkDGuxxRPNaU5v6027AbC/o7h4YEQQgOwt4us89huwHhHns98+Yff8/LHP0tfGKStDUNH6LSGz1HN2f43f0O3v1ckZy2wzkCbcFppiJcvn1mfPkmnahwlivVpvVOCVVopMTKfzuS1KD7W9YAhxYxBjx3XlW7s6e93ioQtbXWu1FhdZxj9rKfPxOMZ33dNxqIDl6odeCwtjaq/OsS5EhQsZZoopTL++ncMj++o80mYsxZhqkOTrvH5eODLf/ofiYcj42ZzkV1fdaU2OHwf2H33Hftf/07NeEmQUuOy0pLTPNPxyJd//M+k0xHvbTNlReK8cDqdqNYxbLbc/fo9d7/+Ht8P4DtMN3I5NNWaxQsthfnTT8TXJ4i5/b0O00InyroIuxU6Ng/3uBKBoPCLHKlpvhq+SsosxxfSos8WxmFLpa6ZnFZSO+zc6la3utWt/u3rmxvRUgumqPFKURrLMp0absg2zVnBhUvWNmweH7j79a/o93eaBrY1qb7rHQZLOp2I01nGnIuBpJQWu1gxXmYfG7xy6W2bMlat3o1GHlTnBLQ/PktzFjy+V/55KZUcmzPWOMq80O13zZSxacPU1jheDCMxMj194fzpJ9b5BFWaQyrUKLRNMZmw3XP33Rs29/dtymiuGdkUJb1UKmVdKFlrUGJqqUQGU1qDZYVcml5fWA8nTFLmuLLEwRi56EsF0wW2j3f0d3tB3Bc5sf1maE22nu/pyxPnL0+AsEg5Jupa8ENPtxulxzvP9Nue4eFeOkMqcZrJLwc+lcofQ8fpdOYfj/+Ju/sH3r55Sxc6rLU87u/YDiMvw8B5uyXOC9PxKCxPVqNVYsR3mlCu80LfD3RDT5kn5h9+5GmNLL/+nuff/Yb/75v3/Pta+F+cz/zd8zPDesK4NlEu9YoXcg12X3PF9j3942UKanTdtMbfeI9pCVXnT5/5/A//menphS4EKDLWbO62YCtp0bRw8/1v2f7qd3otaqGuSv0x1mtSaAx5XTn//CP59IJzcvzndSalpEbfahI8n2bm1wPeO/rNBusDJWWhs6ym+hVDt98Sthtc3/TW4su3Zi9hvEIGpucX0nmWZOEyJXauJQXVhtwyTSJhqEnBB7V1p74L+hx3I7vf/DvC0MM6Sc7CJZmMhkNKHH/+kdcf/gRZCK4aE9ZATtJc+2Dx48D97/4d2/ffq8mdJ12zf7FWqMZx+vLE53/8z5RlJrQpbV4Tec0s80LwHd12w8Nvv+f+V9+LUOHVbJMaIQPEby2G808/kl6fmrazYqzkQfl1kcGvVlw/sHknZJQwakm4tayNAuiwM3/5fOWh0jTK1RhN4OOK323/pd+vt7rVrW51q/9Kfftqfk1y+8aVuEwyihRFaBojqLvvPL7v8OOG3fv3jPf3mmw2U4E2jBVyJcfIej6RJ2VM18sDtYbQ9R7bBZkFnKY7JrSVYIy6SdnLKi5RzyfifIaSscOg9VsqpCWSllkr2F4Nkb/bYPteblkJKfXYzlEwLM9PTL/8oIQmKj700uhVo7zuZcV1HfcfPrB581YGpjb1E4/SXDEwtRTyfFZn4cL1cQwCrRvrFPt4XJk+fyEvZ6jCOjkDXZvUlayEm827O8bdVqaPdZWpIwTc0F+JONkEptcvpNORC1EoRyGqrDOUklmXGRc8++/fYCq4To1cPp8phxPeOf5xOzBj6FOiFMPr6zPzdOLx8S3b7RbvAsF3vLt/yymceTUvOOeJy8J8PCqRqe/I64IpldDQSj4H7h7fsf3+t5hVCTzBdsRU+b+XzP9jHPmfPb7hf/38xH/z84/kpKxyaw2Erq2bLWbbM9w/yNDTkGGC0xts8FRrSNOJ1x9/4vVPP0DKdA0VFYaOfr/BeMN6OuM3W3a/+g3D43uMlY6QeoGa066zTDwdmT/9QomxoZYkyail4nxoEszC9PzMel7oQk/oO6xx5BhJa2yNUSZT6e82hH5Q8xMLJniZ11okpimFNMkQRy6EzYjru6YXBRs8bhgo0wxdVv47QNJBQM+tUI3iTcPDGzbf/1YGvLhQfUeNq2JSJYomrSuvP/7A6ZefMSk3sH3R9gGxR13XMdzds//VbxnevNdrP58gx+bul36zFMPh5595/uMfIC4Eb7HGNs6t5AfDTkSAuw8fuP/ug8xlxkpXatRAUpUDH2Nk/vyR9PoESSlSxvvmPUvULILA+PYdmzdvpP01Vt8dNX9FcQ2Ouq4sXz4rHhcdIEp7j3zXN8xVoFxCOm51q1vd6lb/5vXNjei6ztI2pkJJFYtRbGABvGnQ6nuG+3uGuzu5qhu7j0sWfFyIxwNpTVSLbkQN3n4BwuMUeehDwDnfjEjdVS+njGjxMMu6kJZZNxgnvqS1clPXnMjzyno4qZEdBvwwSgPqQ1t9Rt2gG0Q9nY9MX35heX6iJO1FDRVToJRMPM+4LrD7/nu2b98Sxm2LGaVpBtHv28D0pbFAzQWqDkBRnGOt5JyJ88r05Yn4crxq0WpNUCupNeW+HwjbgW6/J4wdNQqAXmrFjkNzxhdKgdPTM9PHLzgLYew0XctFhpJe2kPjDONuw7jfYXwgp8Q6n6nTQl2joPn9wH9aVo7rStf39N1I9oWcVj59/JnT68j941s2my2dC2zHLWM/cDgfeH59xTnPMk/ENeK6XhGX60zoerJzLDkzGNhtd+R5YjofWfuOTGUu8Knv8S1hqHYd1ltKabGuztLd3dON268SDd8OFUZNTI4r06cvvP74E9PLi5znxmKompRbWE5HrHds3r5n+92vcKMmX2U9g3E67KR4NRTNn34mn06SnvSDJpZx1dTSSW6RlpX1dCYvkc53dGOPC0FHrVKFOUoRP/b093vcZtRquRnP6hqVIJWzrsnTmRITfuzxo6OsLaq1SRPEhk04atNMt4bLmvY5yJTG2Rw+fMfw7j3WCIVW1/XK6L0cFJfjK19+/0emT5+l0c31yga1zuC8xfYd49u37H/9W30GSpJ+tYUG4APVOPK68vrjnzj8+GecddhBiUZ5WbnGzhtDP2zYvHvL/sMHyUycsF61XprQKi3p8cj69FlSBOuh02ugaWeVIc9Ztt99x3h/ryjPYrWNsbmFa2gKndcz88dfyPN0/e/Kusgc6SyYih87cq3aONzqVre61a3+KvXtE9GUuOCSvHPiI3olzGzfvmXzcEcYN4ovBGFmaoNDp9JSew7Eef7q/m2MSozyy60TOP6SG/61eavNdVup1VCjQOB5mXUzCw0+3zR1BivNnimMj29kvOn7hl5S5KCaXiUaxfOJ+ctn4uGpsTZtowvqblmLjEmbt28ZHx/pNnuMVbymED5OyS6lUK0mwCUnqrGNDYkmoEUrw1IgTpHpyxfWw5E8z9KJWk3dSpGez/Ud/X5Lv9tq9WwtpSSqATv22CYDqCWzvB6Ynw7kZaVzlmotaS3YSpMuGGxnGXYj3diDdaRosHWVMWxNTZMJplTWaeIJTaWWJbLWWVMiK0PPeZ5Zfv6Bx7fv2O3uMMYSnGe7vSOVysvhhdCP5FKYjge9Vt4xHQ7cdQP9bs/Pz098bprVmDN953lJIgP8d0+f+NvTSZdcruRYMcERhp7hTrxZLk3oxUziA5TM8vrC4U9/5vDTj5CKdL3Otn+kIawYhrs9u+9+zfD4Rj8jZ2qOTdMoc1YphXU6sb58hlSwfXeVjWiS39b1Wa74eJJpKQwD1ggHlnNrgpwjbEa54jcDdhilMmmoLwUMyGGfl5U4T5JcXOI3S0ZvicMGLxNfo0qYJgeojbhAypqk14Lb7Bje/4ru7kEmt1pgmQTEbya/EhPHz5/5/A9/YDmdCMG2100u9JwywXj8ZsPuN79l11bx5ChdaUXkC99TK6zHIy9//hPTl08iBHSdmvRJLOFLxGl/f8fDb35Fv9tL0uGsGsNq2gRThrXl9Zn16aM2AdVoq2DFba21Um0l9G1CHoRsMl6QeyHRkMGpJNI0sTx9piyzooR9IK3xyo+txkDw5MZt9TeO6K1udatb/dXqmxtRa7/GFtogQPv4cN8as63WgQ3RZNoNuizL1cGb1gVKxg29JnSNOaqGVjB666zWm75lygMo3kcNXlrJy0yazwKdt6hCJQ9ZbGgrW6ubdH8/Yr20oxf8zYWXWVJinU5Mz0+k8xFTWuSkdYr0rLXFcfZ02w399k7NT5MD6KnJ6KMmNKmBtEqtwQVFaF54oKW2LPEz88sL6+tJj5G1Kqw5a9JjLLYf8JuRYb/RWtf7xpo0OPqWUiStYT7PpNOJdJ4wtEQdIBUaC8hie08/doShU8JP1bTs0386MN5X+kev3HATZdYphdT3LCHgYmY5TzJtJOGl+s2GfnfHcj7y+dNHYkqM2z05aLU7jhsy8OX5ieo8xgemp88wDBRr8CkyOMeXedLqk4INHfl84rCe+Z87x//SdfS1ssaIqY4wBLr9jn67UcRnbS61FluJEXD99PNPvP74A+lwliGrGdUuEZimTYQ3333P/te/1RoYdIjACvaOctBTjMTXJ/L50BonR10VA3uJFa1U1nlhnVY51b3SwGzo2pS6XJvgsOlwwWOMFz6otI1A01eXkgX0nxeFCziP7X0D95dm/mpT4dZQtsiBa+IWJZPWCEW4rv7hkf7tO1w3UPOqpizn5mjXqnpdV55//JHDDz+xnGdNTBOkigD41hC2PZv7B/a//R3j++907V51156WKkAtlfOnj5x++pn1fMb70HisEJckeYxTM7172/igQy/GaOMG15YZj7EULNPHn0mnJ5zzXBLIAGmmo0IfwjAw3N3h+17NeejAS0eLowVeFeLhwPzy2jYwFnBCUAG266ipyIC13UHXGKRT/Od8p97qVre61a3+GfXNjahu6o6+RXAO9/eEzbYxMrmmvMjtnEjrItf6BTIO0o0ZcUCtD9jmgjcuNJi9a71iS1RqLuASF0padZMqWROgK7amSCPpO8DqxuyajrAZmCBTq8WkSlxn1tOB+XAgTmc5npu7v4K0dRZC19NtNgz7HWFQCpC0dlaO4mYfVvpPS2hxAuqDplxkGWcKkKaF+fmF+PpCms76O0ZMU9OiGF3f0d/f093f47yhrmszoazUpOx3itb667KSjmeIsU2mO8q6Nsu0wxfpB8NmwPUe16aGJYn9WdbIy58j0+fA2/8mY3yixIjrPKHvOLnAYh3eGGp0nCbBwUuMxNdXht0eF3rSeuZwfNHkb9RreQ0X6ALn4yvFWpKzLK+v5C4w18LaDxzmmZrEdLR+ZSqZ97Xwvwkdv9l4rHGEfsSPI8Nu91Xu0ZJyaNdUjpoun37+mfn5BQyEIeiQUGoLUTDSwjbGprWl6Twv6C97vU5LSsTTkXh8gbIqQSplSgOkG/v/Y+9PY65b0/w+6HePa609PMM7nbnOqXO629122u62je02TizbcmwcK7ItQ4ITCykWICuWZfEBQRAg+BKLCBHhJPAlgAhKQAkI8cVEhICRQMIkwQlyd7qqazrzOz3DntZa98iH6977rXba3W91V3VXd++rdKrqvMPz7Gfvtfe67uv6/39/Qw4zaZ4J+4k4CxLLeX8KJkhKGlptNcZZ3FLiTGvOskZuqU3y/pAo07g/EPejaBSdwfcLlLWU0iawvhOzTZD3AUqBdycqgaqakorIkZdr+usrutVK1tcxyJaiBTPIdTUz7UbuPv+C7fPnaK2xzrQGOgsMX0F/tWbx+BGrh09w6ws5BMSm20SmsWhDHCf2L55yePoUSsE0uYRWMO1HaknYocctlywfP2a4fCCGrTbdpG0VlJYDQZpGxudPydtNO0hqOVhpTQnHhlXh12uG9YXA87VGD17c8cfPJW3IMUga2WEPbdOhtEypZWLaon078Kslbr2mGkuaRkI4N6LnOte5zvWDqtduRBePHjJcXuCXa+wwoJ2sdxVFbiAIjDwd9qR5OrEsT6gXxSl1SFlpHHXLzFbKvIovPCKYSm5O8+aYzYlajzw/0aamcZJJUzdgnWuygNoeF6/WlFqLDnJzJyu+w17c10tZedZUyFOkVolI9MsVbljg+5b2pI+JPM1RXKXZVrQ1Z3MuH41ZAviXaek07Zk3G8L2QJpm4XuiKE1LqpRMhLuLFd3FWiagLY60WtGvxvtNy1o3hBBJKVNiFNyjd4BqDbVMplTXYazF9l4mqQiFoITY8sMVGMscRg67Qs6J6w80btGSrVIhlETuDKlmVGfx6wU5ZVLJhM2W3YuXGOfor9YU1XOpDdvDDtt5jLakUihKkYHd4UDMmfFwoJSeMs5scybkJBnhGskvL4nfqx1/4GFPpxS2H7CLhTA+jWsQeZEj0FKqxttbNl98wfjyVkDxTqanVCRj3Mh1p7TGWIV1bfo7zoxffoZdX9E/eIzWYjKL416moOEV3qcqJYckLav6PEXi/iCvQ2pYJufFKJYrxijJqNcau+jxqwW27wCopTnrlRiJqIU0zYT7LXF/aI56jfYDtEZVI1PTPM4iF2mPSXmRSajaEplioqLpHr1B/+gRph9QLfKyprlNhcVBn6aJ+8+/YPPsJfEwypq/yJq+8dPQxtBdXnH14Qf0F1cYlLzXtT4ZiJR1KOcZ7+7YfvwJ4bDFWMBIOpZWgu2qVEznGK6uWD1+jLu4au/5ZtxLUYyGThBLYb9jfvmMcthLXKsxbdPQQhioGO1xfYfre0zfIlCpTVphmr4Xxu2Ou48/ocZAf3WJd44SE8p5MfGFgFYGO/R06yXGO9m2KI0ZFth2uDzXuc51rnN9/+u1G9Hr9z+QtZo+ulnlpiVNTiCFUbA/UTAoqq3pyZWqxEhh+16mn1qy5JXS5DCivQLl2pq9kKeJMo/CDDx+n0JLHSrUlOT7KIXrl7h+Ad63P4tgkyoobUg1Md68ZLq7pUYxHeiWIy7r1wlyQWHoLy5ZXF9jOklZ0i1WUSa95aTBKznKerM1OGJESU2UIAaMFDOHFy+Zb+8oMZy+nioiJVBKHNZ22dFfLHGLpTTgOYk+1HfgnHwvrQmHg/S4RYwzClm9lmN+vBZ2pekdpjVbqk1sT1PQmGQCZA3T/Y7d/R7tBvRz0Dry4HdYdJXscFNB10qmElOmaEXKicPtPXGzp7QY1lQLwyPDdp7QzrKbJ5w2CPmzSiM6TZSQCCGR84EyJ3JoE+5eXOx0lt+p4E8/eYM3G9TdWi94LmOkGaxFGn5rSfPM/tkztl88JU2jaEGtwXqZNJaQZCLpnUwlGyv2OJmvKZNiAlWZNbj1A8o8kQ7bFtEpzbu4qW17bTJpmihzFDNbLsItRZ4zjRKTnTXozuIvV/I6wuk9oZ2VBjRnSoZpuyG1KWgtGWMVbiGNq9LIYScX4b1qObRRm3O9BRHUkgXrZS3DG++IFtTJRLjEWQ5x7WCENoz7HTff/Bbj7T25SoxqrXL4q0oJYcJZVm++wdX779Mtlq1xFlMSRZpZpR0FxeH5M7affEy422A7g7KWHDM5vqJhqFowrsdfPcQtLxr1wgidIEiTrHxHqTDf3hC3G9I4ooxoONH11MCXBuv3q7XoN1scMNaKnru9H6Gyv7nlxS98i/HuHmM0837Cr1f0iw4LlHlCIQeG/uqyHeyQg6Ruh9p6noie61znOtcPql67EbXDsiWvZFl3KchhIu930izVKrGLpenwlORjK2ck1cg5tHVt6a7kRgSYbjgBwvMciIe94GSsrNZqs9ceb+B5PAiEfDFg+iWmX8hN95S3LqvCXCuHZ8/ZffkladpL1n3fS152SuQcCaO4o5cPrhkePBSDiZYbKdrCcVJTZSVfYhBzCgrlpSlXNTb2YBX8UxaNXNwcqDHL1rQlLJUUpTkyHrvwdOteppbWQxXXbkVBr6hKdKzT/Yb5ftd0tZpShLUq8Y+ifaxKYQeP7TvhuEZZWxZKW8lK46KcI4wj4XbHtJvZbPd0A9iu5/7bCe0PXH+4IJeMnic6pcnOkGoh50o2FjpHGTx5nClzZn+3wVyseX7/kjffeof9bmwJUg3XpTRTijDPxJSp0wwhttcrojaVMjgemgV/7tEj/tC7bzMslzIpRTWTmnnVbFvPuNlw961vMd7cYr3BD6LHFTRkRTcDG6XKGt5L/GttU1K5sCToQBtD3G9I04h1TpoyI2gfSkZZmf7lUonjSJyCfKOc0S0TVWtBCNUiWCjTe+yik6SupgPVRg5mWdSIpHlk3h9IUyCHJIeHXugAxntBH6UkLm7n0Eahi1wDuvdohaQ8FTEk2eUFw5tv45brBr+fqfOMKhI+QQGKYvvsKS++8zFpFNOgMTIJ1kq1xFKFXwxcvPcu67ffFc1xKXJYqE0OYAzKSDLU3aefMr54SplFYkEtpJDleolygFFaNKxWG6aXz6EUFm+9h4oR4nwC3ucUGV88J+62zaUvK3szeKhZdMTtdemWa1w/tAFuM9kZLQgsZEuxu7nh2c9/g7TbY5SmZAjbkXk/MS08w+Ulnde49Zrh6lr0sO0wW1HS2M4zr9hy5zrXuc51ru93vb5G1FiBziNGmbDfkHdi4pCYwdY0aslntr1HGVnBy/RT1u41BFQ/QFt9Va1Jhx3pIPnOIDcgsriStbWSFFQSab/H+Q53dYVyoi1V1kvDkKU5rlpxuLtj89nnTHf3GK2wjUdaSybum0scRbdec/Hm27jFohlKjDh3jw7qxjeN89xW8fWkQxOuqBgelHXkmhhf3LB/9lS0lraTaY22lBLJKaKouPWK4dFDrDcNqq1k0hln8jxiepEXhN2ew+2dGCVabnkpLdO9880xXNDeShNqNKDRxpHmKHinUqQBWPSkEJm3G+I444whxsTzu3tWU0YtIzZo0s8GChP9RaamxMNhCcZgjEVVaaR050g3kbTZURCnttrcY1c9IQXmeRbNKore98wxMMeAHg+UlETTGqPo/HKiaoVdrPh9qyV//qtf5WK1phhZ2dYmwdApi4u5wv13Pmb7yafMhwPOuxOTs6RMnBNuEEMQrXGXda0calSK8noZjV2t5VBSCoq27k2N/Vo5Oa5LCoTDSNiN7Rpv8osK2jbcVsl4Z9DLBXrRYbpOmlQFeNGUip6yAoXx/o48B/IciTHivMM5h7IyMa1KWJ5hmvCDP7nyDarpWzUlRXGkOU/36DH9o8coIxrV2hBRFDEKYj0lBu6ffsbdZ58RDqMQKrQ0XFpbnDPi++oHLj94n9Wbb8rPQKGqdsjTCrQHFPFw4P6zz5lu7+QAmhogHsEl5SgZ8saYlk3fYbyFlDh88Tlhu2Pxxpv0ywVoQzjsGF8+Ix9G0VZbJ9NQZ9HWUFIhx0BJga7rMc3sKKv69lmyP4hxzVruPvmMl9/8NiVE+TypBZPr6XA0byfCGHjyo19l+cYbMqWG9l6T7YskVlW0P6/mz3Wuc53rB1Wv3YjWPFPRhN2e+fYFKUbsYpAJ3DH3XOvm8jZY59HWN62oTEBrlWhGMYhocgqEBpRWWoDS6uhuMFrWZEqhSkEXzfDwiTAurW2GFagpcIz3PLy84f6zTwibHcYqjJE0GZQml9Qc/OCvrlg/eUK3WEtzXGtz2kuKizSYijBPpPkga3g03XqN0ka+TtyjjKVgGG9uGV/ekLZbwdkoQ65JnM9aUZJklw8PrhgeXMiEiGMKkEyYaPnmWMt0v2G6vRfod5V1r7ZCFdCdQxlNCkfjh6x+jfVUKrkZu1CIlMJaDvc74n5EV+QfrQix8nKzZZwzKYx0ubK67wmx8OQnHYul5vE0oxZLKoU5B+IcSCiy0cQQqcZQSsbOkeotc5Amvyp5rSuKm9s78hRhFiMKzRQmhAFFfbjmnfXAP/veV/jKoyfkWiGLbg9EP1uVZffiJS+++W3KNMkmv+9wC482mpQiORbRLltFngPON/6ss9IQloz2MhXWrmsA+SSTfq3J03zKa1fWojoxqoy398RDEFStNxhrJFmoFmpVaKRpxhnsslEVaFNG4+U1LZJPn6eJ6e6uJWGBsgavRXqieoNWhlorcZYGyDlLmRO21+RSKFZ0siUkcsroxYrFex/gLy5EEx0DHKMrVRUnuxuI08yLX/gG+xcvhEnqLc46oJBSxvm27h8WXH/4oYQ0CEQUUn5lSiqKqjWHly+4+/a3iKOQGpSSA6hzrWmOEajYXmD+ruuEXlAKcRZjX95v2XxrT377XewwMD/7XN4n1sihF6FWmN6LsSqLdnW4uJbHdXTQlyzPeZLUMq0Mz77+TV5841ti0KsFpWSVf8SnHXWkD7/6Hldvv33S6sogv01E57lFiWbCfvf9+Kw917nOda5z/RL12o3o9OIZYb+nzBNoizFOGilrXjnPnUMrg3ELFIUyjuJiXazBugYfX0vm+rhjvntJmua2mgbbuRPWRjuLAOW1JBsNrhlVWnpR0/DVDNNux923v8l4e4MxRtKdvJVGMYvRqeSC6RdcvPkGw/UDWaWXKvdrL1Me0iz/EzPzdkPJSSZURQDgkz7QX19DDNSqGDd7tl88g3FCW48qiP6wrfdSCGir6S9WDNcXuK6TqbLSaN9hFr0YP8JMoZAqzF++pEaZZuZSMMZhhg7VJkO1TeO69UpemFzRzhEPE3meqSrLa+A9KSXC/T0lJAkf+C6e5W4M3O333M4jeV7wyA10RpOfKm5WYH+H58Fui7pcE2omKphyIs0z2RrysqdOEWIihgmyYx8TQcM0jlhr2e5u2G+2qDHAGKldIxOERO0tdeHpF54/fXnNn3j/qw0/JCYYbSy6XxBT5OU3v8H9J59gGpfVONPiVKURVtrgl17Wy1rLdFHL/685iRmlmWrkABDQ2mGGAWUUcT9Kk2J0y69PxP2BsNlRQgYM1hlcb0kxknMSPJLW2MFhL5aYroNcUanK2n/Zy9S8GWbifmS+u6Ui01vb9xgNeQ5ob1HOSsjBHCWuMldSiJIIO00oYyjzyHa7x3UDw+OHLN58B7dayeQzRcihHdxaHrvr2D97zvOf+znmzbZdT5JsVGvFWEPXOWqG7sE1Dz76CD8sZMOQJPkLrWWtrxUVze6LT7j51rdJU5BGTyuwGtswTxnQzmM6ge1LHKnIWPI4tR7QoKy483eff4y1VuQUvsN4aWYrYKymNkmLdp5uuUbVDLXh3VoksEAPJIHs87//s9x+51O6TvSmErRVyK0JVS304s0f+4CLt96SrcQR61YK1VpUrWBsC7HYy3N7rnOd61zn+oHU6ycr3d42PmInN5/WFKZUcE4SkNywFIB7SdTm/q1KUbJgckop5PGeMglCxRhH1bLy0xpZyRnb1vpiuNFHzqMwlYTlGCdqisz7A9tnzzm8fEGNM4uLlegI1THvu2FvrGf16AHLhw8l5SYXudkaYUySBRKfcyTu9qQwy9RVIQYfaV8oYSTNC0rI7J+/YLq9P5lfcgwyGYJmCqm4Zc/i+oL+YiU3tyKw8lplOqu0okaBx8+bA+kwUVNpggCF7wdJy3GWOEdUiHSLTliJyFq11krY70njjKJNkY3hsN03zaxqq80kq/RaqDEyzjPbMDGFxKJqVlh80fhqePH1gHKFRx/AkynweYmkGAjzJNrTkqlDJz9LKISGDNrHmTEFppDwVMLhIO7+EE99Qx0nsJrqHXrZ87uM5S99+CGuFuIsBwHteopx3D19zs23voVOicVqfWo6FdJU5ygueWsNWlVsN8ihouWGlxM1wVK1bRGzoK3H9D0oxXy/BSXcT6VFpxt2O8LuILLKqtHe4r2DlMSQ1LiY/YNr1u+8jfaONE3E7R5lxfiCUcLZRKb1Yb+nRoHr2+WKUsREZodOGq8ioQ9KQ61aqApNvwlQYxSofN/TP3nM6isfYKyV9KAUZZJ/nK4bQ1aW7aefcPeNX6CMY4uJLWilT9IZO1hyhou33+XyzTdEd1qSpISVLMYk48B3VBS7Tz/l/pNPqLVIBC/IpL6lORUlBwRjQJeCGxaNIVpl4pySmK20ak2xgP9riNAS1IQDDLWlnZWUsOsr/LCEeQLbtdjSdMIvoRRhPPD057/O3edf0HkvcRkNBZeSAO2Vqrhh4MlHX2V1fYVq2wuOaChV5Xt4T55mppuXQl04BWuc61znOte5vt/12o3oEbpOLWjtoDWf2lr8sJCscmNlsqBVixqE2qaX6bCnTAdQpZmeRH+mrSHFIPD4YYldrVDGyMrvmKBCMw/UQgmBsNuwffaM3fOX6FroBw+DoIpKqpQqUydjLcP1NYsHDzG+OzmM0bLyPSbn5FIIux15OghByvWolj0tjn1ZxZZQuP/Wt6TpSxmrDYWGp2quea01tu8Yri4k3rH3rzSlSgwnNcyiPR1nptsNaZpPqCAoGC/TY2GQyqraDZZu6DkB0JPQCjISwWicp2pFSDN5GzCqrYib3q2iyCUJ77Qq7u+2HGLgQGRrZ4LpGTNgOkpIPP164aMrzz/65MDfs9IUoCCFSJwmUpC1bW1rTWc00zhxmGeqUozjxHy/lan5PAuzfQ5Uo2DhYdnx0Gj+8ttv8WN9T6oZ3fegHOMUeP7zX2N69ozOO6wT3a71Tq6nXNEarHfysxvTTEkeUhGDT5ueaq2lKdRasuqtE81kgbS5kybUGGqOpFCYNzvS4YAY6py42K00KcpbTNFYv6B/cM1wfX1KzhIdrQQn5Jiok0hGbL8Qk5w2zLu9ECFiAC18UbTIFPLYnPqKV4SFzlBSJM9imDPDwOq99xmuH6BLouY2yaORd1OGlCTZ6pOvs/30M0pK1CqmOd+uK+tkAlmN48FHH7J89MarqaqiySoq2ndUZQjbDdunX5K2G5HV5ILtxIAo8afC6XVOU6pE/yqt0YhbPqfU9ONyHVUKvpEBZKviRMJw1KQCxEjVlu7yCtt1TTcqH1cytTTSOFKZdnu+/E9/nv2Ll3jrsMY2zW9s5kI5jwwXa5786I+wuFy90oSeqml4nSenRAoTdrUUecN3QfTP9Wsr3XvM0BFvt7/RD+Vc5zrXD0m9fiOahXmJFZ2i6Xqs6xqQXlJQRH4lTt7anOTick0y3ewGKFFuEA2qbboe1RA3br2WZJrWep54nEpR4kQ8HJg2G/YvXjJtd0j8oT8hpcIYKM25vLh+wOLqGr9ctOZFbjSq3bxqlZSoOI+y0i5ZWITGSAToEVhfC2WeCPuROEmMqCoSn6iqwhq5+WZtMP1Af7UW+Lo1p+951JxqJ+75nBPzZs+82aOl5aU0vag0NmI8qhpppi+WjQeqKLmQplE0lLXKuj4XUs7EeUYVwVMBLWO+Qc6zzNbSHMS4crfjEAPFVMY4szczXdehTI8qI4fbic9+ds9Pv3HF77iGv5ul8ZzvtpT7Pdk61NSc0kBSlUOYCUn0nSpVmRCOM8REsZLFTi+HhkVv+UNDzx+ywhw1fiClwubZU24//pQyTngnsafKGbQXIgGA6SzOO6yRFS/NDJTHQE2CKsK25tPbNiVviUTWonIm3d/L8+OVXAMhEsaZHDJKGZwTDNTpekkFnMNfrhmePMIuRBoh+mKDUgW/XMrqfgoYa4VvaSyUgu8HbD8w3t0x3d+hUj49dzkmcimnA42Yvg25QhoDyiqGhw+5ePcr+PUFxOmVnrEe/16RKd5+y/j8GfP9psVhgjIG33lpIisobXFXl1x/9QO61YVod9vGobbHoYxIBab7l9x985uUecR1AwqEgtGkNimmlrbWNOC1ilFMazGC6RaDi2rTeSuHBiMreNV5mfkWOejUXCkxUnKhv1zJ8xejaIu1xK6KjlziOsf7DTff/Dbz7T3W2BbHeUSkiVHRovCrFQ/fe4fF5UqaYiUGTIymxiiHO+epOUrQhaLJd/7BhvVcv9rSvefNf/z3sfzqm3z8b/77zM/vf6Mf0rnOda4fgnr9rPlSMKulAJ9dJ9OlUl5NP0HWhG2aUmI6GYmUtW1aWlpTJDxIPSxQXYdrcYnaWJnsnKI4ZX2Z5pnp7obd8+fkILnozliUFSxOjBmlKrrvWV6sWVxciHauOWtrLqdc7YpMcFII5DCjVJVJahHsi/AWJb+6xEgJkbjfE6dZ+KNaGs9jShQAnWNxdcHw4IEk04RAzgLJVkUSbErUpNmI9nB3kDVtmwAVCspKIlFt6CHjLbbvcYM0MxXhQOZ5psQsq3mlye3xUoqYRY7JOUqmoTk2jmiW9XoOAWc0uykypkinLHOKbMKIwRBTxFdZfT7/NLP+Dz3/6B98xH/QV/axUG626PsD5XqFDhF6T1GKORVKHiEl6mFC50odA2rb3OYA3sDg8FbxAZrfez+zW2y4u9jCZmS6vWO6vcEohes8pdamnzSNHpSxncctepwXuoBwXTM5JGk20SirBYLfeWk8G2YJFIRwOnhU7ym5MG62beqo0cYKB9TothSX/zaLnu7qCn+5xnZDM+e1A1gWl3ppnFM/LETHqnSD6guPVivF4voa5Rzjy2bSK5wOLMY7ajaUGElzIMaC7jsu3nuXi3few/iBmoNMdRv+CqWgVOI4sfnsM/bPn6GLtLilVtFKt0bwGNiwfvNtlm++hXFGNLlGUGoVhJtpLGmaOLz4kv3zp6RpwjQIvrBQ3WmSK2QLSTs6Tme10iijZPp9FBco0F2HWyxaNr1CGfk6qhSyapuHRkDIITLd3gqRYLnG+F4eYZLXo6TE7uVL7j7+lDyNuEVHOATRlhqZvGqjUN4xXF6xfvKIbjEIiF8Bx42HiEgl9GIaCbutaMPNcYvBeSL6far+yRVv/5M/A8C7/6U/yqf/9v+D+dndb+yDOte5zvUbXq9vVhoDri+sLx6gtZYbeZGpg3A0i6BjcjpNEfSxAT2u/VKUzf2wxHS96E2pcmPShnp0wjYIe9zviYc9JURSmk+rcm2UNMJGXLzGDyyur+mvLtsaVb2aZqjGI1UtenSeyTGiKBgniJiSS1s9K1AV0/ekEJhvblG5UoqwH8mpxREqoUtZQ7de0V+sBEDuBHGkjMaaTlbXGnKphP1Bmp1SUUV81TVllBMmowJBJXmD7aykOrVIy2NTnGfJIFfaUkolx9TuoY15WOqpGahZnNVxCvLn2qRaRmmaWCqhJGxRxFLYxhlKIRvPyorGrsTMJ1+75Q1j+MM/2fG3S0KPUV73LNPq4gzKCt801wS7A0Zr0m4Ph4NwGOVigFWP6RyPNfzkZqY+3fL3bkf6X3jKpbM8vhxYrReycm/0BNu5Fo4A3bIlaDV0lbidpZFQzYWuDGhnpBG0RvivRUwqNUsiFbVQtJYJ6DiTQ5SDEQZzhKanjG4MS79aSuxqP4jMoZQTw5XjJBOBn2vjsM61hke39CORpyhkui9s/ijNWs6oCq7zQkNoCV/KeVaPr1i+/S7Dg4fN+B+bS13L5BSEW3t7y+azTxhvb6ipnjSN2mqcl+u75IK/uuTynbcYrh4281FrzlszpozE0U63d2w//5Q8bikxkZOs05WqGNQpaEwWIFXwokYeF+1goJWmsZIAMJ0EWsjEVQ4YWCVg/xTbyh5KPqaGFUoMjDcvSeOISw/wyxXaeuJhx+HFC7ZPvySP4+k9oGyTBHgrKC6tWD5+xMWTJ7iWQFaR61+1cAPleqouhPtbkZzE5tzXpkXEZtlknOvXVLr3PPnjP3X69+uf/hFu/4OvnRvRc53rXN/Dar5Kc7HfbFk/eCArMiWTQbl5yKpYHeP11PHvSRNXU4C2vtZGogmlCRX+J0pLQ1sScbclbDeCuSniyHfDgLaa3XO5UZcqqUrLhw/oVhfYoYd6bI7NqeGqqgXZzFOD01dsd8znlhtfTVn0bNaJ6cqL8Sps94zP75pTPZOrJA4p39NdLfG9xw8d1jr5MaPcUMs0o52jFJh2e9J+FEe1NXIDLqKpK0F+9lIrdujxi16y0F1D2JRKTXNr8CUtqioopen+2s9Q23+XlMXEkxI5BsIUZe2oqhijKoL/0YoQxMCRi6QjTSXiFQRt2cUZC3TawhwwX7vnj+klnz0c+U/CDKsFKghiqDpD1c3cksSkVlKmbvcQgjTvAH5AXyxYa8XvyJUHn3zJt17umT9+yaA1P/LGFf2Hb7C8WIqjOhehENTmv9GCBFPH16xmalEcjd22l6Qeaez1yUSmsjBRqzFgDXmSNXyKVcIBALRoSbU+xriK5MGulvQPrmSKZ2xjy6pGUkjUEAX5pEXjqMTtI8gg0yQDzVaGtcQpcHjxnHB/I5PINhHXXdeMa1GMfV3H8s13WL75Fna5kus2yET+GB2LEYPU5vPP2X/5JXHcy3uqvfX8IIa/nBPVWFZvPWH15A38MMj3Ok4FSwFzdIkXdk+fsvnOt0mHvQD/FRitWnJUoZLlGlaaPAVpKo3EjMoBSGQCVRt0qSij0F4wViUfwfOi75SNgwD3S0pyXZfSQP21SQ8q82bDvN1iF2vcxQXz/Q3T3Z0gz6yWprOCc8IdrbWgvWP5xhtcvPlE1vVN4gNGmmbnpAmOkbDfkaYDJVdx6tdCaggt49ph+ly/pjK959Ef+Ud+0a89+WO/h8N3njF9efMb9KjOda5z/TDUa3/C+vUC7R3T3S22H+i7jhynV9Bs1cwiObSm0wGaSibHiRwmtPF0w6pNTuBkY86FWiNpnomHA3kaJQtaqXbTkxuStY7+4oIwziyurlg8eCBGkKMbvCXPiABMnMdxGmXqRIsI1BIRWOYMtHhMazBO0DHGWPl3Y1m/8zbj7YY0BskONw7/4Jp+vcINHWWeKCFStWmGrIk0z7jOk1JhOoykaUZnuaEZb5qLWFNiBlPRQ0d/scL1HWIpEj1paXnyJUVJ2amVOM4ytDViBKntZ+EUfwrzNBPHPWmO1ALGqNOBIZdKrqLf208RpSSBKtdCLJC0ZcyBqjS96+iMp9TE9rBj9XX4U9vMU1v5XIEdJ8qyh86LwzllGGfIhXJzL+743ESKqwF9vaJXired4/prn/HlJy/Zh4xGUbzj6f2Bhzc7Lq9W+MZKNdpgrcK2TPIcM0YpaT445siLLET3PcrLivk4VT9Os0x7jGG/lylozKBsk1ooUkgyLG4JQr739A+u6B4+FCzTsck6Rrq2mNmSAlVbMZYBxGYG001a0tbA1VjGu3v2X35OCXNL5AIobcJJw1Zl/MUly7feo796IBuDkqk5Nh0s1CyvaxhHbr/1TcYXz6hZ4kwltUtJQpgV1qvuelZvviXECGNOT4+qHDn/gMTGbj77lM3Hn1LjLHSJWklZJqE5BorRdOueFCMlVqE0GIs2ummqS6MeOFJOWO/xfd8muKCUwniLalzSOgfKLAeVnBM1CbasNEc9RSQoqiqhNhyeoe5fko/JXO33ZborCU4lJTKKJx+8y/LRI7TR4tanHTI00oSiWpLbjookpyklEpeSWkKcVlRbX6VxnetXVcoaPvqrf/Y/8+urH3mHD/9rf4av/63/I/H2zGo917l+u9brR3xeXEhDFyPT/T326hLCJDdh19JjiqSfULUkBaUEppKb81cRUNbSr6/k5pHE7JJTkmSleW7rsCJTFI2YMY4RmtayevIG2jpc17WGtsG2kUZRGUMpYkApcT6a+GXdmtsaNcrkRXUe0w34xbKl8IjDWhWoKdN1HQ9/9ENefuObuH5guL54FXnYIPU5ydRTK1kXq25JiDM1zFijMZ0nzDNFCUw+hyjoJmvonzygu1gL/xLISX5P6ACz3AyNZ97vqaGtZa2mtrV4pZ5WxHGcGXdbwjxSUpFI0862m3gmN92r0tKQ7g6SYnVMjyocm9KKs47L/gKvBNFTamE8BB49c/zRBxf8u3XDPZU6eGrvqDVBrNQ5oG43sBsbviijvENdr7BW8ygXHnztKbuvP6PGJOtUYM6Z2/3M07s917dbut5xcbHA904mw1levyMOTGt1OjDIUFMoDKqAcpY6jYIE877hujJhsxc4/RxQyop2kiZrUGKUMdbgFwPDg2v81YVMIJveluO09MibrJJqpFGokqAIs7QaSYQSqYVMyvdPn7L99FM5jDmL6X17DSVCtOQZUPTXDxkev4VdXMgULgd5z2nfGlA5OE2bO+6+9W3me0kOq9qddKbWeWKI5DEzXF9x9ZX36S4u5E2Q8yvdtNaQEspo4m7L9tmXxMNeOJ1WDgJxv6cUMcL5oacbekqRSebRsESVqfqRGACQUkJZCbcQmYywRbVp79daW4qVIpcs7xt1XO1n2QpYSw6ywcgVUpb3Rp1HchJZijZGDohViZmvVlIIPP6RD1k/eiRGpCKUiKPDXmmZbKdxZN5sZBpbc5N/qPZYNMopTNfSndrPda5fXSmtWH309i/5e4uvPOHH/5v/FD/7P/zfkMf51/mRnetc5/phqO/BNV8w2tCt5OauUkJ1vRgOAEoiz0HMRelACVNDL4nu0y16Kopw2GG6Aes7WQtPI+mwE8MHcFpl5kiJMmHBWMxyiR9WGNe1CM4oN+mju9VqlPWEaSKNe3E7a8Ep1RAFqdPMRapW3MUFdlgIgkb4O+3nbBPehpvxqyVX77zRogq96NecGItyCAJTv7iS9V6MlHGD63ts31FyJsYkAIDS1n1K0V2tGa4vBLmUZaVdsmjrpBEV8HxuE11ViqB+2s9aUzMkoVAGpv2O/e0dcYpicrIO1zlqqcxjIDawvvUe05JrcqqnZ1tKnMZaaax27OaRQVuWzmOVYdCOOBZ+6raHbsf/7WHli6GTlXdKMAUICe53MuhOcjhQFwvssucyJt7+fMvi57+kzulkSCulEmthSpln9wce3Gy5uuhZLTvAUKsF1dzYVRiXSluwtq3WRQoihjgNMWD6DjMMkAtxf+Dw8pZ5txfKgGrSEfmr5JKbAccwXF2wePgA07eEpCPsHGniTln1xqBcQwoddZZKg5EJJtaC7wmHA5uPv8308jlpnlG1YbAolEy7fjV2NbB8622WF5fy9apM++TH8zItLbLWvv/8Mzbf+TZ5nE/QflUrVUvq0xwCIWeu33mb6w8+wDrfNKBaGkxtT9NLZQ3T/R33n36GqsIY9UNPKYVpsyEeRkzXsVyvcJ0nzEID8P1CEr6UJh5GcsoYrWWLYRR26PCLXqQ6SotprPJKh12P/WiRFX2OYBzGWDHw1baqz0Wa6hLRSlFiIsQmpVEVVTU5SQOsckY5z5u/4wOWD67l/Vxlw4B1VMkdpc6TbAxiFh5uymhn5DCWskgCrEZ3FowSaYLvv9fP1XN9V/3u/9F/9Zf9/e7xJT/5N/8K//F/43/eDlTnOte5fjvVazeinVWYxRKtJdsZaxs0Xm6aeZpIYaQctW+2a1gWhNPYbiy1Vg43z+kurigHAbFr1ZKUGvtPgTQpSuEWS7rVBbrrW959kpVnq6o0OEeMgXD7BYZ6yhgvVdy3R5amrPo7/GqF9d0pWenovjiuOKv11Ci80rDdioS1OWiVl9i/PAdhp3YDaZ4EWZQLduhQtUree5Sc68XF6jRtXFytcf1AzZUYDm3iCzUGuVE7R86VeXPfXPWCMqSZqkqpbW0K837P4f6eaS/6NqUURilJucmVeZwpudAtOzFQOY/3jt12T0wC6qdWSi1UVUnIYww58nC45O2LR1wur8A4Xt49I8SJKUR+NC/A7vnZq8DX3MxeVQgZXt6LYcppmDKsF+irJV1IvPHxDYtvvJSoz/Zz1dbnKQUxZ/Zz4PntjstVh/eeKwx+ANvkBVobyf1u0aJKWZT3J1e2MgazWKKMNI7Tdsf4/IY0y/OgjRbGJUqA8VliNHVn6R88xK/XJ/SVyllA5+05qrVdH97LhL1ppJW21KrEnFQzupMo1t3zp9x+8xvUaZKZs2oTVdWu7ZTJKTM8uuTBVz/EL9fU+SAHuxb1KYJg0UnHeeb26z/P4flzjscHpcRgZNo0PrcksDc++oiLd99FK0UNszSi1ciEtjXCaM3u+Uu2X3yKsYZySO3gVwlzIIWM7Rf0qwGlKinMeNc3IoFMQss8Q8qnyXIB3HqJ9d3JbGacE91wm8bXhkSrpcihq1S0cadrQiktXNUkfF+0wqDbJqGgWqKVc5ZchGNbFdjFgsdf/YBuGGTy374/DZ+lskTOTrstYRwl0KC9r+SA0Qxb3qBbcpdxnRxcbPc9fKSe67tLGY1Z/sqNvF32/PTf+mv8R3/tb0Gpv+KfP9e5zvVbp167EXWrC8E0NSepigKGzzmRDgdyFFe7au5bdG033EjdB1mpWplEqQrx7hat9CmusYKs9VNBWYtZLnDDgPXD6SZOcytDk+1pWe3FzY4yzxL4tFiKvnKaKKm5yjuH9h7bDdh+iSoZQpT1p1KvmltjqFqTDlvSYUeZQ9PdaVTVgDnlzis/kHJhfvoUlWVShFaSIINqUzYBsVfr6VYLrDHUEkm7fVuJN1h/SY0oY5i3e8LhIM0kSPNZoc5izDC9p+TMvN1yuLtnHhuyxhqMlZVmzYVUBAk1LHox4Wglg70kDvGUy9FDLLzXFjGaKBhtMcYSSmU77ejdwKPLx8xhz27eUyP8aKy8/fzA79mM/Oyq4xes4hAiyWoIhTp09L3n8fM9j7/xjMs7ybovVSZiJ9oPtHhN0FqznxIff7mhIhGel2j0aoHzLcGnHXzMkV+rlaxo+0EmfjlSQma62zC9uBUO64NLYcaOgTQHTMko4zEG3HJBf32NXSxB1eZuV3LAKW2KVgsoj+4lupYsK+OqjcCJSgtKMIaaCncff8z2k89OTnClZDKnkTWyUgq/6HDX11x/8CGmW0p0ru+gW8rFXdv3zoFxs+HZ3/85iAE/9OSQyEWkDVpJDv00z/jliic/8hH99UOJNq2CVwJaglgGpCm8/c632X3xOf2wZNwc0GiMUaRxQgHL60uUVqQwo43BdwLlN52jVEWZw2nLoJ3gxfywwJgW5WsNVEWaRTesrERmyqQzQ2nUAd3kHy3atbYJtNLiMqxhppZKzhmDfF4A5Fzbat7ir694/NGHWKWaKa2T91ROQDMwGk0OmRgCthuIUxAjEvnUBGtnZfNAxXQDrh9eSTPO9auqn/5bf+0V5u5XKO0tP/Uv/1X+3l//137Aj+pc5zrXD1N9D675KjfLklDWUtGkcce82QjQ2kr+vDJaVvTHSMucIZfmKraNz9gc3M1tW2IgN6C7WSxxqwvc0E7RSolRIyVoKSloTakQ9lvyeJCVq3OSvCLOB4kh9A6sxfQ9fpDEJppzHuNOUxCMkeSfMJPGQyMAIOve2qahpjE6W+b2vNmSD/uGCdIy/YTW9Blsg+Mra4VrGANhEryVaQEAFIkWVcaQc2G8uaWEiLGupU9BykWiHY1GW0vYj4z3W4mUjBGoWCtO8VoqOQgD0Xrf3OPSgFYqxlq6xcD+5Z45NBYplVLln6xEi6tRGCMGn1IgpEBtoQQLvxRU11gopvA4j/yRw8zvt4ZtLuxy4RAzt9NIN98wHGLL7lYNXSTNWZZfwipY9p7BGRbOYLUixcRmc2B7ceDiwUVzdMuUUp00ycJ5NJ2kTZV5ghgkvvTlLXGcMd7jFgPaC9BeFdjuD6iuxzlNtxoYHj7EuEHkEDL6Po0ta8onXqi2BuIsxiErkHyqahiliu465nFm99m3CZt7SfahYYXEmYRWRuQExrF+522W77wrmfAxUdOM6hZQcwtyEL31zbe/yc23voU3Br9aiNbYaoyT/PY4z+RSWb7xhIfvf4DvB5mCIk54GfnL2LmWQpgDt9/+BvPNDcoaQjtsoaAocBerZuDK5BxQFLQW8Lv2IsMpMchh1DTjkwI3LKSxU1p0urVK6MLx8FjrCZ+mSpW3tbdNF44Y9HJuzWqWJrrSAiayHOLkJyG2GFxtHIvra66/8hWs9Y1WoKklimzi+DrGQJ4CcZ4Fs1bB9b7FD0sjqjsvCV5KYYzD+E7W+zmfXr9zfW/lH65f0VNes5RS+Adrws05eelc5/rtUq/diB4xQBhPzoU0b8kpiMNcWcSFOlNCpJSK9g7jxEyitBG24THBxSh0Q72klGRa1PX45Qo7LNDen3iNUuIll4SlSJom0jTKWs9aaQ5LJo97mWB2HcrJzcQulhh3TGtSwrMskpYEgnGpFdJhS5lHalv91VpfDUJygZooxpCmQNxvqCk280Ul54pyFo3ESBZjMcsVzneUeU86HARpVBL6ZBZRVC1Nz3S/JY4HdFUtscY29qPoEp0Xvef+5S3zYU8pzXjVkmoKoIpEjlrv0c5KvGVbc0LF+k7MS8YwhUSMuU0AKxnIIuKTVl8pCpVUMsbUJqkw6CIu9856LliQpky0iewjPmRWUyQfAoftxGVD9yglE2V9XL0ajVUKZxQLb3i46rle9XTW4KwkGi0XPRerBddXa7pFjzaqNfwObT3KO2kOnegd82GUKMyQCPf3lFSwXSfNODR+q2ggV1cXYC3rhw9xy6FdF0Um0/loJ2/cVW3RXS8T2yQRnLTknppbOo9SFBSH21t2z76khAZ9tzJZxinIlTRnUs70lxdcf/gR/uqBSFvCTI0R5QfRv6IoJTBtNtx9/B3GZ0/pjESbzocZ7Qz9ckBVCOMM1nHxxhtcvvV2S/NquK5jQ93eQyVFDvdbNl98Rh4P2K4jVyUJUihimAVf1lmZWtYkQH7r2+OSaW8KEXRteF4t19xikMOTUfJ1cxYqxInNq8hJAhVqw6UpBaoUibdFoY2TSf94aNfrkb+q0N5QsxZ9ttEYLe/jxYOHXL79FsY2TJbv5LVMSSaqyC+nEIjT4bStqUVeb61ED6paVOwR1m9dOwQ3OcHRqHau761+4l/4S98zg9UMHT/+3/4v8/V/+f/A+NmLH9AjO9e5zvXDVK/fiCqoVZHGHTlLNry2bbWdC2WSJrQa3RoQcZ4fNaWqZZVTC6Tm4harMm61wi/XsnrVkkJTc2o3VU2tSSQA00Ta7yDnlu7S8qSPaUIAVhBJrlugnT+hi1Cy6qMlESljxLEfm1OzgnIduh7z03ND9VRyLuR5alzThNWa2ly6x9hCRWNfLgf65Up0otsdcb8T7aBWTdNnKVULdvNwII6CwLLOodrELOc2KdXiPJ/GiTTNp+dD26Z/y5WUpCHqB4cfenTDZtl2A9BVUoIqolu1HuYgyTav9I8yET2uRdGaDKSS0RSUMlSl6LRo+Uxx9KZwkQbiLjINkU2eudnOHCaJgnUenJUp57JzeKsxStE7w3rhuVp2LAfP9cWS1bKnSScx1tMvBrqhp18v6AbBMmmtZeXbnsNjE5rGiXyYSNNEnmZqrRjnJQxAK3IUUxu1YhcD/foK2/WnjPjjAUUITUUIAFWhrEc5cViTBE6PFj0hOZ8al5Qy890N0/2trNKTIJxs54F27eSC7hyrBw9Zv/MudnUp12wU84zyncSEVoHW758/Z/PZx6T9FmstJbWpogLbWWKIlEn0xxfvvMPFW+8IauikndYnCQxKGKD7mzs2X3yOUhW3HEhjkohUJaYh7QRAmkKkJDkwmcbPLKWQY6S0n1+VSm36T9tJzK+2MrHPMb5qQpFQizRPxGlq5iXAGHLKkmxWRVZSkqzNa0riUs9yaNXm1e+JblwOuYtHj7h4/AbGe3mtupYOlWnSBvn7Yb9vCLfSXPRFUGMojJOpumraY2Nkq0PTmdOCAep3adLP9Xp18bveRznzK//BX6L89YqP/uqf5Vv/i3+X/Te/+D4/snOd61w/bPX6yUqbe3HNGAXWNFNBpYbQcEhVUoda06cUgiVqyUBH9AxKbgim71Guww4LbNe1CY4A6GsKDQ5fyCm1VKKJmrNM16xki5eYW6oN6H6QVewwCPhcnRSQbdWZvsuxHAQSL/t3cfYaJ3funCh5phpLUZo0T6TDSC0SyamMGElqrieTk9IW7TzWW4x35P2OtB/JczhNVivIihlFCYE4yfOmjUa7joKYTcQJLc39PE7Mu4NkyGuN7xuzsSoBgVdpYLtlh3MGaUBfTXcKhRqLNP3l6FhWzGNEFYVGcUw8f6VnpPFFCzFHUlEsvKfUwpxnjNJYZTDasrILaqpsdxO39sBF73i46PDGYJ1m6BzXy56LRUfvDENnGXrLYujovcP5V5nltcVjGuclxnM50C0XjbuKNDFtGqlqpaZECom42RP3B5l4Won1PEaliilGQgPccolfLXHN9CbVJuTtGqlFNeyTSCNoyCuOWtCjdhNpzsJhT9yLnjilWdbMzWSUUxYNZVX49Yr1O2+zePgY0y/l2gszVStUtxDtdcmE/Zb9l0/ZPftC1tpo0GA6g+s9KUTiOFOLwlpLt+zRWViYbrEWM19j9Cot78MwzhxuXhK291jfeLcxSeNLW33XQolJ9Nki15UJpzZNvpJJpZ6c9UqJYcl4jzlm2IOYko6MT6Wo1pJiIE5Tm4LKdLTU2p4bEYfkFMk5Q0mi0ayVkirKtISwEE86YrdYsHryhNXDh7I+RwsXtLb3ehU9ak2RPI3E3bZdO9J01mb4EzGATNW10U3b6mTCHefGFW1vXH0G2n+v9e5f/Mewi189baB/8wHv/+U/wcf/1v+d3dc+/T4+snOd61w/bPXan7DHSYQYhouYC0qhtumHMhatZAVblUIVmdTVNuqqTe+l+x7XdeJab7nW4jrOKC0g6dry5eNhT55GuYlZg2k312O2em3IFjOIscD6TiZdtYr+tNC+ubRbpSRKmFojmUXnp5tSsh5XiRpcT55m8nSgzJO4tftOknRCpKqKslYkBM7LTVmBKol4fyDu5THXhqwx3lGtI8VEDiOqJHRVbeVXKVWmw8Y7tFbEw8jhfie4p1oxRmILtXXSXOWCVgrbd7jl0AwsMyW1ZqyxM3OQZt5YK7xFpTDGMI4inxC8zS+WcVVU4zYmplJEpjDvoAQhaSmFM47OerzxrOySt2JmsdQsHxuWQ4e1Bmctzhv6zrHoxa3vnUEr0dEarUXaoExDMtEmYBbbe9zQyYGjcVJLLdTUJlW5kEIgTbMYypQ6aYSVbS7oxqDU1uCXC9xyeYpMPcYxyfq26QgB1fiZ+qgtbM0aLc4WGoc1J8b7O6bNHTUEShRjkBidNCVXUsyYNrlbvPkW3dUDcdjHmTIemlzFNlNPYXr5gvvPPmO6uZPmq1SMNXSDx3aWMAbm/QGUolsMdIsBqxV5t2VOgbx+QPfoDWkKm0Z6vL3j/umXECesc2iliKGgqjR7VcnYVFuLbgEApsloBHFVQOUW6SsmLmMlPtW051trc9pIlBDagUeupTxPgjhrnw+0LUnJCWMUpUAMUcxcqh3A4NXktBEltHPUGrCLgav33mO4uPgu7q+Vx4mWBCorBIG421KSpCPRDna1fSZJsAVoK3IP43shU9RCkd+Qz4JSwbpXZslzvVY9/qO/G3e1+jV/ncV7T7j6PR+eG9Fzneu3eL12I6qHXnK6Uz6ZOKpWGCVO2uP0oJYsN8LGa6xF3PWm67HDIGvR46q8mRjIx+mIJkVJV0rTRAlJGhcnGrlaszSXSgxGdljgliu076R5yFkQO0c2qK5yP0kSkVnCfDKflCKZ2aQIWqO1pRZFipLwVEJA1YxuzYkYNI68IS2mquVCbpg5k3d78jw2U3eSpkTJDT2VTN2HE5ZEKXMyZmgj0y2sI8fEYbNtmfKinVVGdKNoLbxGo3ELgfkrY7Gdl6khFeMV1suNM4aIKqB9J2viUhoj0XIYg+CLXs2MT4YlmRlXUi3kkogxsLQ9tSTGMFJLwmrLyg+s+xULv+BCL1l5w8N3Lb73WCeTca0VRis6bzHWNQRSPhmWMJLpbaxMHJU1uM7LulVBjhE4Mh4TRdAC5EZEUEcSg1YiHwBqEN2x1gq36OmWS0zfVvEnk1htaV6aSiMruK45tRNUaVQlQSk2Y5SiKsO82xF294TDjjxOlDm+WkMbTUnSwPj1itVbb7F8/AZ6WMr1WDI1tHQsJ0a2XDL7zz9j+8nHxMPYwhvAOYcfOhSVeTtKY2sNvpPnWGtp0LWRnydsbqml4C+v0MZx99knTLd31JqwVli6aIVt0bN5CigDKUosK1kMQdZ1oDS5FrkeGuWAqjCdFQ2ykUmiMk6m7UlSynIMaO+JIZBDQB+JE22qnZNMmOX9L075UjLGWNls5HKiO1CbvFVpcgV/fc2D996lX63bZwUnGQ85Q5hOUovx2ZfUGNDOob0TuUQtzaNo24FFErGsHxrqCTngaoMaFtIMN31tHs+pP99LXf30R7j18P35Wj/1Eduf/4T7/+Rb35evd65zneuHr15/5xRmjtnPJQRKRVZzTtJ76mltqYS/2CITlfP4xVKmDkqdVuZKNYNBEZB9KZm43xJ3u9MqzXZOVuBVzAXUQj02oMNCvqbzzW9yvDlpsTa1qWeaDqI3pf2ZNt3Qrk27mh4wpUIa99QwN2ORME+VFgaquIY7ChW3WEhmdynkeRad4jhSYmwNc8X0nTj7D1MDn0uTqJUmtVWkUlrMWVYxbnZM20YAAJlithW7THEUfjG0KZ6R1WnT5dnO4xgoMVPSLIxNo/B+ITrHinBGEef04TCdNLVHaW1Foj6Pv5hrJaSJXBKqwnbaUnLBaYVThZAC22nPxbDmcrikrwN9Z7BOJmbUilEIp1NbaqnSeGvEuKYV2nYcYaKm61taT2tSksTGKlrzXxQ5BNI0NpKBEZmHbpIOqjzuBijvL5Z0K7nulG1mtSp4phNuqWqq1RjnxcgCMmFrzxMpoRqRIRcY714S7u/I00QOM3mKzchFY7cqYkws33jE1Xvv4i8foq2X71vkMITRqBYqkGLkxde/xvTsGTnMQKEWhes7yYqvlTQHai30C4+26pTCVVJq8guaOcqSw4H9l3tShhcff4IfeparhTBqlSDIjLeUmDCdpD6VkLDOolyPbTrmqhQqy3tDVv1VQho619K+LMo6AcLnfDJtae+Y9wdJBaM2uoFFK0POkVOqUuPsppzahFTe2yKDVZLeVOS9F0NkePKER+9/Bd/5FpKh2uveLtfjOl5bphfPBPXk5PBWpJsVLbeWpth2FpTFLlbyOTUe0MNC9MFxkubWSKpX3N4zb+5e+2Pyt3u9+Wf+AMsPf+kUpV9N9W9c85V/5k/w7fn/zPbnz5PRc53rt2K9vlkpyao3t/Wvb1OrkiQ5SFl9gnVTKsp57FI0eVqLtg9ozmSgCne0Gk847Ai7DTWWNm0RTIysy5v+tBboevr1BX7R8uqBV2740pJrCqVo8ngQp6xSJwf+ES0j0HxpLJMqzPcbaphOmfWn7ixnaq5o78F57NA3/EsmjwfSLKv6HCPEBEZJWpIxhHGkhiDs8DYBqrXIhNMbTCeIp7AfGW82xINMypxr02WtSTFRcqTrPabrMJ1rWlYDGpk6OokhrE0uUStopzFNd1vmJM2tjG6hwmZ74BjteZqKVpmEgjjoY8kc4oTTHffznpgDTgkH1hiF15ZUCreHe2KKPByuSHmNMwatFdYYjBbdqjylRaZOSokHRClKTvhlj+17oDXdVeIfRTNcMN6SU2G+30k0alvbakWTdVRKTOR2XfXrBcsnjzFdfworEPd1m3gdObQo9LDANGc/zawk13qhpIimonwvwQF3t9Qwk4MYx0rO0sjJj0JKCbtY8vDDH2H14Brdy+S/psYhRf6gNMWV8e6W+29+k3mzJeVMDBmjK13X4YyhhCRGq4owRzsnj69UKtIsYo8NoULlSgoTYb+HCstlR0qJ7WbHai0/J1WTg+hDtYOSM27ohCphbUs3kxQrXeqJ0Wq9l9eygvJGMt3nNlVXtHSyymG7I44zVksiUYkZpQspz20CDTlmUskStVqrJDIFmTqXKpPqo0Y61cz6K+/x8IP3MUrIGFo7WZe3M68cUgsxw/T0U+q4F3f/cilIOZrkpk1AtVHUqnFtEprHDdoPYGzTnosmWFlLHkfCYUc9OvDP9StW9+gSu/j+BgB0Dy/48L/+Z/na/+R/z/jJ8+/r1z7Xuc71G1+v3YjGw0StSpBInUPVQk0t5/2opauSS+2uHjJcXMtquWkRa0PJVMrJORvnQNjsqLmxM31DNmklN9zUEliUwl1e0q8vm36tJbGkfGoeZOon2rg4bijz3CayjpKCoH+cOKVt31NzlRjD/U6wS8aKnjXXV42DNijn0cslbtFjrBb96v5APEyUmMUtbLQA0hdLwnhgvtvIWtp18qO02FDVHPbaWUqamW9v2W8PKC2TKoVwEKmKaZyxTtE1wb+2Gr9conVb61ck6lKp5lSWhtMNHdZZcq7kKbbnRhbuKAghcHu/P603helaKcdeDDEqhRwZc8TZBaZYJqCWRKQyqA6MQ6I3C/fjFhPhK27N4I2YzzCvHmtO6CZTQFVqi5L0zYxUUj6xOmsM4o7X0jjNmwPT/T1GyZSKKtNs3Qw+OYkZSxnD+vE1i0ePUMZTYmq9SpGJeAGx4VRwDtMNDSGUTnieGougvcIsjbK1jC+fMt3dgVKkSVbOtWSMtyesV02J/tEjrj78CO8cSrvGqS2vNgVa3Nkoze7Lz7j75jeJ2w25QGrZ9cYJtiyOE1Up0cp2vjnHo5h5jOf4ymllUKmScyDNs0wdW6iE1grbSBEhZPzQYXTFGCvNqNJYa5vfTsn7SCOHnCTPnfEi+zjqJfUwSO+XZpSqmEpLuarMmy1Mk/ya0shcXxPbRNc0Q1GpQsPQ7XnJjQl6xEzRsuErcPX+ezx4/yuoo8hcG5nsghgLtYGYiIcD48sXlGkSbqm2MM/ynA09xvr2OgNV4fxSXt/9ljJO8v20Qnth/2KdbDl29xgj0aXn+pXrzT/9+3n4h3/nD+Rru4sFP/7f+qf5+//d/9WZMXquc/0Wq9duRI3zYrCxwvOjVvnA1zK5yjESpok8B1JVDKsLmQgdhwkly8rPWsI0kg97UgzikvYWlJg8SluD13aTcxfXdOuVNK9J1vi11gaabje8FChxJk2jgOVty/RuzlfdLeQhxIg2lmm3J+22gCBqwhw4vHxGmA70w5rFci2u/mFBd32JLklWxKmQDiNhu5f1fS0o5XDrNUUpDi9fEvc7rLEo7STXXVUhDaBRGnItpGkkTSPxMOG8b010ERlAlcz5rnfYTsxLtutECoAWvWtBjFJGXP0lSSNm+h6tLWmcZHrYGoxaclt3ZqYkue4nnV0T5KnmLDv+6lwix1yegugFF26QCFHnyCUxpolQKoPq8SvDaunxw0JYn6hmfrEiSTCSPIVR+KHDDYM0AyEInL2lTulhIWvsGAj7kXiYcb6jVkUuFWeFmlByIrfYRr9csHx0jV+vZVoYU2tkm2u+KqoShqqgkpSka7WVLTm1Q09uUhFpbg83X0rjmVM7eCThxTpLmjOqyKFq9f5XuHjvq+gUJRzBuuNFj/CENEo7SoX59inpsBHAv7Wk/UEm4Z0RMkGYUUC/WNCtFxgUNb5CnRUFaIt1DijEeWTeTyilWioQ5JSYDyMajfNOdK0hsLxYo2pp16WSA6RWAqanxd3WQlFi9jPei/5TKXk/aA0lyPuzcVRLqUz3d/Le0hpT1enQEWKiJFn911KJIVDCLOlWysrngVa4oSMfIrVWcqnozvPoww9YP3okhIRmEhOtaYU4yyFRW+ZpYr67gWZOM4tFS1SrqJKpIZE7L4ZDY3CrKzkQlATWYZaNbxwa4aJfkg8j+f4GyOha8f7smv8Vq0kztP3VIZtep0zn+Mm/+Vf4//71f40yhR/Y9znXuc7161uv/wlbKrScdSqCyam1gapncioY6/D9QIqR7bMvuXzjbXHVI6uxkgJhtyVnWY2b1kwJuL42Z2tGUbCLNd16jXadNAdz++BRx+ZO1mg1zKT9pqGSCtpqyM1d3VJ4xGFfGv7mXqaTVeIuNy9fcPviSw6bOzSwuHhAffN9Lh8+ZLhYoUpA9uoQD3vm+x05yKRR9R1qsWC32cB4QKPoF4uThu6IjFJKtHzzPENNWCNoHOPEua2NleSXkE5uXtt1uMVA13doFHGaqZQTP5WayVNz1TuZmtVUyfEgpjFkZa2Pcgmt6RYLVoueh29ckX/uizYBFXNMpcqfpVIQdFOplZRnUo5o7Qg5ctWt6G0PVDpt2cWRXdxz+dYjutXqRC1QNctBoCG9Si1MhwPLRw9w63WbZCvMsJAGZDrINEzLxC6PCTJCV2joJqd1ay6Fz6mMZXG1Zri6xHRDS77S6M5L4lE8XjOAUdKEUlFReKx4B1WaFUk0kvjJMB6YtveS8hMSaZ6oFMxC0FA5ikHHDB0X77zN8smbco162/TR0szKG8WilCFPE9Pdc/J0wGjDxcMH3OciLNIghwlpWC3dsqNbLdBIcAHKUI0WqYpWGCs66DiOhP2IvGqqxX4a5kMgxUI/eGKtuE40sjVEXN8JQQHkvXciuALtwGI6LwzRCmroZWJcG/f0qLVVilQLcbttRr6K8p0YzyqUlDEtsajkKCZCrXHDgFKacJilIWx6XGW1PAfecvX+V1g/eihTUCNTbOU6qtby2pUMyjK+eMn84ilkIWEo58kHea2UtdJkk6lhQvUL/MW1kApKRDkPnUdlOaiIdr2SYyTe30CJgnMy8lyf65evhz/zE7z9T/7MD/z7KK2xq4FwbkTPda7fMvX6rnmlhCPYElQq0tgJQNyJBg0lyJSUROS/XuP6JSVn4vaetN2Ka9Z7lG3r0Hxczckq3g4L3MWVsEBLgWlsZgQv09c2WSuNE1jC1Jigct+qzeSgm3O7Vpmyht2efBhPSKn5MHL77DM297fkBvDOSrHd3NFdXnLNG/L9qybHRJ4m4mGk5CIry95TSmG6uUGVIlGSzqEqVFVkKpMTBZnylJxQpcj6GSWoJeOwnayRjw76CljvGVZLlLWkJED1GkWykLVM8lQuKNvMPUUMZLVp7tAalYq4owG76FldrEXrZzTv/+g71L/zc8DJoNwmn6ITzbUQayFTSSURa6Y3PUYVWe3WilWa3nWsujX2oeb9H38D1/lm3smUqtvPCjHI2lgp2D9/Thz3XDx5E+s8pEAc9+RxlsdxmOSQYhylOZm1c5gGLC8t4atfDHSXFzItb8H11dq2SqY1K02b7LyshrMkLEn0pRZWbcnt2kukeWTabpmnEXKh5NQ00AqNFnZrEf1if3XJxXvv0F9fU0IESWuXqb1tbFJEmxo2N8TtzSuWZhV968WDK3a3t0xNL+mcYVgvmhyjufaVbtpIkS5ooygZpnEUI1wjT4is2DCHyBwD3nXgHF3nTuxd43zLu69No0tbV9NMRJIbb7vulDKkraWEQJ7jK1VxyUKXOEyUMFOKrN5N22zIar+AbfrcQgsBaHzVJHn3JUX6peS5K10xw8CD97/C5eNH7XVqh0kjmxdVi0zLtSWOB8Ldc4ldLdJ4kiSvXrXPB+MdtWZst6RfrCDMFEa07yXVrIisgloF26QUadyL/rhfyLWThNd7rn94aW+/L7im162f/Bf/Of7+f/9/zfT5y1+373muc53rB1ffQ9a8TGYwgjgSw88xklIaq9ISZ6z35FI43N7QX1TyNFHnsWFyfHNBy6RUOOsabR3uYoVbrATaHmObJirR3DknppccyfuRHKbWJLxiDoob2TSnuSZHWQOmBo/PKTOHkf39Lfe3L4jzJG5nYwihYIzwRG++/IL19TUaSXXJYW6P0WKXS0l5GkfqPGO0wi6XGCeZ4SnGZkzKDVIvZglxg9smaQCchxjJcySMMwXhOXbe0w0DWrdIQ2iSBtOmnLIqtcMg8Xk5S3NWiuj9jGqcV1lx+vWFuMe15GrnXPjJ3/U+jx5f8MmnL6UxOr3GrRmtEGumNM0vVRPIrLVr3nKN1cKNtYPmg598yOX1GnKR6NbW6OVcCfN0MoAJ+9Ewb0em5Ui/AIKwWksSVNDJsFSD4KmcAyNyjNqQTX69oLu6wvRD0yZXsALyJycoEiFZtUG5TnS3Wdz/NLMQ6dhYaXKYieOecbeRFXNb2SttZRJqNTkl4iFhnGPx5Jr1u+/i19eANFHK6Lb2t5LEUys5ROaXz4i7u5Y2Zo9PM6pklNEsry6pQAqJoXd0i56SK7m54rUW3qZxpgUmVcJ8YD7MMnGmhSu0w02aA9YZbGdO4QTW+5YkJc3WMa2otuliQSbO2hqMl4ZfGSP80Bib614MdDVF4hxI44yiipmpG6ThzIWj+/0os6mqoMVZRp6CYLhaGIQzCm0UcY745ZKrDz5g9fgRRJnGtwE9qoqUpLbAgHAYibcvT1pW1VKylNEnJ72uUJXB2B7fDxAnck7y+dOkEzW2THrnKGjyfg9xltfRyPVUjaHsz/imX66WH77Fu3/hj/y6fT+lFL/zv/fP8rX/8b/D7uuf/bp933Od61w/mHr9RtQasIacJO/Z2kH4fClSsgJnRQcYJQPdOJnM5SixmNBuGPa45ms6rn6JX65xXjKtZVUamwZMy1REKUoMwhedx8bYRFb6hZZOZNBdR05J8qtrJYd244uJMB7Y3t+w29wyHw5UpXDeUnIlRElnysfBR5p4/p1vMG5GLq6uMc7jBgfWCnbmsBXHrxcDlGpNYwmBmoswGEuiNAmA8Awl07tGmcKUOZBn+Tlk1WpwXUc/9MItbY21MYY0R3KViZJ1Dq21rKHn+WRcAai5UpQgrvxqRXdxgfUNH9Qc47VW3n/3CX/qT/40/8a/9XcYp4BRRiZUVEopxCK56ABHpajOBWU7yumCUPjB8saPL3n0lYX4XJorPOdyArzLGlgOEd+dinW4uyUetnTeSrR75ZQIReUU51lShCgIJeMcfrXArVZo152YsKpFzUoefIvjVOZktFFHPqQ6RjxKA1a1oaTAfNgybe7E9FRlzU1zaZeYyTWirKG7vmT54AGLx49xy3VLHiqobmgvgRijKJUUE/PtC/K4F+pCrTKKb9Pa0tBgiiiIpVyEQ5qzrLVNM3fpFmagIIwTcQ7EObQEItHvmqbLKym38AIJDLDeYq1EvlZUo1dADElW5e2gpH2L6jTy/EtoQCXn+RXMv6GvckzNsCX611PKWRHTkzGGFBMpBlBiWZIGtmmqG12j+67ggO7ikqv332P54CHtxZcVulYiw9FGdOApEqZIuL9Ft2Zfue86gDQXP1qTpoCyHcPqEtMJysmk2JpWRZ1G+fPWkYsSVmhrVFW7bmpDTqlz1vwPXWlr+NG//uf51r/+t7n7e9/4jX445zrXuX4N9dqNaC4Fk7LA462hzPMr05JrcYBUqhW4uEwlGxRaaWhcP5qT2HYDpu8wyxVWm6bjTCeHMdDWh5m03xHHkRyDGCdc0yGiUFag5kqLezfOUcD1QfSZYR7Z399w2N4xTwdySiePSsqVeRb0jzWKvrcYo5lj4csvXjLcTbif+AlWiwUpRvJ2g+TCS5qSmDakGc8py8QxZVKSSYvAsw3GaMkRL5IYlaeZEqQ58r248QVQL/8AomVUipRkYmWc4GeUMQ3Q3QwcSDLTcd2q+wF/cYFbDM2U0TicR4RWlef5j/2RH+fzjz/n//r//BrzWDD6FdA+lUJqPNNMizZVmlwbnxVwC8NbP7HizR9f0y1Eo4ox5CxNrOkcrjPkEIixYLxIOkoz/1jvUaWSY0Urc0p+Ek2pao5qiYu0TpKW3HKBG5ZNN9iSkY5pPLlpB7VBGyuHmhSb+U0mubU11cfozxQmwigxndKY8Yo5q6QpVEDRhsWTN1k+foQblig/SPpOFs7oCflVCzlO7XqdIIZm8Kltul+bxlmJ0SdFaoyoIo12OTZ0xsjzZcXBXUJgHkfC7gBw0m+WWsUIpKGEcjJvGWvp+l70tWiw0pQrhdAESkIgXQrTedGNOidECiWazZJSc7KLdjvF0KgXYmoSJ3lphsDaDg5yjc+TJCpRK7kqCbIywvEsVHSLsVXW0F9esXrrHbrl8qQFrg3Sr0puXFdI44FpsyftdzJhbVgu1dbnx88itCKFyLwPMIOydyzfeIzvh1NDWcexbVAcKRfyPKJzPiVrnQQrciH84q3BuX5R2dXAw5/5wTjlf6Uyg+edv/BHzo3ouc71m7y+h9W8rGTRqpkTZEJXlaa2BhNAK3NiO9YUqdZihl4c9hWUc9h+wLljIhCnlJxT5GaplCzA63QYme/vxMDT99JUoWTaYsVJW3I5gb9rY1CGecf27iX77R0xHKTxyPV0A4+hkGvFaMVyEBB7iIX9GIkxS2PqAuP9l6IJ7Hp87zDDUm66VaQIJWaJm2zpMiVlSDIpMp1vg7LS4j1lappzwfY91jus9SfzSD3+pzSWJrKqtl13aigllccJLeAIZgd03+PXF/jVSiamtImxaukztbmSU2S+30CY+Mf/6I9jLfzd/+gTnr3Yyk25VKIq5JqpaCKyUndoQs4sHFy92fPej1/x1keXdBdDSxTKDeiPuP2taStYg+la4xQCWgnsX7V8b9WuLdWaUKyViWHTU7rFQLdeihTBtMOMMqdpJDnJgaVkWSsr0RKK/rNNs2qhRmlSlDWUlJjuXhJjEH1xqSjjZFKqpQkuSWJk/dUF/YNHDA8fY3wvK+paqWGipPDqcStNnGbC3UvKNHI67ZzgBPqoGqXmRMnHpC6RXpRyjBkVJzveopwjjjPzbk+eZ5mSa9NW4LXpoCHPiTyL0a0fBnwvaVq6JYwds+xLitSa0aa2g4/HDT3q2KxqfUoh+274fDgc2rRVjIL1eMhqEbXHCNYcEjGMIhXItb0njvIAgzYyWdVGo7xn9eZbLK+vsf3wagOitLx+RWJ56xwI+x3zbkOZg0zeUY2dm6hNpy7acEUIkfkQRCtdCuHmRkxojx/hF4NgoxRgvSDOxgOKgvadyF9KO9TJrr+RLsZf3afrb+H65//UT6AUjOsV//F//nf9hj0Od7nkjT/5+3j6f/kPf8Mew7nOda5fW712IyqTgkINM9AGQOr4Yd1y3RVyA8nlNFVCKXKImOUSv1yJEUJVVJbkGk4NqLhWa4ySWhMjOQa5+TTdqUImMdrZU254SpI53oZM1Jy4v73l5eefEKYdRldikhugUTCFTAgZaxXrhcN5y/6Q2G8CpRS8Nzy87ug6+bl2Ny+5uxl596MfoXcLTEPRHFeo8+FAmCdAY6wgYpTVsloFaZBzIccipg7vcUuH7zrRcuaMohkyqDJZTQmOoQG1cmSvCmqnJf/kSFUF5S1df4FbLoXFqs3pRipIpEJt06wcZqa7O+J+R0Xz8NED/vjP/BgfvXvNz3/jBf/p154RtxBKYs4ZQ6UqUMqw6i1P3ljzwQcPeP9Hr1k/XOD7jqo0IQQUko1eGwRdWyObaFVesUStrIyNlZ+hFCFb6Ra7eDTeFMB4h+t7/NDiOZs29RgLKk1okKbJGky/kFV3M4mBNEAY01bL0liF7Z7x7gUlTs1EJhP64zSQKhpbrTXdw8csH7+J9R3aeml84nRKczoaakrJzHcvSNutPExjXnExBXqJdpZaM3UayWGWqFOtW0ylNFe6vWeUsygjje3+5S0pFaxVba2tWtSruMlTiJJORMVoi7NiNjKdJG8p62XCOUsKUi3CvnXLFcZ60ckqmciXfJSXZERToomjNMCu8xKakDLaOPl5SiJHmc6Pmx01JbTT7bDXzHe1maPap4axBj10rN9+l8XVtYQ9HL37bapMStQ0U1GkaWK6vZEGFk7Xdq1VZC5ZKB5oxTzPzPsZpQzam2aIFAbrfHdHHEe6y2tcvyKNW5hHjKrCp7VWXqsUpalVYoxM80wM0/f0ofpbuf7Gn/ldXC09v/erD5mN4d98+4Nf98fwC//q/4kSXrFd0/58UDjXuX4z1+tzRK1uedAtNk8pwZt8N2CaNi3V4tAtrUnoLi9xi7VE7FElZaUIq1C1tXFNkbQ/kOYDxxjQGhPKGqzzoqvM0oRiDLkW8jw1nqFMsHb3t7z47BPm/RZJEVKE0NaLFeYgqTGXFx5tNTFW7l6O1FLovGF54ek6S0qV3b6wPczs9oGY75mL5kc/ep9+MaCdJ+fMvN0RJzGNGKvRNG6pUhIvOs4tX1sMQK7v2xpbWIv1qO2kJdFkiTY0fS8u8WYA094JhioKXkgfm1LX0y0vsEfG4/GGb8xpcifaPpi3O+bNHeUEjDfUAg8u11ireffNS/5z/8g7PH+647APxLbm7Zxl2XseP1zz8PEl/WCxXgIAUi7M4x60oh9kyqms/J62FtUbcZQnqE7g68ZoFLppQqVBU96ilKLMskq3vadbLeXnosk0js1CKZQ0c4yGVd6hul4Sl1IUyLyCtg8WjXG7lubNLfP9LSnMskbOSaJEtUz6SsrkmLDLBcsnb9KtL07X7Gllb/zpuVbeUGJk3sgU1HhJ50khUKuSpq0lIFWQkIUwNxyQFqSBPsbjZsmN1xJoEA8T83ZLmQWNhPVobYlzJMdKLfJYtRF+qO8czndY704MXetceyxILjwRlMIt1oLJilFeD2elWY1BJA65iB56mqgx0g0DqhnXtDZUXck5UWMkxcQ4zuR5xrY42qrkGqCKHpVaqUVRlMIsei7ffZ/h8gpFAWcbv/TYjBZqDqAtcQxMtzfyfgJp7o+68VopWUgbyhjmUZ4n30mqz3H1X6v8L1qTxokUn7O8foQKk8hfjAXvTsauqpRMnsnE3YGcZnQjNvx2rr/yx3+M3/P+A957uMS291RWik+G5Q/8e3/xt/8/3Py/f+707+NnL7/rcHOuc53rN3u9Pr6p74jjLFzQiqzmWlLS6WaqgK5vEy+Nv7igW69lelPbVKrlOKPEYVtroYSJuN+fUpVKaqtHralGkneObM1cII6jOHadIafE/uaWl198wX5zg9Gi60upopVo9+Y2jVz0lq4zHObMYTNjdWXwmsXQS977VLjfTsyhUHIh5kypipQrT7/4kpW3PHzyBKUVcRRDlDGmxU0WcpDJZa4CQ6ooShVhvdNK4iStlRjQGKURQ6ZnKUVK1Y3FaU/RkMYfXb6CzKq5kp3DLZf45VKiF5USp9UxcUpJnCnKkNLM+PIFadydzBy1ua2VEVj+WlsolatV4cnlI5wTE5Y2zWQjAeNNoypRjGMzzlhjsNaK/jVFXPHM84jpHN31hUwwUzmZu0qLWjVHwH2tAqduGle3HPDrFa7rZbKopHGlVolcVXKwUNajvG0yiXpK2RKUj+hVBfWlKfPEePOUsN1QUia1WFqyNDPaFFIq5JjxF2vWb78rueZhbvrmDvpB2KilmWK0IU2BcPMcyChtJe7zyI3N6aQiIWfyLKijVwe39l7ILU2rIYqoRdK5trtm8AFQqKoI+0CY5HCjmhnJOEvXDbJpcFag8l2H9YY0zycYfm6r665fNspExvTStJVSKOPhNF0sHFfW4H07ENWCsVamplH0tLkWwjyjKPjOk1Ok5Cp8XKOIU8NjKUXOlW655Oq99xkuL056TdXib+XkKQ523T9g9+wZ8+cfo50RCgO0Q1WV6Nx2kMkawjiKabEB+uWQUTBo7PCKVawQr6QKe3lOtW9SCAOqrfqrhpqI80SOoxwAv8ui99up/sCPPOKf/1Oi/1z1Fv9dsPqE4n/2lR/7vn/PPM78//47/8tf9GtlCr9oAnquc53rt1a9vlkpihv4OPWQhsbIdDNFwe8oheo6zPqKYX0h2sfcYiaPjUeuDTQuTWjc7UjTQW74ta1T9SvdnXaSoKKsYz4cKONeGKPGMO/33Hz+KbdffEotYhzZHwrOgrOaECT5ZfAaaw0xwfOXEwroe83FSvLIb7eBwySTJm8VXiuqhdXgiblyu0s8WFlKvOXF5wmrB3zvcb7B5TUnOYIA+RXViLnH2BZ/qjRuscBYS5xDmwDJRCfXih06+m6Q6U9JgpWx7hVqJrfkmGHAry+xXX8y9VAr1XqJN1QKtOTRh909081LakkyYS0ZppZ9rhQKSymyyu6MuPZ932G8MChVrlAitWqqtg06Xhg3e0pO9Mse6y0pyYTbuQ439G2KaykhEvczWhusd+Kqtk6ax9K0sDFQ5ogdevrrK/xqLZPPkxlFSwNas8j2WuOtnJeGqjFASTLtw7WJYIqQEuGwZ3/zjDhOlJBE+5mPsbCtaVHi0h+ePGH91js4o5v2VoHvoFvJc1tyyzmvhO2G+cUzoPWPyjaqRG4oLd3c5EXoDU3XWZsZTyuN8eY00UOLs33e75m3O3msOaOMYlitGDcH5nEWI5yqeNfRDR2L9Uo2E9aCtbhBpC85J5l6G4G0K6VxLdYUKtoPoi7IhTzN1MLpoJC2IyUmutUKlWVCWasY15QCtGUeR+bDAVULzjpUFbBXKYWcMrpocpJthVIVt17z8KtfZbi+lte30QWOk22UQtkOrOPw/Dnz5985GfROwPzTe8midKWgSPsMsREsetf0oqCR61qlJuWYZ6z39MPQps60zxlBjYkBUA45OQZKSZhhIMcI4bcPR1QBb1wN/Cv/3M+gtcKZX5oYUBXs7a8yceofmGb+7P/g32B8evvqt+Nvn+f7XOc61/diVgpZ3O1H/0Wludxl0lC9xa0vGK4eYpdLYfSlYxPaDDPNXFNVJW63hN2umZ6M5E9rMT7pZrCRNbwljDPx9h7T3ONxnrl79oybLz8jz4JSylmMzKulYZoLY6j0TskKPlXudzIFW/eGfuFItfL85SimpVLwVmOswmiwTnK4Yy6MU+DRpefhw55aFbv9FmsUw7JjWApkP4dIaVxIMU/Jil0bQw4JtxjoL9ZNLyuPo+QiXENr6deXoj1taCelgU4ShSjiXlZ9h1tc4/vFaaFfyzGNRwwewj0U48v+i+9Q5lHWvUp4kGU8tDV/T6lQcyUl0eP6YUAvV40fqchZ9I/KeFklW0scJ+I4Yq1GL5YYJytT4z1Wiz40zjP+YkVFEQ4j1jnRy37XurbGKBzLIhNMf7FiePgAO6zk0KHEjKYax7KUWSaryomesq3oyZVcSot7FVOODNfkudnf3nK4fUEphRoyNWb5WZQ4wQvtcWnH6p23WTx4LI7sWqQBXixBO+q0QzlJGCo5s3/6OfH5U7T36L6n2q5NWJurXF5gQR21BllpTWnpYEo1V3+uaC9r8RgCYRyZ77dyIAOMtZjOMW62xFn4tNoYnLcM6yWL1QrnHQUlOllrhCtbRXstcbGpPf8tHtP5ZszR1Hki7yXR6oiOSvMINeP6Tt6rDd+Uo3Bdq9YyLQwz1rTDTEjQCBYqi6641AK6oJVhuLrk4Vc/oL+4OH0OcER1HeNgayXNM+PnnzI9e4rtZVqJMihbpGmtlWMkaakwbfbkOUmUcK2SkKUVNcvrq4wkmtU54bqO7vJSJqZWNgCgyCGIOUqL5jaHqUk3FOkQ5M//Q5qx3yrlrW7UK8X/7m/8MYBflhRQgX/xo9c0KNWK+wcaz5/e3PCnn3/x6hf+0k/xz/xP/w7bKX6Pj/xc5zrXb4V67Ua0liJpJA24KagZAXmb5ZLh4WP8YiVi/9ASXxqzj8qJ3RgPB6bbl9Q5gnUyKWuxgPnYLFiHdgMpR6YXL9Aly7QmJXZ3t7z4/HO2N8+w5hUE3fWaw5SIIWM1rAZLLLDZipli0Rs6b0ipcHMfiCHjrGK5sDinyQXGOROypAblXImx8PC6Y7l0jFNmHDPawDDMpBxIuRMXr9aSOKrl6XReE+ZEmAL9oqdbLaQZyqU5vKUBc32HW63EkDQ1wb1tzvAYZdJnDGaxpL9+gLFO1qft76MUqrapkjFUrQm7PfOLZ9QYsIsBaIapGFHGYrz8Wo6R+bCnhhnfd2C7k06v5HrKI69apnzz9p6cC91iQBlDKoUQIpSKsQrV2wYU14CmhIDv+6axlCax5iy6X9N+zVi6Bxd06wuJ6DT6lXuaKqYVpU4QetV1qCOrM4nJSLXnTGmNStKwllzYfvE50/ZeNH+xUGaJ8TRW1rSlgHIyWb386EOG9VrSqhqJCd/J94lHI0SVa+TZZ6T7G/zVJWZYnpq945qdGCgxSOhDPpIOjrGf6oRzEgi/GKnSPDPvRuJ+bM2WNJXGWWIIpJAwXvLde+NZXV/iW1Sm8g5rtUg25kl0l+29gtYyOc+VWkqD4mtUTmJwSs3U5Sy5ZOJuR81Z1vwY0jihVEFph/YduWRUitQcmgNedMbKymOWhDBxLZYqU+f++gGPPvwq/eVaXst8jPyVA1GtFYxoaMeXL5lePhfHv9EiZbASgFFLQ7thqCo3mVAU0ps6fkZJEyxxogbbdyhrscbSX6xF5lKKcIqNpcQJ0ozuJMkqTXvm7UbW+M1wp709/Sy/1eq4bv+bf+n389b14rX/3s788reNISdsaz5VrfyNb/88//C2FlCK65U/N6LnOtdv0/oeXPNGbqY5UYqsF+1igbt+ILpGpcWdXauslI9Ip1okPnE6EPc75vuN5HR3slo9Ni/H6Ea3XoLtZPp22KOBohT7uxv2L1+wuX1BmMW5H8ULhdKw28uH2GppKQUOk2g8vdd478ipsNlFciooKuuFZX3hcZ2s+2qBaSocxsQ8CxJmvXJ03nA4JOaQ6XuLNoppGslJUVGsVkuM9+QK3kmEZlHQaUO/lLx4pZrRC0lGUkbRrRZi6IqpueJV09oWSggyUe17ussrSYbRmqqEXHByZNeCILU0KWfi/a2wTitgnaTiKI12HXhPrYKRSoeRFGaZoloHykGWVKlSSnstK0VrUo7MhwPOG/xiCQpSCIi6Vcuq2EqKjjOd3HBCwWqLKqpNZJWkHVGpWlFbnnl3dYlfrMTtfoxzlH1704NCbZNQZbSsxovoZCWSS/ibykiaUdGWsNuze/o5cb8FJBigZplSKqUoSRzRyggNwF9c4NfXogW0uTE2tQQuIH+25sy825APAj33l9fNEMar2E7VXruUxKSWM9pK+MBxHd8cMbh2+IrjgXl3YD6IxlGkCGCcRjtNbpD74ULSvAyKYbVmuFwBkvSlOieykDzLz+Q6ceejMNqKZ4+K9vKeVFTyPJOnSZriZmia7rfUmvFdT02VksVUpawjxSTYIyCEKM9/bbrdRj04vh4gzGFtDcvHD3n41Y/wy+WrSSg06oAg2qhicBxvb5hefCmBDUr4vHJNRnnsLbkp5UTaR0kYK7VpsOXLllqps8gQVHPjW2vor64wXd/eM+37xxnCJHxj25NmoV8Uajs7y2uWQyQfDt/zB+sPc10Mjkfrnr/8j/0Iv/+jR9/z3/9XPvgxOVQAthQeNZLKsf7M8895b/renrN/9a/8Yf7cv/TvkcvZhHSuc/12q9duRAVwLasxPSxxl5f49brp/aTJUkcx+wkynkjTSNptSYdDSzoS17fo5ZQ0hk5L+ozzpJRIdzdNF1gZDwc2ty/Y3r6gxFGa4IbEUUAqoCn0vUxVp7mQU8E7xbJzxFzZbgMKWC0sfd/hnLiknZfpWwqZcYpMYyKFhLWKoRdt5uEgaJy+d+RcmOeM95ZaJuZxj7GWpe/oFgNaK2qJ4p73XvStFXLOTZcJ3XKQOFCq8Febg7oqTu5hjMOvl3SrVYOXC1+UlNpESbShVUmjlfYjcbeBeWqwd3nusbaB0pHnPgbSOEmMpdanDG+ay/8os8gtValUyCXR9b2scpE4SaU0xnmwFdvJz6IqqFJbD1mwDUFUKzLZ1QptLUYbrHP4y7Ugl2j4rgbEl2ln/i48WAOKpyA/kxEw+9GQpLRksodx5PDsKWFzJ1pS62QieWxaS20kAZoe0eD7JaZWNt/5JsOTt+mXC5R2TWsr3M+SIimM5GlsSCrBHMm0tmkNAVIihiB6y1ox3jcaVW0TvXJ6/whzNbB5+pIwzYDGeY917bVTijBHdBVHvLYK23e4bsAvhhOZAKUoUZLEtEFYWBwn2q41Ywj+ypiGX5JsdoyjqkIaR+J+T04R27BTOTdmqJYmtOZKKpl0pFSgTqjNmiuYdt22KbcfHIvHj7n+ynuS7KX1qQmuqFNgRc2y8j88f0ba3dEtFyJhSIk6xdYzHifzmlIC42akZuSAg1xrSmmaaqNtYTTHaNNuuTwFABw1uiVM1DijXYeynhIjcdyLttlI8IPuHGR5b5X4m39S54zmpz54AMDv+/AR/8Tvfe9X9XW+NSz58LAjt0b0Mkb+ieeff18e4+/78BF/9xeef1++1rnOda7fPPX6jWipmH7AX1zi1xey5sq5NQfuFQeyTU3TNBO3G9JuRwkSC4qWiaLS7UamFbrrJes5JuJmIwgZIM4z29sXbG6eM+73wnukeYOsPundnZVGJaVKTpJrbZz8/jhljFasFuKWd1bSeKTvaRGSuTJNmc1O+IH9IOlKuVRSBYzCKdVSa8C3uMVCYZr3GNezWEvDkVsSj7ZizCq5CC/StJx63yD+VaGMNCeqWaslYBNMP2CHBa5v+d1Ny8bR6X2arhnyPBP3G/I4tmGUxFIqpdsETDSqcZ5I0wQpohW4I8ezobSOmkSUJuUkuksEQ6WNQXknk+1cOG4p0xxkIqdFr+mcRds2natJpBxirRb3v/HYrsP1vax+rRdW40nCAaolIckGVoDpKsemm9XtcJNlBN5ScPI8E7b37J8/I+13uN7LpDImlEBQaViDptvVaN/hl4NEm8ZImSe24zeob71Nf3XdEEWS5pOmPUpXjHPkmFvevejpcmrM3FIoKVKaKch4cb8fJSelGf20aszRaZSJf0xoZ3DWSWPZ6BMpJIlz7Zv2VGvBWXW9hDgoMTaVeaakJHGYiCbZuA6l2/PVyBPKCEbr+N7SzpJLIc+BuN3KFJwmv6kFa60wVqOYrEqK5BgbEF8mu7pNtnMuqFRPOli/7Fi9+RbrN94Qw1aLFT3GsTZHE2hDoTLd3ZE2t/j1Uq7ZI+QfuZ6VlQY6Hkam3dTCnDTtEkVrLXxaf+TrAlS69YL+Yo12XoxONN5ojlCTXHPWksNMnA+kOEv4QmPaVuTwVlVtHNvfvPVf+Kl3WfaW/8of/dFf89f61mLFX/jyk/+M7vP7Uf/Cn/89/Ll/6d/7vn/dc53rXD/c9dqN6OLJE9xyjen7tso+Arltm1KpNnHbE3d7wnZLTbEhbGSNfZxsoEB7j/KOVCp1u6XOMyUXpmlk3N0z7u44bDYcxkkiJrVCI3GBCrBGSepLamtXaNpLuUl6q+m8xhhNypVxzBzI9N6wWFgwEEPhcIjs9xL72fWWZsSmVNUmOJVaNdZoiTnV8vPEVKBExmmD34i+0nqD9Z2YRxpEXWuN7Ya2oobaGgNSkLWuETSTdh7b9biua03JsdluekJaio1S5BhIk0zpapvW1GaWEYi3gMRLTMyjpPKoiugOtaGgWlOBxGFqRa1ZkmZyPYHFq1EoIylJOYimsCIaS+2sYLqq6D91m3od9Y+1gfhRghPyyyV+tRC3e21a0tPfKSf0Uq3yHGkqKs3NLd/4PkYICmJ+U4T9jvH5c5kGU3CLpjmssoaXa0WmzTlJg+4WC9wwiKM9CxBdKYVOicPnn1BSor96QJ4OlOkALT5TXisjYQpav8qrT1GYmuUYudqMHu0+XXOWv6ulCR33B+I8o1H4rpPvbbRoRZOkldmhw1iL7Ts0kt/uhqGZd2TimcZR3l8taMIai+2EymC7TuJmiyQxkVu2vJImrpZCmUbSOMpzUME4J2txbchR5DelZHIKsp3Ioqstx8NTba9JlTQuYyzdxZrVkycsHz+Wx9WQTLUck5CEKIH1pBQJ9y/J+3vcckAZJY8zZQjt8KE0eZqJc2Daz9SqcM1Ml7I8weYY8WuOelXoVwu69Uqm2y1Uox4jhHNsFA5PmkY5yKUoWuzOgHMysU5JtkBK8Gu/Geu/+Ic+YOgsf/EPfvDLmo++l/rjL59+X77OL1VKwT/9hz/kf/v/+uYP7Huc61zn+uGr125E++uHzXQhEzp9XOs2FmTY75hfviTuD5I+U1tuulKv1srGiBu2HygpEfd7WVciXM7t5obd/Q3ztJMJTGlMRpAbt5d1XEwVmpbr2IBqBNnknESMxlRl1d5iPZ3RMhV1GmMU85y524SWZW4otbabmzRjpk2UcqlgxIWr26pYvn9z75aZ3fYlKMXiYoVxkvhinMP4TnBFVh6TTCwrpFkarwbQdsMC36D0pxtGOa50W4SncWIo2e+I23tB02iZWpZaThzXUgrKqDYJHSlt5aqbK1jg+rLWt52Tr5syaYqtyaAly4gbvqTCdL+FnLG9B7T8bNbJOr79Uwqo9jiMM+1rKGn81mtpqo7aYSWO6aoaFaA1FWjdjExZkrfQDddE0x1buR5qYXz+nMOL55QwCyasVkGMVQVGrk+jKzkloYVp24DvjZ2ZssgMTsk/onONtzdoVVDSdVGijICN707Xc8mSUlRyBArGWDKCQVKqMXY5SShRWos5bJqJUTSoWitJISqQYpbwBwW+6zDeYl2HcbIeNr1Hd77B3puGeA5Nn2mwncN3g0yYKWglsbqmZMJ+R5pnjFbUosg5UeaZNE6CJkLheplWC10hyUS5ys+nFBSlSSlRa+M1VIhRJDZaK7RRDNcXXL77Nt1C9Ks06H+NufGtmkTCWObdjjhuKNNBXOnQsuLbVDbJNLuWwjxOhFnoEMbIdVMa+cBYK+9JDCWBcQa37OiGZTO8lXZAMCKNObrjtcD6w27bpp5glwPK2zYhb1zbIxM2/eZhWP7J3/02v/srsoL/mR97Qud+8zTRWin+qT/8VZa95V//97/2G/1wznWuc/061eubldBQNVUj69Ha1pPTgfn+lvnunjjOMuE5opdKS1AqBdU53LAg50w6jKiYTtzL/f1LNi+ecthvmKYAVIxRhCSN4DAYnDXEJKB5o49Rh8Ip7L182IZU2GwjORdCqoRUiLlwMTi6hWa9slinJdJzF6lUnDMylYWGVaotmlCaMW80WYkitdQjKB+5sVdpUCMju90dVSmstQyrFbbrZV3JceVZW9xmlVQlrTFDLzpQa19N0ZRA/GvOECaZgtmOMB5E/xjnFmEpc+DajEvaWWn4C4RxT55jw2ra1oQiDVRb4SonzuSUEmGeqblg7CtDDRVJ99kfQCtWl2uUs5SsMA1039oSQeWoStWgjEJViVj0iwV+fSFTUImDanniSjrXlNvkVInpSCvI4eQwbyM81MnEBCUG9i+esX/6DErGDp1oOY94IydkB9XMMTlVkQV4L5PMtn7OmXYIkrjZXJLA9Jc9xEAeJ4nadB7T9adJ4lFrW2KAFMUtnjJ5btpQJ+lKukXBplHQTPNhFMaokol1rhVdpFEeDxPWWrpFL1G27fquKWOMfRWnGQJlTs1prtFa44cB68Xgg9ZUY9DWyWEjicmoxsjcUGolJfI0CqNUG/n7XYsBLYVSBYmVc5ImUyniJBgjVQVLVqsceEQLrlg/esjV22/hlmt5DbWQEwBwojs9Eg7G+xvml8/RWqG8k8NYrScaB0i/WLVi3s8IutXKSh7ZxNQWjlGzIiuN1hXbW/rLC6xva/RaqEqei0qF2LTYJZGmHWk+UKsY0ux6je6ENJDHGVUkZQtVUUcj1g95/d6vPuQv/qEPeOfBkger7jf64fyqyxrNH/yRx+dG9Fzn+m1Ur88RVUDNELOwHVVlvj0w3d7KjQqFbVF6R9OL8o5aC7pbiTt3mojbg0wxjGG/27F58Zms4qdIzhlrNKUopjHROc2yYZjGMeGdwntLTJIRbq3kle/GRAgFYxTWaDpncbmi2te4WjtWK8lhv9sEUso4pylZEmesVsxB4hit06f1dMkCuJclPWgrDZrTbdWHNB7GGGLcMh0MD548xtjGbJQxIbUeG1sla8F+oFstcX3Xts5ttKvFKFFzlBSfriOnTLx5Sbq/A6uEeVjFrHPSpBqL7jxxmgj3d7LFbs2A0scGVaZR2hx1eorp8P9n789+bVvX9T7o95WttV6MMWax5lprl6eI7WPHhVBi7MgYKxGRgoRlMPgGBYiEUC6CQUJEQojiD0ghLgJcIBAXBkG4QYQLRHAsbCQHGZsIO7jKqc+u1ppzjqIXrbWv5OJ9e5/bwXHW3vvsvfbZZ3w6R2fveeYco/VijP62532e33PWEI0wK401gusxhtPTmZKzpI63G/GGVoP3QVLvwelKWW82DJjWMMbhp4Fhv8MNmw9D5GUAvQwRudJzoocBt5mwTasdr0QAHSZ1Ldox5NMTx8++Sz6dRRGLHoP4Pv1WVPZaNXCVq3SyhwFnvYDWa8UYKGow9MGJtcEbhmlLvLkRJu2yqH95EgsJ0Gqm5yKKWVow9QNfsykeyYYg1hMnyKtyXknnMzkJrUEeWpeypuDJy8yaVlrrhGFD3Ixy02AEwu6cw28k7V2W9Yo+6lW+V9xOMrga4e8aKwpy652eVtqyKF7L0ZT9mZZFgjzDSJg2WG9lRd8lGCQ3JgtBKP2Ui/VDmA86kEtYyDrD7pOPufv0E8K4+b71b5cduUXQZL3T0irBxad7QVz1jr0ojeaD0tprFR/tquQIDaMZ7yQMZwVjZZrapYO83zZ3t6LqajsVvYntJARtHeu0dSUvZ3JewFhqrYSbrfi1tc7UGIONehNdK21J+Gn6QX+v/sTOJ3cT/+M/959gGz0vfgcPoN9/ProZ+Zf/9B/iX/m3/uaXfSnP5/k8n5/A+eIc0ZzpJdFqpa1JfqGfTtSUJQ0dRzQpgLGiCrkY6TGSTmfq40HWj0DKidPjWx7vP+N4XKi1EYLFO0daC97CdnKUZjjNlWlwuGjJuVFSZhikS/28iJdtHD27TcRZgbnPa6HRidGy3wW2m0DOnWVdpALRWnKBQRE5rakyWnQNay25CD6o9IYzToMk4Ix6KJ3FGWlCb1laWZblicPjA8F7TU0bVXzkU7PZQLy5Zbq5kYHy+z+4LzYHrU8kbmSF+fgW1kVT9ZfwjRcMlLf6fSzpdKIcj5jeJaChqaJeigyD1omP0xhKKeR11RCZ12EGaOJ1zMuKQM0j02Yr3khVM63zGG/A2avdACuDro2BYb+XgU4biPTR6Qyq00NttJIww6TJeWnn4qKMKXcUJ4Nmb43zw3sOn32HuiblJUjNpw1eVtal0jTkU3KlFcO43WGtpeSk1ypf34VwZdq6IRBvd4TtDnKmzDN22ogXWmHmPSdaXqkVWlolgNX0QTmPtaqo6/NbUyYvibTMsr6+YJnUNmmCJeeFvKy0DpvtRBg1sNSFO+pcwAUPvVLnFazBDCN1WcF04jTivRAVrgwzI2pwSzNtXeilUJvimkqilII1jmGzwe93tJQpyyzidK5AoeQVp691XZMWL2jaXTVwY2QQvfn0E+6+/nVtkdIQXRi0hCFDg14zNS2k85l6PtFrwcUgJIWmbWQg71EkBb+eFkoRf6uo7I5WGk5tPq01HYQtLjim2xvCOEom3xqxBRkJf9XlhEGG02YauYmvNs8LfrsRGtq6UteMHQI2Onop4o+tXXmtvz3+yt/O8xf+/J/SHJ5hN/7ODlP9h493lo9uxi/7Mp7P83k+P6HzxRVR7+k5iUfxfCangjOWsNnKqjOvyk0U9auHQG6N8vCogRpJU8+HBx7ffZfT6cQ8F7wzbDeB01ygF/YbL0PmWnHOsJkc57nKin0boMOSZaC5vYlstwGnYPCUxPe5poq1hld3IzF6lqUI19EaStEPMdM5nzJhEPWylMJmE6HDuhasRepMdSVvmgaXrLQvScq403SFX6uAzd9+79dw3nP78oX4KK2nlYobBqbXr4UJqgO5rLdlsO1JLAnGRWo3pPfvKKcnTEkflETj6T5ALcJFtAL9LucjrYgvFWR4IkvQwjgvnE4rKnRJSSsfJTDmYhSSgXfUVVRuYyyb2zuM81jAj1H8lFbQSVgjQ07SWkRrGW52TDe3uGmSa6iXXaqGl1Tla1Wg53baqgdSGYSX2sXGhyAT8pye3n7G8d1b6knYlgSHC0EZl01ukErBxyiwcuPZ3O1FvatFTQyyehbfpvznuNsQdhtsjNTTSVbh44iPUpPZmw7NtVKWRF8XrPOUKql066VSsq5JVril0qq8L9J5FrpDlVW6847aGt7CejrSrcFEx2ac5KbNR6xxSnWwOA+YQl0kVObiJDgqDOPLlwSvIa8LJN5aMFWH5iRopNYoq4R9OuJdtcHjNhvhpdouCfGSMTRKzqLI9k5eFi6Dp0UsMr3LVsAFx/6TT7j59FNhfl4UcXtREqUqU6woC+t5ppyPMsr6SE/p6p/tvYH3opwaBJrvHBbx1Xo/yBrfXywB4L1wZ30MTK9eErdbTAzqK0YQp8bQ0yrYrpZoVGHeOislDtuNKL7nVVqjjBVfcBJFvNYmlgzj+WkYQy9++P/5f+NP8OZmxFnzUzkg/3adX/rqLf/dP/0H+Vf/rb/1ZV/K83k+z+fHfL7wIJoP96SnA+k867rPC4qoFqhN1vIGTPASZjgvWgEqLMbz4ZHH959xOjySU8EYw2bjNbme2G6kAWVem7QXDZ7zUijV4L1hv4ksqwxwt/vAMHrxsFlR5Ert3D9mznNmO3nu7kZy7jweVjQPQe8QvON8zsRg2Wwj85LxwXCzHymlUdQbFi9gbQTLJBQdw1VYUzQOQGmdMESclbXz/We/ga2V/evXOOeIt3eM+xvxYJakyEVZ01/4oiYEunHk84n89CitMuigYZwMlJfBYAh0IJ9PtHkGjGB7FPfUNH1tQhQ1zllK65TzWZQoY64DhIsWv91IeKcUxputeOucBIMoBXIVtE6XZHit5QM71nnizZ7pxa0OMYjH82I10HC1+G8rDYffbDE0afihq5InyCeroHgJwB04v3tLmRe5BiteUuudKpUFY7qsVk2k1Ma43QtKrDZarzL49q7PoaWsCdOlUCDstoChn84YH3D7rVg4e6UVveZWyMsMacVg5cZjiOLJbA2QtbEMPApczwlrnUDXr7NCZxgCeRGEkvdBBl5vidMGZ3W4tvYyg19RVsZbynzG+ch0e6voMfHjAnQj/FUBxHd6reQkxIGSEjUtWGskADUMlEXeM5hOTll9uIboBumazxnrrZYvWGwzci/khIBw++mn7N68ASS4ZYx2tvcKRcJJvUkAK62ZejxII5NxtK7X2IGmAcAsNbuiXMtzY2yT1jD0Z8VYuYnU58cNkfHFLXG3k5CbNbKRV/uCsV6IHr1QWqa2LMp5BzeOgtJaK2Vd6bXjtgG05rRZhw8Dpouie/W7/oSPs4ZRw0b/nf/cH+SP/uLrn+nh8/uPMYboHdFbUvnZbLZ6Ps/n+cj5woPocv+e9ZwwtQpiyEBvBReUM+mlJrBegy/iNzs9PHF8fMfxcM88C6JpGCRAk5Ks4adJ/JulNpwX1bL2xmZS3mHprEl8nc5bznNlXRrbXSAOjrw0Dk+JlAq3+8hmE0VFzfXCzsZZQ86NNRemjVf2aGW7kXBIWjO5SRAqDlETvLLqDUG+SKPTqtEkNFT9oHTOYml4Yyjd0Hvi6ektfr/j5avXDPu9YnYAjHgkQZqCQGseE+l8pK+zhrigownzIUBpGCt20rys5PMZ2wrOSxDowo1sRtP5WKwRb+t6PJPmWepYndgmam74EHEhSouQ4ap6ShWiJsrDAHTB6lhLS0W9lh0/DAy3e+L+BnudONXbeRn+L3/eG8ZHog+yhqdfCEca+lGwvXog1/OR5emRvGiVowEG4dU6HVZbFR8hGEzrDPu9rOqz9LyDEf+rFRxWLQkXPcPtTpT8nOllxYSAGydJixvxDUtXfKKuszwUG66hGmOseh/V66qhq7wmmqqlJSXteDcUDeVZ72SAiv66yvZhIAyjhGysESW2VB2oxO5Y5oIfIsNmKy1SXekAF29lWnTYFuW8NbHPtF6FmqD0hg5XpbMr4aB1I5QArW3sJV99nX6MosK2Jl7o7Yabj7/CdPfiygI1wpMC44SCYC92jcBynEnv32FbVddFFXaudboJ6OQiafl6scWoqm87opSiNzBNfoaNBb+JjLd7ws1ea5W6hNVKoZUVO2y0/alR1oWUztdGL4MM03VJ5HmWgdR1XAzgxQIgQ6j4Wu0YrxaTn9Rx1vDRzcg/+Quv+Rf/2V/6iX7vn6bzT/3eN/zzf/IX+V/9pb//ZV/K83k+z+fHeL7wIFpOwqIUHmaXjushigDWDbVkVeeg98r8dOB4/56H+7csywK9E7ylWUvKHWsLcRAwdW7guiTia+t4J8DudRV1Y4ySmD+eqzbAGO7uBkJ0LEvjeBSV6e5WKiYPh1WUHANgcNawJglaRKe4J+e+r/lHEsDeCFbHXxCIui6+YKSuLVJdP9CcudZHAtQujU2md1o9ks4P9Pox5IQhgAsImLICspJsrZMOT6TDA9boMHH5il3UXiOBXzqdfJ7Jx6Ngk0L40Bak1ykDisN6S1pX8pplkFAAfKtV2KZbheuDAsMX6prx03QFpOv/yOq1d+q8KpvSMN3eMN7e4YfIFYvj5YbC6Pr9ko7vvWOHSVQrXVXTJWQkA9lF2YOaC+n8RMsrbU3UdRH8lAtUI2UBBkNLqypgwrAM0yjIn9zFs1sbV9blBYPlDOPdDX7a0JO0VLlxIwOwDs+9iaLY80ItmY6obTRRwbFguwxnvShOCShpFZ9qbWC7BKFapyT5szBEsA4fjAzyweND4Fo3qp3pLWVNtOu1AOPNjjjJKvkSosHJENhqFaVaPbt5WaT1SUH03gepoM2FWooMjk6QaDUlqRPtRl7XLu1PrQi1oFRtNwoON47cfPJVNi9fC7XhUjlr1N/c1R6g74P1/j316b20NXkneNks1bmmNWHB9qIpeBmqrZYWdKUJXNfPl+Q8HTcExhd3xN1e2KFXX3GXm4rLloFOzSvL8YnurLYoyc83uulAvc/WW3lOSsOql7qt6zX93+tPDt/0S1+95dVu5L/3n//DP7Hv+dN8Xu4GXmwj96f0ZV/K83k+z+fHdL44vskaPAYbHDYGTAw0kOHxPF/9jmlZWA4PPD6843w6klKB3nHGQgVrOjHIh36pMpyW0sm1irLorKZlO9MooaKnp8R5LSy5c7f17PeRYfCcT4V5EcyMc7K66/0DfgkUTl/aVU3BGByOS4ymIz5P54yEUboEJoTJKUOg5Gfkg9ogXeCgbUuqRHlj6a1SSsUHi22Ww/1nxM2OV1/7eaJ1GCPIHGmhsuRlZX14Tz0fBQ6vlYwXZaubhumXvvRKnc+0lGRtLqY8xMPaFOmkrTu2k3MinRfZkHttKXKiktKgp0rrhpazpJCtJe52OC9tR8Y52iohn4sgZJ0klON2Q7y5lZrP1mTtrQGpXpIMgZcSAw2uGbr0sXYJlEjTlrt6SFvvlHUhn59oSbrQa8n4ScoCai1gAyCBtZIrzkXCOOKckAFaLpjglGH+4T1QW8WNkWG7kVaseZHrGjdcObcaeKpZ8VFdBvZW1VdqVMGtnW6b0gDE3lDPZ2oqMsBZS4z+OljV0/mKRUJtEWGcZL0O4ERLriVLA9Ml4NUlAT9sJ8K0UY9wv2KXLsxQ6HxoZFroCGKq5IQbpRxBWp9WFP1AUVyVNx1TqnYvNHn/Zm22QjBfOGg4dl/9Oaa7W9kSXN6jXFRYUC8G3VrS4wPl6b0M7BdubM4a2HLCvm2VUiUMZX3EGbE9XKq7Wpc6WbkJkTYzNw5MH70mbLbX72t0oGxpphltUGpGLAZlxe02gBHVe9jQ8kzPSX5nREfLDatNbM44jO2Qs9g/Wqev6/dtM34855/4+VdMg/iv/+U//Yd+16zfv8j5U3/gU/7et5/4P/313/iyL+X5PJ/n82M6X3gQdTGKR2+IsqJuVTmM4p1cz2cOj+85PTwwn55IWXygzhpq/4BJMs5KjkW5grV2qZIMTgI01mC9VHbO58J5FhUleMs0OW73AR8c5zmTs1R6dpC1vpVZRxCUMiga9ZE6a5Wb2VStu2w2ZTAS26bRdWWnV64tSmrpvIbcDaKqNh3grBVlptWuK3IrzUtl4d23f4M4brh986moQy5QcyI9vqccn6AVVWedBF4w6i2UAcOGARMC87u3ApWPUTvO+1Uxu6bXDbRaKNoM471XxVT8ixhB79Qm2CfBSYkaaI3VNb+wFlsWLqYobTJUhf1A3O7w43QdIo1zHwbKUiQNby2YIL5WYzH9wn7U50/5oBevYKuNdHwinR6FlVlECccYUYONoRtBUZWUoBviZi9r3H5ZZTcZIL1UeNKTKHAGhu2WMI1qN+hYDXp1HcoBgcTnRG/5AusSiwT63GJUGa1YZFivdPK6kpYEvQlKKHpa6cTNIF/fWmGkalDIu3BVMq2q36WuymI11xsGPw6EaVLvL1dVzgVB9PRW6VhqVfuAExRV11YiN4ofVFTlpHxPIUO0XvFe7Ayt9ivZoWZRb40z+OCxcaDUisPSlpl09sTNRtRPnELjOx2p+S21sT58Rl+OgjwzlpYLrQi7VQZbQ2+FvCyU2jFc0vLSoKU/koof0+IMOm7wbF6/ErqBPm/odRuj7V6900umpJVaheZhtP3LxvH6PPbWtSlMFO5WmhQpKLtVbo7MlTxBqV/8N+oPcP7JX3jN115t+S/98Z/jdhN/LN/jZ+H8oW++4K/9ylu+c3/+si/l+Tyf5/NjOF94EPWbjfryCk19XdZaaik8vP2Mh8+/y3I6iqpSu3i6PNe0rTGGCtqJ3oUR3aWir3cBZbcOKTVBKuWK06SoD45pE5hG+bA7n2X165ys8qwRRmdHeuQlwd4I3knrjobOS+sU7QYPUTiJxhqcsbKOheuHnDDgJRHvkUG6I35QyRAZQpT1qNGVunPaLX4ZSg2s84nv/fovY8PILk704xPldKDnBRccNOFO2hBFeSmV2hLdWMLujmGzFUWxdw6ffQ+vIPN27TiXKsSuCio6IIM2Fxn1bCKqmzHKRbVOMD3eaBBKXZ4lX/2JxhqM9wRriZuJME4ydF8ivBpKMV39mGiwykeMj5qHkXWvvgkEeC/GP/EszjPpeCSdjtS06sDMZRSUAgWQdLd6EcM44oOXASfXK9QfjDYmCePTbwb8ZiPvk1JEBVVwftMBuJtGy4WyLvRW1fvc6b1isHTsdUi03mEuK/clUVKi5CJpdCPPby1FmpZWLUwYR6wTJfdSWtCa/B1jRbmrRVP4zmK8J+62hM2kyKwgT8SlChXEb2ug5Ew+z/RWsL3R1gW6wW2Ee9nUr22co6knupYVi/xcmi6sXPHPZqlBxWgqXTzeznrCONDPJ5KRn6u42YitAmRYc0Gg/e8+l9YwxGt7/cHTtUKvld6LKNoVrA7lcrH9evPV9XeLMVKLGqbA5vVL/LTlcsPVu74/tS7WuonWKunwRDNN7R5azRoF7dSz0BV6a+LasNC7EWXfQFvy9fedNEwpH/a32SP6+796y5/4pY/5J35eBtHn848+f/z3vOHf+VvfeR5En8/z+Rk9X3gQra3R8irQcidsxqeHB57u33F8updOal0NG1tptZPWxhAs3ksQqfcu63lkAAUByadcr8NjyrL+jt5SgXH0bPcD1hhRXFbl+3nFKGlyuCpKyXlHDFBMvw6htTZVK82VgWiMVQtjpxv12emqVZLT8u+NMZQsg+4wBKCTs4YvmmCBjJe0uNMBqrV+7Q/PS6W1R95+69fIKTFOMkS5UQYNgG6lF560yup1mBhuXxD2t9gmCtdw+4pmLOnxPeZSt6heuFLydZ1uELW5Ial+Y2Vwaq2qv9diMcJ+9R47RWhGO9HLtc7Qeo9xljCN+HHCh3hVES+D7XUA1OEb5z8gvDR0pNIrF6i9Qf2mOTMfH6mnM2VZyWm9KrQ1CX7ITKLQtt5oa8b5SBwmbPAfboi0A713WS1TRU2LN1vCdiM8yCXJdV2GfZBBuFVqStS0QpMhrLWLTxfoil+y4kO9KHfpPFOTDJ0XT2GeF9I6s7nZS3o+JaBhhxFr/fVxdyzOB7WmFL2RkcoEGwLD7S1hs5Wbm64YK+cwOWnYR24Saimsp6Mo0F3A+liLGQa5qVtkCMVCd9K4RC3klAk69OYkVAvjugz1TdBMHSM3ciFinBQYNBr9dBb0UknEF69UtXQCyr9/D2XFj9Jz3zoafpN62VYrLWdKKrRucNHjrFhk6po/kB6QQJ0xQttw0TO9uJOwVa3gvdhQjNa/drHE9JpITw+UvGDHCRO8YJmcxSC1qGhtq1F/clnF3mERb654t61gvgwyJHckNPgjnt3o+fP/3B8ABEL/Cx/f/Mhf83fT+bN/7Jv8+udHvv08jD6f5/Mzd77wIJoOT1grysD8eObh8+9xfnqQ5DKCMoxRghhprThvGZ30Q7cutZgYI2zOjibhsySUe6eWRqkSVAre4p1hmDwxeHrt5N7IVYbETfQ4p5WbtSnL0xKjuwYXQJTRy3927rJiv4SYdCtrOvp5zUUBdVZW0Tk3jIMweDRGwZrkQ/aS+nVeVVEra/9SK8MYmWdRmIJ3OAvz++/Sa+bVV3+OMI6AAR+wzlDWVUHlhnDzkuH2DhcCvWV6ToDDhMDm9ce4YeT0m78mQ1Fr1CRqpA3fl1s3HR8DrcgW9VKv2Tt4568IJOMilCakA7j684z3uHEkqAqKrkl1Qr8Yb6+r9u4cNowy5LWiCmjVFb29+kANAiPPy4l0PlGWlXqehWuq192r+ChdlMR5zY2SK8EHvBe/aLtwUJ2ndUFJtVpl2DSNcLMj7ne0lOgpYUOUFa+quK0Wai6UZaEuZxlq+L5htn9YCRsnA3SrXQJJ6iW1XewqaV05Pp1prRCip+ZCzpneGj5GHIoYwyqeSksF1oVuxDLSeyNME8PdLWHYfEAh6TG90ajXpHtNiXSe5fFdOKXDgLHy/VtO1DXLYGqkbtcZK6itYWRdE67XK57Wdgl2uagEjC4IJRcCvVdaaTTb8TjxduqNRLx7Lavwx/d0mjSp0eW9ts70Ig1QkkgsMvgaLwqyk61DPkvrVFcfubVq9aASdxsZQofx6p1FFU2r1aH0Tk8L6/FAqVkwYzSxKdSG8dJUdlHJTRPaQVpWHAbTK+2cZCvhPTUlLpgy+Rk1cqP3I5x/9b/yn8Q7wy8+D58/9Pmlr9zx3/8v/BH+h//7v/4cXHo+z+dn7Hxxj6iz5Lzy/rvf4+Ht96Cl6zrc0Ane6LpYVumgeQKFW8co68F5ltXpEBx3d4HeYV0a7VywthG8YRw9w+BJqVI0aNR7Z4g6bLYuvfNN/KXOy7q6VukWN1bWkN4K7qnVRuvgFafTWhNPqVaCXj7yWxPPqXVWhuIY8E5XfBVJ3hsYg6ZukeakputFYzu9GZ4eZ3ywjGPQD3tRctvjezb7W+Jmgw+BTqOcE2mecWFieP0RcbPFtAI5yeDkvKbtHbTCsLuhvHzN07d+i1Yq1lhCjOAc6TwThki42YnCqgij3g3WOBmwlcFJl5Yg8R52Cb84wVqFzcSw332AeV85kQopr0XCPXS6j1Ll2apcsxME0wfFSgZ2Yy21d9bTAyUnyrpQz4sMXJ1r57hRyoHBUNdCN5ZxmGSILWrJiEHqNKsMjYZO2Egwx3uL3+8py0KvFRdH9aRq4rxIZ/vy9ERbVwHJW/HZdvUCWi/0g97QrvFKyqtC0isuREyE+XDg9Hig5ILXm6CaC9PtHZtPPmU5nTh97zN8DBeXqabcC9Z5aq2UWhhu9kx3L6VJyaqnt16CXcjNSBe1Lq8n8nmmpYtFpuGGCXCUZdFmIXn+sRYbA8E6Ws4yGBtH3Iy8v38gAK5VOh4fHE3zTz5G9S0bTJPKUBcDxtvrDVh+eqTlJD+bKUGQx1jOmtpvVby4ztFLFluIKpFizeikVSw+clNptVzB01IibgemV6+wYcDG8GGtXjLGhyviqtdEXk6sp4OG8jx1kZ8dOw70UuiXxjdVONN5xuuNlQHMECFE+rqKYmqtKviGtGbBZf0I5/d95fZH+vfPR843P9oRfszBsefzfJ7PT/584UH0u9/+Fof3b6nLk6yfsQSt1BTQtPitau1Xz2TtSFe785zOmdYam8mxvxsJQSDaS4bTvOKtrOvG0eOsYJ0uKqNzFq8VoMtSsabrn3lyERtAr5VSxBPZa8f7SzoX7dGWQcioF+0S+r0oscZ86JlvWZRMa2Xwqpqchv4B3G8M1jpq7Xj1zi2rqLM3+0EGqS5DaGsdpy07777161jn2ezv8E4+5IcXrxlv77DeQ1UV1IrXEqfp3SotRvl05nz/IEEwL8pSrZn8JJ3mpmv3OyhjUQYrZ6WOVAZFXeuXIiEs5zAxYmMkDCNhGK/i5xXE2uqHlTWCLDJxFCxULx+GZviQ7Lp6ST0lZ5bTE3WdKfNCWzIuBmpuuGnEhkDLSVP8MuZ7P4iiZpA5fC3imwT9ezpgeEvYjtKYFSfK4UDHyACo4Z/eO7U26nmhrrOExC6PTd8L3djr9+ulYr2j9UZeFwyddFrxQXif8/HE6XCShqY4ME0D3cD06hUvfuEX8dOWXa3Yccv82ffYRGkPqlUqV8UK0th+9Jrp5SvBRF1eN2V0QtfAjOjx6/FIXc/QZaCtrctr5Rzr6QRWkt+tyetsogDB0QBOXSWAFsaR1x+9Zj4dmQ8ndrtRoPilMEYZ6PvF4knHhSgqZvQY08nzIu1HsuYQy42imaS+teA2WxlCszR5tdYxPojCfJHu24cAm48BH0SRDFNkevUSOwxgpD2sl0Rb5UbHhSiBujRT8kopCas3Aq3JDZKLI6z6HvGSvO+tko5nDFbCkc7LWiQMUKXWE/fBi1vXTDkv5PSswP20nH/jv/5P8V/7n/5l5vTjCZA9n+fzfH7y5wsPou+/86tYRLnoiDezXtUuCfNYOl7RSQ1hKZYiKtF+45lGh48SIDIYTufK4ZjJqTCOjhhksEtF1obeG8ZB0EO5NFKSD1TrrQDzsyRfO5CyKpyKaVIrHc5bfP9wrc6Kgtq6YVWPXAiC/ylF3GBelZ9aGrmISlpEuMO1fkUc5VyxCBT8vAj7cTM4WaEaUWhlG6zr2Npoy8Lb3/wVbl5+lf0nn3Lz1a8z7HZQCz1r3aWPomgZCVT1ksAGzm8/4/it36TTRD0ylrKuLKeFkpOoctariirqplOwvTFdFMEmYHyqtP6YoJD4ODDsd/hhoKtyJIpm0yFYgkK0SkN6z50P6rWU1LRxUZSkJsB6DHQTyCmTDo+U9URbkhB9Bk9bVwnHjFGU1lLEHeC9KJUNIQdEQVtZ7wUppZxLUeAL4+0O7wN2GIWx6r2oeqqkt5wFy5VleHFeWKfVGGF4dq5BHUqWx286SbvgLXKzNWwmeq2cHh6Zj2eMgWEc2ex3WGcJt7fcffPnsdZhWscPEy+//nXetcb57WeMGgLCGgyV/adfZXz5saiftYDVN5kxEvKqRcJSGM7376nLQtxtxJvqHWEzQjcsx4PgmqzHdEM1Br8ZcVVW+FUDXR1R+bsRi8Z+uyeOW5b5hMmZGKNuOVT57kIVcMFgxijhJ0kS4bVdwTpFdyFtR2Cw0yiJ9kvdqHWYaPSG6oMC7qKjroU4Dvp+yAzbjSqhUdqzlrO8hqXSrXy/3go0KKlQSlYBWBTgti6yyr+8nzSs15FB3LSOi9K61I0BB8wnCSBaQ7/4qo2UTvQK42b32/LL9vn86GeKnuAsM8+D6PN5Pj8r54un5i892LZLuCiLKtmFHyQrXCt1nLlaapL6w83kiCHgVD2Rvnc4njLznCilsdtKkjmlquB4g7UQoyeXLsB502VYMJZ1raxJpE5rJeULhnGwonD2TggOa2FN+uGuCCdAuKVZfKwgKmjVNiPjBHpdmwy+xlr18XXhQ/J9qWpjWFbpqY+DBFLSWrBBPH4XPqmQjXS4dob5dMLFd3z84pcIztLXdF1XyuQqqh/KdszLyuG7v8p6/w7vpSuc1lmPMyWtQGdzsxe+aPB06zEdgiJpTAxQq2x3c5FhwDrMMOCDJ+ykaQgFistraT/4ba2VIaJkKgYXJ+GetkudYlAF14j6ZqBbUXLX05GWFuIQsTSWlGTFXSVt3VqjnBd57vW5tjZi6LIKjkHDKJp2VhXN2I5x4tM0agOo84wPARuFaVoUWt9AwnQ549Vz3LvDebFh1IuapyggrCUvC61Ko1HDMNzuaakwHxfSacY7R4gDPnpc9Ow+/pjNR5+qFaND8PSSsK3y6utf5zhE1ndvaa0Qx5Hp1UvCtL0Gb7jQBRQRJWBLeeynt59RTmf8NJJnIQuE7YgB0mGGBsHJzUs1jribMGmlLAtpyTjv8cNI6wU3bQibSYgL1hOMoKt8vPwq6LRaVAyXUJOLkbYu1Jwk5MYH2/DFV9ytpaxFqAlW+tzLslCSdMcbVWTRcFZOlRCd2iw8NWX8MDC+eCkoqtZkM6C1oLIul5+xngslJdbTiVoyLjq8D7SaJRh1WYM4lfWNpaYkSmgMV5XfWKFltNowXoKIAnQQhb8uK2EIitl6Pj8t5y/8+T/Fn/lX/m9X2/DzeT7P53f2+cKDKAaWVHXjarDukjBGfV4SAjqfKtbDfhtw3pBL43yueGcYJ09KneM5M58TmyngNvG6Xg/R4625MgVTUkC9NaxZUsQSkpcPBqdDaDcyINcGLjqEvCSKpjVGqhsRVI3VkJOPXj6waNd0vPP2ms4vtUubi+l0DEOw1810bZ1aIWk15qhDaKlNIOJ0aq66DjcSpoIrLscHz+nxgc/+3t/i41/4fUx3L0FT6VhZ4faaad0wPz1y+NZvYEpRjquntUp+OlKrdG/7KRKmgdY0oJUWfPAyyDkvFZ4XjqdV/25whCGICjptta+8aqrcaBCkXUHnvVUII3GYMC1f23WutUDOQkny536kVijHRyhJcFM546wjDCPr+Yz4Uu2HmxnFR1lrwVyamvwHv6O5dJo7VUeNDDFGhueaRSXsRgfL2rWrvVPSTK+FEKJQEmoDZzDeUku9NmehbgJhUFq6jbRuiNuJWgrz4UheFpwVmoCLgfH2hv0nnxI3W7khC6OEdUBvAgZca9x88hXOw8R6/xmbV69UtdMaTy7PpVomNNxU15XT559TlwXnA2VZ6a0SxlF4sFlCND54au0UOpubLU5tMa004jgSppFaK96OOP23brNjvn8g379j2G4lnKUeYCsXhY0BiyWfj6K4D7KiN0bsKUIskOeZEKTpK2X6aSEtMyVV8b02UaWt+lZpsjlxQcgMJSXCZmJ6+UpU9q43es4LmaFeCgRE4c5pZj0clQThMXjKKp51E7xcQ2tYZaH21rFNGb8YuWm61skKZqvXIqQLLY8Aw7DZyPtqHH6oX67P58d3vv5yy2+8O33Zl/F8ns/z+W04X3gQnddCaxCDps67tBJdgiC1dSqdaSPesdNcSElYkdvJM4ziXTvPidoa2630ua+p0DWg4hTF9MGLKND2OcnavbVO6V0FToPRIVTCUlZbkUTtNMiw6DQc0cqHgROQph4sIV7L6AFZ8beupBekXUcJpRjpeSTlrt5VQ/AaeLCWIXhKVQetNkQZK73ZpcnzZb3ltGTGYJkfvsv7b098NIxE6yAMsiaumXQ6cXr7lpZPMjxrx31Zi2JxAs40+SB2UqFYU8I5j99tNfFcqOty5Z5ecQFBmn/CdosbJgmcKRS8d02u13pVdbu1uGES/BFdQe0G44KGa5ChqjW6i9TWyY/vroMsTdA8QngaCSPkdYEqtgYZQq0EhC6JZYWlX/ij4t8EuhOVTsMxFy6tVS5nLZIaNwsBpIcAAQAASURBVDpUVfXBumEURFGVa3E+6HusiaLqHLVVUlrUQtsw3WCDJ80r6XAQcH1rxDESNiPD3R37N5+InaGD8YEmiaUP7+OL39Ma4jTg7SvhVips31ixHNARkL+CHtLpwHx/r+twhLFqhHnZaqcvSd7PTsJy3Ro2m4kQvLBlvWXY7yXoUyvegIlRUuPecT4cSPf3DMOIj1GZqroRcEa1QUjLmdYq8faOuBV+aMuZpuB8MNgYMTFKo9M8k1fx+hrppVWfq9HfF4L6siFol3xj2G0YX79WUoFRxJK/YpmMPn/0Rkkr+Xyi1yq2ACtvAvH2yuvfc9Vsnyi0PWV5nzh3vZGmdwl76cvUrfxO6CVD7aL8jhETvPhan89PzTHG8D/5F/44f/Zf+4tf9qU8n+fzfH4bzhev+DSydgfhZFZt81G6DQbDeek8nQRbBDBGy34XmUZ/HRCtk5BNqxIeMXSCVuz1Joim1qVhyegQMo6CAKrWkHKVtX1weP135kJ2qU3CQ06CU1J9KQPjZbgtpem2WcMWFxpRa+RUNYQEpjeCdTjtyW6t0nOjFPkgDd5enw9j1LNaKsZ0LFYGEn2ueuuaDJaV5O0uMgyB4ynz9m//XZoJfPKLvwePJefC/P49588/w1KxMQizMmXonRAHnLfC10Q8pIDghKZJuuJjlA/luUoYo3VptOkdGxxxv6fVQp5P+GH6oIL2DiVjFAlUcqI5R5h22F4Fdm/ke+NkmJXayg7GUbuhnI7UvOBQtugFUF9VkTVIT3gIrA+PMlBbfx1YAcUcCZ6nX9a/RVbscbPBxqi8clllW+sEMZQuCWcJcHXldNog3sfakeS2NdpMpKqld9RSqGlRFVXeozhDXleqclq9d6xLYZpGNh+9ZvPyDX4YVUmVv2+uoS5dFVxrQB9hnaUQoBQZtpyTQM+lP15/BtLxwPpwTyv1Wu9qnceHgdaFx2m9hW5p1mGGwOicRJpqhVpluDWGmhXvdCFGdFgOJ1gXtjc7bR6SNPulKtRaKQYopdAMDPsbwjDIc5Nkla3UeQn8OEdLiXo8kedFAovI69cuVowmL7730jAlnuBKfHFL3O/FEyo/MNef1ZYXuQXU66l5FewVBhejDKdG2t4oVcJGvWG9pyOWFk4LPkaxDPQKQX3PGuAyXd5Dpcr721S5LTJKxMAZbfp6Pj9Nx1r4k7/0MX/l73zvy76U5/N8ns+PeL74IIooWs10TcYbXWMKzzKvjaU0cm2YDje7wH4brl3ytfUrfL61TkMCTzFIur13QTLV1pU73YU5atBUvlR2Xtbxztvrqq5jyLmRUlGLgCTyQ5DvvazC/pwG+Xey0r5ci3yvVOQD0DuDNWBDkD5wa+i5CAKqCYg/WiNeVi+p99aknacpVD8Ex6Xv2jiD9ZacZAi/vZ0Aw8P9wmmWLvfv/erfJ3pL3L+kHM+U01HUQWOp5wR0nPcaJEGDJAI6xxicdbghyH/vXastJRwi68gG3hGnETdGqcY0kTKfKWmRsFbrit0p1JwpSyYvszQb9Y7f7nTlLCEVNMUvlaaGvC7k0xHTqijVwIUdKq4AHZi9cCpNMzgb5J2lVaoSzmqqyoqyLHN2V9bmRjyhzir8/FIjmRVKLwzSrOgmq37Ppl8L+VIKTxf/YzedVpL0tNem73QjNg7rCNNE6AO9V5bDGT9a9m8+ZvPylbQ0OaUb9CYK28U8aS24SM+Zej5AOsv6/6ISW3kMPSe6cQhIvbA+PbA+PtFSplXxrvphwPkgap+u7mtpNOsIw4CzhpYypWScc9hhlKakeZbHbB3dO1qF9Xykr5k4DlgfrvWe10FUeZt0gZIN2x3WObEBNH1tGhhnRJX2jlYqeVlI86I3XWLzwCHvmSJVuxc/qATNYNzvGG5uP6zdS/3AWm0ZYx3GeuiZfDpQSgHrsEPEeSdhKiOtWXVJ4OQmycVBrqXKDScuXP3f0GlpFXUcMN5ItalaR4xWsrop0ulQqvpHn89P03HW8i/+s7/0PIg+n+fzM3C+uEeUy9xjqBevZJXe8lo71sLgDd5bpiEwjdKOkhR9ZDEyUCID6KVmsXdYS5VAkKa1ZSUPRYcSZz+A8d2VDdq59JdfVUcjdZ+5dJYlCXNUPZpD9Nf0eghe/k1HlJAmA5NTZdBrNWjOVYH5oujFIBgpjKibDRSj0zBYeu3XPntaZxgctUFaC8Ng2WwH5qXy9DirL9EwTYHBFR6+82vUb3/OZtoybQbtfJcPzwvOquYkNavNXJ8TG7xUdKpq1LvBWOn2pqkIOUT8OOCH4doChXP4aSsDxumAH7fQpTVoORyF2akBq14lBT/dvJTqw960u1zZrSnRSpJmKUUlGWOuzUvWeWmPap2yJhmycr16EpuVgJhx0JqV4S1XrJebnTANWL/DequMT6O+UWi50HO+UhxqltWqsQ681ddFEuNGvbpWq2FLzpqmTpRUxILxIYUjtaD6HNdUGXY77l68YvPyhQyhXkJa1zVvKXQvwxnOU84n+nxQvJX2oltNzrcmz6sTT2xNieXhgfXpiZqyNlx14riRdfyFh2mk+ccMQawV1tCWlbqu4olU/FTNhVaLKruOnDL5fKa3qi1ZRr6Hc9eQWq9VvjadtspKXIgLllaF22l0E2J9FIpBqxKKOs0aGhMCAUbsLMKgtYIa846eC26MbF6+Jmw26H2GJNwvyqOzdOulrjetpPkgvvHeMd7hosda2YaUeaUlDfsZg7FCaaBDGCfBTKn1odPEVlBU1bVW1vi14rUByjgnXFEr70MbxVf8fH76zhQd/+X/1C/yv/1//PKXfSnP5/k8nx/hfHFF1Ir/8qqIGPAWvLOkLv3ywVt2G60EbP2yNZbKSUU6XT7orYWaO2vWEIr5ADNHUTPSbiirQ2/Fr3fp5wZpZ7oMPRjxYdoONzeenCvLWtnvBg0hybrdGH/9YGkaaJI0u6ilvXesEZTTPBesMRKM8TIA9wbGS2iqqfprjQcj3fZprfgANjjWVZLb261nnCLHY+JwWK9r3hgst7fCgbx/90gtJ3j9hhA9znms99Kp3jU45Dw1rdIyFANuHDHB03KVD3FdY/fWRQB0Dhcjfhg0BGTUkxjoGFXwjAy4tVLWzPz+iZJFjfMhEoYIpbM8PGKdI4RJBkDjFBqftQRA1OOmiKjWJUltrXzPViv5NFOXJP5LJLFu9ObACohWhrbWsV7A+k55j7029YT2a+pZ1r1iOyjLqqqovO+copJaLrQi/7YbUaex0mxUFBdVk7bwOAnKOSe+zZpX1mMi3uyI2x3Ti9f4cRBEVtTGqVpoZaXlFTdsII4AlMMDfTkpU1e8koJukiaubmWY702GzjV1Ht8+0FcJcjlridOE9Y68rphexavowE0bhu1G0GGpXFulfAhyA7IUbO/iofSeUir5dMZY5GZEbRhN1+M2OFWk5XH3WsQj6bzaaAptTVKGoKxV6zy1FMoyk+dV3gNY0rzKsB+CWg60fcw6Wm34IbB5+RK/2cgvh44O5VX83l6xSq1Sc2I5PQkxwXisNzrQC5mgJWnmMsYK4zQGoQqUindew39arNC6DucNowSQmgvGdpwPsvEolRAjJgZaztrC1WXb8Hx+6k70jj/x+948D6LP5/n8Dj9fvGu+ipo0DY4hOpwzpNI5noTjt5k8ITqpxTTmuvK7IJaM1XpPDMtaGKLDIhD7VrVmU6ZF4XhaCSTV3rHGXj2pTX2gTdkdwVkJK2AoxXD/KGl8US5hzQ1n1QPnZAhorVKbBKWClxWt904UVhrz2lmytEVFJ2v+GLx870vrDWizk5Wkf4HWK5utp7TO4SljqNzdTvjoeHpKzHNWNJVlt/VspkhthsP7E8uS2e899IWUJobBYnqjlCKBk9aocyJaL8qTV1TThQuqffHo2tfGqJD3i9IjvFBjVX3ScJE1UGvj9O6eshbKkkTRcgZrCna7AS/r6uXxEV5Y/LAlnc5QEk49d039jSjxACe94cY66prIhxM1FW1PAhtlgBbbgQwposiJj2+43ROnkVZl4LDWXINxl7CJNOsUsRgsiwyyRoJM6PDaFFdlnKx5uzGUmsWf3KSIQGwfSkxynjBE7GagnSr5cObm5o7p9lbCNM5ifJQwVE7Cfu1g/IAZJpr1lPffw/Ys/ssLcuoS7qoVgXM6Wl21d31k9OBfvOL47YXRdeJmwvl4fX2d9TLYb3YMu628bmuSax5H8UlX7XS1Vm6O/EBaV/JyxgevbV5o/ahXdmqn5YKPQlnAOwHAb7Y456jzQllWuZGzFlTZbDWzns5SJdrFOlKWRO/CuG216s2GUBp6a4SNtCX5cdLrdKIi16ZuBr15SCv1fCavZ2Gg9o71TcNxjl4qtUm7l/Hy9Zu1Miwbi/FOGrGuqrzcsFgD3cuNT10y3YjnOi8raVlwweHtVn8PGFou2GC/L9j2fH7azid3E//Nf+7382/8X/72l30pz+f5PJ8f8nzhQfRm54nR4b2EB9YEqyJTNttwqX0mBINzjpw/wOclAKRp9dIYFWpfNTVtnMG2RvDiJVzWRtB14eX0LqzPWvRPraHkJl9vcOz2EkiRQVg6z4fBkbLgkry7MEYLpcg63XtLiF6VOGlFmmcZHKbBEoOu6tSfWkvDO0sDclHVVkNKIciw+nTMnM6ZMRhevNxireXhaSWtFWsNzllubiPjFFnPhcPhTCmdl68Emv309ECthjrdsNlPxN2WPC+0lBlCkA9rL97KuqwKbW+qIgPeE6ZI2O4+KI9xwMSB3iqtrJDz9UM6zyvr40EUspQlZe4cfghExf6YbnBR1tzr4yN1lFAHlusQIZWUVVBMSgvorbIeZ/LTUcI5quRe/KMywRnKvFxDQ34K+M0G54OolFq7Sld/qZEVa6+FvMyCNCoZ22VQ6ULkEn9lKbriFv9pM1266RVjZXvXGyYgixWhJml8EgXV8+rnf57p9gWmKWPUeWiiQtKKqqMDzo/U0qhP3xJx0UdR9koSwH83MrSq6kdeadbjN1tYzjgaLz96IVaPw6PYGWpV/FSihYCdtkybCYr22feOiUHCZTlDsFjrheU6bkjLmbrMxBhlNW7VU6vd7kaHejt5cWt4K7gjeVmo60JJScNeYIIwNXsWUH46LYrgMjLMrVlety5hQUGiOToNP0TGOwk9ibQtnNVWG+by9Y2FlKinI+ssaX2MNinVVbcV8uPfLsEzb4VhmjLeRyyXNX9Wtq2Hy00OHZyllkKeV4ZhZJ3P5CRotGG3ER+7rvaNM9gQyMfjD/O79fn8BE70jn/mD36FNTf+F3/x737Zl/N8ns/z+SHOFx5ErZEQTwOeDoVlFjXRq3czesEv1SbDoLMGuqimoP5NawjRUWqXxkhrrpDyzoeVG72TUhWl0glP1Ks1wBhDrp2yZEmi65q2VlhzZbuLLGthsxlY1kLwgncqKaPxZsYpkHKVlWFXhnjrpNQI3hI8gGBxrALUe6+E6JESnIp36n1sjWkSpfFwKJyWyjQ5Xr3a0Ern6bBq8AVCCOy2orgdHleeDgshGO7uJtZUmZfEfhMp6cBTaXTvKLmLbcAEaQsKQdmNGRsksNG1PtEa8JuJuLuR3ncMJkbwnqZhnl6rDFyt05ZMPp2hVmqRwab3hveBGIOku73HuEEQQfOJOCrM3kHTQQIjjTR0q2gpeQ3XpzPpeBacUuu40YBFEEJVgPWXSsYOxMETtwLr72mV4VZDPVbbe3rKtFbI6yIDbJf3kY0jYOil0fQx0sUramOg06gt05sOa6ZTFczVW2HYSp/9ui7SPOQDN19/g4+DNFuFEUK4ptIBjB0gRkwcqblQ7r+HixIaa+o7vjRcyeMpmDiIj9UG4u6GvpxoacEYRxwGPvnm13h8u2V9/44xWIXAW/z+ls3NnrrOtEUqJ02QBic0+S3YqUq4veH8eCS9vxdfZtfmKE2TG2cUOWbU7ywKtVEvaluTKM4YCQT1LmpkkzBRyYk8J7TJV96PVapArTVXaobfbUXNjYHtqxfyvqErGqsLVmkYJXyGoS5nWl5JpXxgy+rjsmEEI+q4HPF445xUiroA2r508Zq7oGGsnGi90rFS2TovDLsNbc1UHUJD8PhRbDLdNHpt+GmgzDNpuXzP5/PTeIKzbIcfKO7wfJ7P8/kpOj+QRzQ3w+ExUXPFe3dNswevjUW6YsdAKpcBE1nDS4hbGZ9GPaaG3KB1wzjKIFWKePRKbqxLJjtLcAo+N4Z1SWwnx/7Nnlw69w8LrRsOp0xwlqdTZgie05wJQT5wZdOmrEwFqIfwYRXfcZQK0+BlYKnSDS+J64a1wqmsTT2lyjTtrbHbDaS18vhupbXK7dazvxtpuXM+F2oWH+tmDOz3AxW4f3/meFy4vR2ZpsDbt+ILvL2dKLnR60qcLMd399jbG3qMbG/2V89jb00ehzJYTXD46LFBBlV04AFRsbp2uEuyq1LWJABwH2i2CZ6oSqPOtFX8kzX4MNBro6YVFwzD3R1hmGR4qTIMNRC1E2QN6wXlszw80lLFOYNzMiS22kTFdU48qilfkVJh8MRxpBdJbAuXtOLCBjsOak1Y6L1Q5pWyrtcgjB8Uz1S08x7FLynZoaRVEuUx0Hslzav4XGsjOIcPDjcMlDVhnWe82bO5fYkLA52GGbc6cVXFLHVJYscIYaIuM/30XkIxIGqcYpsEy6DQdGtl+Jr2uOjp85FWFlFZvRcUlXfcffKGQww8/Oqv4Exn//FLgo20ZRYFM3x4bD0LVeES3gl3L3j83vfox6Mqyfb6M1yLKLnGdMw0Ct2gVAk5dajHo4SXvJebk3nBWCfeV2/pq4Si1iWJ0u6lGUvCSVatIVpuEQLWQ5gmhrsX+GmDockQXjotnTHDlm6scGtLodPJ60pZxUfsQlBPs7v6aaWVSz3e+hz7MAqa6rSKikyX17qW682t0L7k/Re8qLK5ZlFoe8YPXtV8sZbYGMRHvGa8cT/UL9fn85M7/8wf/JTPnxb+N89+0efzfH7HnS88iHYsxyfxw4VBUDBOfXu1yHo2RkkXSyK9YyxEJ8nb2qR5yCsAvraG6Y5h8JTcmM9JlQlZdZ/Omd1WvJ5SpSkD4UdvJoYgYaTjST6wtOCI2sFh8FbDKqZrGlinY4Qo02m0ohxEE66rdWugNoMLgiSqqcjasYJtjVLFU0ntOoA7Hu4X8lpxFm7vBqbdyHxcWZZ2rfXc7wLjFMilcf8wA51PP9lTW+c73zkQg+HV6xuWJVNrZXczcTwXej4ylS3jTlaiNSVVnryGxmQoFraou/ooZeCW0ElbZnqt1DXraj7LMGKF+emnDa5b8nkmjht8iKIoWSvCnzGM+62s+rugji6IImPAXnyWPmDjSDo8sd4/YI3TAULQRr0K/7VfSp6u6K3KMG2I0+YfUECNi2qLkPRyns8YYyhJuJ42DJqvUVVPKQjGWEx0ulrXilGthq0Xu0gX1S4vC90ahv0G0yolFzYvXrF98YpLe5CJk/BT1b5BB4KXwJeL1NMTfT1JQrxdqAUXVa7SWxH/ppU6WbfdCUczzXItYaMAf6OFAwZD4+bVC/L5Y0gz3gljs6eCHQJmjPK3ctH3sJFmIx95/PZ3yE8HQhRCQu/9+6wS7YqDss7TsdjBy3OVpf6zG0tdFvnvYcCPAyZ6WsmkdSWdFvFhakAQxH9di/qlg8OOkV6F5zne3eE3kwy4pWOMoxuxhtDV01wK3Tp9f8sNiHVWQoExSKlEcLSlU9J6texISUWQ93pK8j5Q5msv4vNUgJhYe3LCDwPUznI6MowbjOv0avDbzZXC0Tv0tJJzxtkBa59T8z/txxjDFB2Dt6ylfdmX83yez/P5Ac4XHkQPx3RFCpX2/V6tjnfiE0tJUE5dUUiXjuaigRDvZHWLMwQNKZ1OST2kEkhaT4Ji2W8jXpmfuVb2O8/NfhQP6VI4PK3k0vA6rJTSaK2xV6/oJTxjLjgm/cDudFqWD0RZ9Te8F+W0gaigrVOqeAltM4p16lflt3fxtj4+rZjeGQfLdj8yTJHj48KaOikXvDfsdgMxeo6nxPm84rxlf7Ml5cb7d0e228Dt7cSyFGotbHcD51Mip8qLF55cTpQ0UjWUYayhm47RVLP3Dq9MSHMd4iwtzdKz3hXLk1fKKvYEY7qifQJ9TdRa8NtJUtYXjiYdEwzjzS1+u8GUTF2LLtHF/ylBk4IJ4odc3t/TTmcZypRycLEOtCprXQlMeUxecQHG7S1u3MjXc07bcoyaFBWInhO9VfIl3W6drL118BTzRxeqQoNmpIAgLauWJpgr59U4Q02VWsU/aqaIj560JDYvX7N7/VrA8Bqc6aXIwKccUhsHWWF3Sz0+YIoMZtIepFfSrQ5ZwqC8WE+c2hp60zunOAgn06jB+gr0r+R5ZnINpkF9tLOEpbTooV7sAc5jvKe6yNNv/iYtiSfUei9+TqB3aZhqrckQOkRFqkFdFgyGsNuBk2HQGgvjeFXX67yQ14W6ZJyVAJaQHGTopisFStFVrVbCdmL70UdiqWhd7kAQf2wrRRLyXRLstXXy6YHaFKVmpd/ejlHfk9BSkpavy++dLAQM8RJXpSNkMHKrecE1df15rTmr17SxHo/EYSBuJ0paZCVvJChJl6G85kIYRqhd6QzP56f9/Jk/+k1+4+2J/+v/51tf9qU8n+fzfH6A88U9ok78Xdah0PmuTEfoRqoxl1wxXUIPF7W094tyinjYuiVn+SC7oH1ondYF4yQ1n/IBWkql1saLFwPT6FnXynkurEvRhLOueGvDedhEwRLV0gS55BxWWYat1atq1o0jl0YMTnxniqRyxkhzjSb1jSKksnZji68O5nMlpcoYDJtNYNpFMJaH9zPrUmi9MQyO3S5ineXpsLIsiXEKjGPkcEysS+LFyy3DEHl6OOMcbDYD57NQCF6+3JDWQs6PRO+lpz3ooGk9foiEKCB0Y72kiXUobykpRglaydRcqCnRq6w7nfOAldrIBiEOwm7U5whrCZuRuN+J8pezVIVidKVdJBCjSl8rhXKahcmo63/jnbYXXQDvcm1GIfzDMBE2k66OZVC7+AEB0OFB0EGLNFs1K15FPgSdmoapLl3prRaaMSzn87WCshslJvSiK1/HMEXyujJsBrrx7D/5mGm/l5S1EzJBbzLg0JqooMOIcYL6KacHga47J4OlruupWf6789KiBBAi3g8YGi2vYj3wUR+GrvqbsF97KeTTkXQ8ygq+Q1kWjJGB06on8kIIMNZSWmf+7Fv4XrHTJOpva+LbvdScSoWEerKliKAuK2YI0mO/itLthghxECxUWqnrQi2VkgrOqn/SmQ+FDV00XD8OGG+k3363Y/Pxa9wwqjVBCAeCbJAbhu73ssU4H8nHJ0nBK1bJDIOEsC6M1lqlOat1sae0Dt4RnJf3el6F0eq8WARKkveV6frvqtxAWMd6OhCix8eBsi7abuVpXfrle6mS/B9HbJfGtd6fm5V+p5yfe7PjZgo8zfnLvpTn83yezxc8X3gQjcFSi9QiOmfBKylIV6ytdwZvrx8U0l6kSlU34ARCb+hEL6pjzvW6ju9GGpW6kb9TcqWWxs3NQGvwdMjUIg1IVr9H0+aeGGRIE6xkwwcBzvcG3cpqslbhORoj/907UUfp2hSFBGloFwVEsT5dx+IuSs08N1KqBG/YbgPTdqBWOB1XUip0YLMJ7PYRuuHpaWVNmf3NhA+eh/uZ1iqvX27Aep6eZpw3DEPkcFhx1rLdRuZTotMZRs/7h7fUBtvNjul2R5gGwhC1NUmGvN6R5L/yNjuWVjMlZYWTC9LJIJ3arTbsOMjjLZp4p2OCJ+y2hBhlpV/qh2Q8GniGa0ikrlnrO40OZXBpvDKXNXVrctOiyrQfR1wIMtA2GSiNtbJqRxS/klbto2/aFKVDFPmKUepVhjfvglIAKmlZpFWoyHvDeFFZbRDclcxmkkQP00jY3zDsbhm2W7RBQL4WHzBdJkbsOIIfqGmlHB+1KlR/fFSFk9pKUTsvPxd4LzWqdNqaddB1OsBxVUEBakqsj/eU84yLgzA9S8Eq19Rao48ZUWGtJS0L+XDAAW67FQ+xYtNKET4smCtdwXkrKm0qEAYBtpckPxvO00oD0zBdKjWlLQnxoLYq9gEldBm1E7gYsXpTEHZbppcvsT5yoRX0lvS5FNySsRJOKqdH1qd7+Zm34gG3MUhwSvFstTSxRpSqYTpJ5DvvxYvbRWWHBtUIwgoJF/ZudAiV9X4pmbjbYVolp0XW/sPAFRNQmijXm51sE5J4e40xPJ8f7/n2r60oHhrvDZ98I/5QX+dP/xPf4P/1y2/5G7/67rfx6p7P83k+P87zA3hEL+zOSzq+46yoo73JMAiQc7um61OW4JGA4CXoI0fWYF2T9NZb0qqd2AZ8sJxPGQuc5wpLxQDj4IjByS8s9W2F4KVdpkmNqHNS/9arqrZaBylNlWIbMGoTaK2Rs6S+rTXU1nQBK0puqR3JvEjlY14F67IZLJvdwGYTWdfK6bRSsvTJbzaBaQqk3Difhat492JDx/Jwf8ZZw4u7LcucSWlls420bnj/cCYGz7iJwhu14IPn+LQIBsieWbNnMnuBv2MkSOK9fjiLf7EbI9zONclQUsRv56Ign1ouGG+FKdkadRVVFGfx40DYjLg4QNPkees6T4j6ffnQbq1pNWL70A+uUHrdh9K1brXbDgjf03vhmbZarsqcMQK3B2GhlpRI80zLWbVxpynqhulaQ9llJLbWyXurJtbziXROwou8YJKMEyxQl+BU6428LBgf2H70hmF/p9YLhGvZxNIh/E9ZrdthAy7QljN1PglPwQny6KJMtiYe3EsorjcdYJ2XIf9iTXBS83kZmNBrbWlluX9PPp0wFyVVFWdn1EOqFaEglph8PlPPZwydMIzfRz0QJRREOTRGqmjjZmDY7a5eXKyVgXwcZAhV5iq9SsBryRiclFh5eb6b0ieMk9fMhajKYyFsNoyvXsn7R+JrolY2LXi1H17jus6sTw/UWjV8JSgmG7SmVjwlV3+uvskxWHn/F1G8zCBbB3Km1VXrU4220Bb8KF7jfDwLW3eMpPMZGzxuiLphcPSSpbktBOGkKo+X2p4rPn9M53u/lTg8yI3Yb/4H3zeIBkMpna/9wvBDfd3/zB/6Cr/y2YGHU/rtutTn83yez4/xfOFBNCWBlg/BkHKjtIazEjyy1pBLxxkZxnIWJE+MDmel7/2Shhd4uHzQeK0EXVdR3XJpDFH4nbe3I7k05ZOKytcaCoSXgcQYaTjqTf7eRVW7NCf54D6sKZtCs439gLPRawdDrrJq9tZQjahbITgdQpG+8g4xGPY3I2GILHPheFjJpRKDY38TidEznzOH40rwjt1+1KF0ZtxEgvccDwspZV6+2jGvlffvDmy3A/u9+ENDlA//w9OM946b/cjpOON9ZdpPhM0WN0jCWk6XFH0upJSoy0KeE9Y4CTE5p+zIKhxSY+mlCqqnVmwI+O1EmMarn/LiBRXPgqiRMoiizUtNtsqXgU2eeLEGtHr15Fbto/cxqpUC6alHX68ufkxRzoqwK5dFUv6XkNk1+G0VP3oB14sSluYzNTfymim54qwMSV25oN05fLAUC2ldCePE7s0njLd3osB6ad7pWbFFTZ9TH7HjhoahPt1jalJ1TJBPUmEpGKuu1pKOoduAmwRdRO+0dQHQIfQyZBUdBg1lWVgf3tNSkm50I/Jza1JL2krFDVHV0E4FlscnTCt47wFPa1Jf2WuRnxsNC4FW3N5sCeN0VVRbk41FHCdtK5NBmd5kCJ2Tpv7lRsQ5LzeiF+VaKzHpUoUa91umV6+l+lTLA9p6FtXSefBBYkMl0XJiPTyob7jTcsWOQYgLranto8ngrY/LWCdfW9fngFgP3Ac1+jrUNyFB+CFeQ3vScx+oyyyYs3FQxBaiwOcs3mXvJdzlHbZ1TIjypn8+v23n/WeZb/964vFdZTn//weLSu78yv93oXf4+i/+4MPon/z9n/Bv/tVffR5En8/z+R1yvvAg2lqX9beu3S9r7Ys65q1hTfJBOU1BFJtUOaYs/fOTgK7TWrCmsdmO1NY4njKmd/b7SJ8La2rUnrHG4LwEa0pBwdgy+DhnrkimyzX4IApnyU267LGSjKeIytlFNaULzL4DQ/A4INeGw1zbnEIU7+kyS9PPuhZy7bx6ueHubsQYy+GQOJ9W6J3dNrLdBWozPD2uzOfEMHq2+5HzObPMsprvwMP7I4bO69d75rXy9rMjt3cjwxg4HGaGKOrL4XFmuxsZhsDT4xkfHEPonA4PxJs7BrOhX7yVRgaLNC+UJWOtI0wChadVainqe5MP5poSlEItGTdEwmYjqhRGU8u6qrwEOKgYrBQQZAkt8f1+Pawql5f6VbVrlIoLlrjZCrKpSOc6dFUpZSgyQMuJsi7UlPQGQV6/bg3G6I1I71grtaUSnGssxxMlJ1FKu9RWGmNpJZOztPbE4GlDpPbK/tULdh99Qpi2cilOG3jqek1cY62kscctNWf6esC0JvB6unoGRVHk0vBjtQPeD7jtDRbhjXZ7CZlpiKZWsTForWY+Hpjv30uvvZX33bWXvWQZloylrgKPbz6QTycoGRf8FXzfNBHfa6F18DFoTWnBTyNhs6GnLINyzhIIUobnNZDVKiUn0lkCTLKtroQxYoOjrRljxXsNCsY3nel2x3B3p37vinGDQOVXQVMZrZftVQJFeTmLrUbRTTUXoiK6qPocmS7c2ybvIz9EfawyYF+a1YwxdH0vUwutK51jo1W0NeN8xIyBVpIySwXLJngosUSIum5B8Wh4h1F81FWqez4/0jkfK3/7b5xZ5858+kc/pzl1fvVvLxjDD6WM/rf+s3+A/9G/+Tc4LuWHvdzn83yez0/o/EAeUcERCeaoF8itMY6OkhvntbPZeEJwzHPhfE6U1tluIrutrKpLqoxRVrRPx4TpDR8EBVU77PaRlC7JYaDr6t1Jo1EpVZPhVjMtolJag6KJFK6NIaVEVOC+0WG5XaoEnSbjS72yTkMU9VPyFIbjMZFSYc0CAP/kzY6XLyZS7jw8LKQ1Yw1s95FpE8kZnh5nljmxvx3Z7UeeHhbm08rdyy3OGd6+PRCj4+Zuy8PjwvFp4aPXG7oxHB7PjFPUgbJwe7fFeSd/PgY224GnhzPGFab9W+IwMJgtGEtN0vmNNYRpgG6lU51OLx3TJGzmYrw+sSUn4mYiTDrQdlTFRFPzyDCBhLrzugr+SHvBUScqTWgF3Yn94dKQ1E3HRy8q60Ul1Z53o/5VfJC+9FKp6yLDctA1aK20qsGepil27FXlqimxHE+q8hrykihFHltOwpsMIYDvOjjBzZuPufn4DTaO+v5Rx+uFDaqWDBsCZthSlln74sUP2S8ZKSTk1lu5hnFqqTBtCZutqKZZQi/GGAkmXZRjJ2l8gPXhPcv7d6Iqduiti9/SS1FCzVlvCkT9bRiWh3ucNcRxgt4Ex1W0EsCA9R6vXuBGJ+x3kixfFulOz1mtEEFeO5BWpt4oZSWfFc9knTJHFeVVKv3y8+ekg72bznizY3zxQu4JW8Oo57IvJzBStEAThfNSx1rXhLGe2hO1Nrle9W738sE3LOE5CNNGKjubDqg2/IMNSl3e46VkGjDe3NDSSjc6bBsrCrYBOw20tcpmJQbW00k2ISHSswz+XbcEZpBwpUjbz+eHOb13/t1/+wDI7+bl/MXV5Zz+4wfW/6jzez695V//r/4x/qX/5V8l1+cbiefzfH6azxceRHOu+OCopUnTkTdEZ5iPCR8cL16MlNp5/27mNGemMfDRywkfHMdzxtJlaK1Q1kz0YI1nvw+8fbewroVWZRj03oK7zAaivKZUNXXfrwD13iRIUGqlVF2zdwnHxOjFVqchqdrAeoezkIuC6b0MbMF7am24IDzE43FhXgulwn438ObNhu124HwSbFRKGectN7vIMAWWtXF/fyKtlVevNsQpcP/2zLomXr7aEoLl3bsT4+DZ3254/37mfJz59JMbcjM8PZwEdl8hrZm7l1tqg8fHme0mEqPj8f6E9Z797cjn3/oOOcGLN5/QaqOtAuZ2McjAVJqspDG46LE26jDYqfMC1jK9eKnePLErEKXXvNeuQ0W9KkF5SfLnXfPtxqqyiUDGS5HGojCoomgY9nvxpSq6yagH1Cg3yI0TOE85PpGPJ6nvvO7g+3V133RNawAfR6z3rPPM+nS8WjHyWq4hKVpjHCM+BrVTNAiOmzdv2L56LX5C7ySY0lWBaxrwcQ4XRhhG8ukJSlJlUm5YZNK2EoS5PD+tUVvDbW8J2x3UjGnSY07X4VVT/kafGwMs9+9Z3r+H1nHWUbrc8NCbAPJVWZYgV6dZy/n+gWmMV3B+zY1WmtgRvCiY4WZPPkvS3W8GXBzpRdbO4iNuYIMMi8ZdvZa1FtK8YJ2XG7UqQ70LAeukmctgFWIPHcPm5QvGF3eycq9ZwPfO0ZaZts4yhOZV3gOtk89H4cGKuRxaJd7uRC22RtRlLmo8NOMIu0k9t2KZsN5jhqj1rcgNioYlK1ZurNaV3ip+FNxba1LHaoylzlnoA2MkHY7UZRVagjaEtZLpvdGKwdSGHQbMc2nPD3X+6r/9RFo6Jf/w1obf+uWVaWt/KFX00xeby6+p5/N8ns9P8fniv2I7VB0Gp40np8KyVG7uRmLwnI6Jh6eZJTVe3k7stoLAOZ4EVF8qrOfC7S4wDAMdw+FYKNXw5s1WAgWrJLcbULKwFUuuWKQJyX0fvLzUi0raWVKjtk5wAtXvWMlFYCi1oZYyHBcBSwZVo+nmdclstoHaDafzSs6V6B2vX0ZevJzwMXB8SpyOKyVLYn5/I0Po+VT4/PMDvcFXv3aLD57vfOdAXjOvXm1w1vHw9swQHfu7LZ9/dmBZMt/4xgtas7z7/JG7uw0pNZazqKc5d5Yl8eJuouTK/dsjdy93hDHy9P5IGD01P/HZr6+MYcPu5a182OdMS7LOJCgyKUnFYmuNvJwJw8BwcyMDa22KTLKUtEIRbyfq2yxFQPI+jhIcadIlX1PSBLXVodQJ4sk64jARNiM+RlmftqobfoGKo3zZrgikupxVJRQMFNbScpPmpy5KrrXoOtayHA/k86y8SfH6XsIw1hhsuDBjhRHrpoGbr3yVcbe/DoKXFLZ4GpTHGQZsGOgmUE+PmCrqpdz0dDBeQmOKpxKVr9OMwd2+FoWyZbDQ1wRY8BIQk3/T6Qicf318T5lX/BB1Jd7xQdbotYgn11ojg/Ew0YwlPd0zjON1VdxABioMPnZ8iPjBsZ7OlJIZxhE3bqVO9WK5qFWUUJDhvmX9WZNwmPMDdBnsxYdrsA56LpLad4EOtJwZ724YX72S17VkCINYA0qmzWd5ravYbmrr5PlMmc9XqwF08dE6UV77mqAXsQpYQ80VFzdi6ahVnnvFtfVS5fFY4bfWtFJKEdLDstCdxU8bec/kQlszborURWtJWyWfT8yHM7sXd+JHdlb+N4ilgQ5ksSK08rze/Y87lzKAv/PvzXzn15P+2Y/+dVsTf37vPxy94H/33/6n+bP/2l/80S/k+Tyf5/NjOz+AItqIUdbc52NiiI43b7ak0vn88xPHU2aInm98upEAUpGUee2GUhpDsOy2I602ng6FXAT6XnJhHAPOZRmCjK6FFc1krRVfl7usQ5X56SytwbzIOu1mP+qmvkmXfUPT9OKfDOFD0MUZRxwCyywd1PvbgZThcJjJpbLdBl6+mJh2g7QhvT2xLpXSGtPg2N0MWOe4f7/w/v0J7x1f++YLajN859tPlFJ59WqCDm8/f2KcItvbDff3M9YavvLVO05L4fh44MXdhvNSybny+uM9y1JIi3hK01KY58Trj19Qa+P920emzUAcIseHJ6z1hNtITaJ+CTtUhgZTuQLuS0q0VombLXG3xTlH6+Lvk7rEhu2XSIYEUtI8U45nfIw6gNZrh3uvolxJZ7sXn0bwxP2GYbvHxCjtPK0JtcBpExQGYzy9ddLpibKcCXFEu11lZMuCg/LGijc0BlyM1JI4v3uit4yzDhd0ICsyIFvzAfhvLRjnmW42bD/+lLjZXpVasiKU1F9sMDJ8hEGQV+dHTM9S31nV0xqiDj1AKYg/tNHw+O0dPkZpVcqJXgSVhfaqo8G53qGuK8vDO1pasCHSkgx83VmaorKMFdKADR6/2ZByIz89Mm53tCRMWK8hOlG8taI0DuTjkeVwYNxu8eMkIb6Srz5KuZCqqrSht0BdM2lZxEOt1yMBKUmNdxx+iKIStobpjel2x/hS1vGtZLUaqGq5nnV4Nxgf6UBdjsIjTVnDchU7DWI3KAXSIh5ZZ+lG1v42jPioHNHWxdYQ5OuRM6jiX2smrzM+WlgWMF6QTEHeg+gQ3RYJghnnaCWzziv7jz6iroqWag0agvlyqoI7IVI0nmW1f9jpvV8Edb73W4m/++/NP5bv8/f/5sK4sbz56g+OdHLOsB08p/X5ZuL5PJ+f1vOFB9FpciyL4ItevRqZNpHjIfPu/Zk5VXa7wM1GFKCnQ5ZhozaG6NhtI6V2liUTg2UcLUOHGCOlcQXN62efOve6IHoswslEPtM7hop8UObUrkGopklnUNRhQ9acTaD0Tj9LLr3285LxtjNuBua5S+uRhRevN9zeTbgQBM30lFhnUYJ3u8h+P1BK5/PvHXl4mhmnICv2tfL+3RGAj17vWNfM6biwu5kYtwMP9zMW6ZN/elo4z4lXr7ccnkQ9ePVqy3xOlNq4ebljOSdyKrx8vSOtmXfvj2x2I8Y4zk9nhsnjYmA5HzDdiTfudofzA21e6VaQTa1keq0Muy0+DqJgGURlKqL6SR1lVzZoZT0+0daEC5FWCtZ4jDOYagFZcV6wWDiLHQcZcOOAGTf0JD3wNkZd8+sro+oV1rKmBXLCWX/1IfbeMdraZaPDhFH9iZn1eIZapLpV23ZKFgqA1ZDURd01g2e8vWH70Sf4ze6CW7iqmOJmlcCaiZHuIxVDPbzHOifr97JqIEsHE2NlzaxpbuM3xO2t/P28QlnkawdRLXvNHyQhYyh5ZX18EDZl7bS6ysDqnHg9q1yj9aIOm2nDumTafGKIQaD+VRBHxon9otdGt+CjF+5qWtjevcJ5L89nWnVtLmGqribX7uSGr6ZMWVe8V38kwuitRQJ9tndCFwW7rIXeK8PdjunVS0UeyXujGys3gSXpzaDRIJshnY+UdREF0xjyKt5k570OyPniXBBlFIO1HmcsdRWEWysFq2qwQP+b3DRUqWm1ptNTw9iA32wwY7h6mW2U5iaUsoGRUP729UeYVigpSVtTBRuDDOjqhaZX0mkmfvy1H/oX7M/i6b2znBs5df7aXzp+2ZfzjzzWGP7X/9J/mj/3r/87X/alPJ/n83z+I84XHkTP58R2G7i7m2gNPnu7cDjIB93NNrLdBrwznM6FkitxcOzGqNvPyhAcbojXznnnHfOq3dfe6eDZqFVW784JjzEIyFM+5J2jJEHs1NqJ0RKCPAR7yZ20fvWLGisr4YuftBuLD5ZlScQAwzByOCRyyWymwM3dwLSJgOV8XNUPWonRst0NxNGRUuXdZyeOh4Xb24mXH+1Y58y7zw9MY+TF653gm54WtvuRzW7k/fsZ0zu7m5HTaaW2xqvXW05naWDa7yaeDqIg3txsWM+JVqTu8/gkqKfdbhQ/5LKw2Q40LOfDQgiF09ngtxNjq7TcpXccKylz5/CbjSbNjfAwW1P/rVWPXdN1aCY/nSTt7r2ERaoMPCY49Wp27CCr+tYqcetxcZRkMsAi4Y9L6OjSb07XsM64Ybp9yXB7y+Nv/gp5mfHOS3rdasGogtJbbayHI3letC/+w4pZEEhIEMUIG7aUyrAf2X/8hunFa4wVVqqhSV1ovfhNJYBiYwA30GqnzQ9YK+t+NMCGNeJzNNCXWQJAeq1u2op/NCd6WmRQ95JgvypsCrWvKZGPhyveqlfkOdQ2pVaF9ADilbQxkuYT5ILzXgD9KeOGQW7KrBHrhfpOyzJTSiUOk6yejf3Q215FZb2+FigzNyVZk1uL0TYtF8Q767zTfI58j3Q802pmev2C4dVHgLR3Xb+uJtYpWZFPVVb+6XxtkrLW0LzFmSjD4JyAVQNfciMqFa/SSCXtUY3uHTZKlWetRSpJraUbKGmVGxcnWxM3TZgh0DWhb0dpDLMp07q+/s0Qp0lqPNMir1mp2OCuGC+ctDLV1IgffcrNV7/xI/2S/Vk5h8dKLXJz9df/7z/dA+j3H2vgH/vkhv/gu09f9qU8n+fzfP4h5wsPoh9/vGWcPDl3Hp4ST4dEqZ3d6NiMXtFOkj4X/qZEToJ3H1bkteqAKav+3rt8QJVGvQyMXD7DDd4Zqn6QWqCskrLtVdqZwFCyKC3OGioiennv8FYGXgNX9qMBciqEwdG64f7+jDFweztwczMKIqoZzqfE8Wmh1K4YpkjwhnXOvP38xDxLoOjmbsP5mDg+zexvRvY3Ew8PM/N55e5uwzBFnh5nLI1pE5jnROuN3W6kpMrgDNMUeXwUKPk4BObTjHWWYRM5HVd6bfgYqEUCYGEjXNLeMnGUYa/VmeXwgHeWYbfFuSDPXwyEYVCoufo5QcIbl5S8NbQiz216Oogv0zoZoC7+SIAmtad2GGRtTSdETxiHa0CMqtibS4VozjJsKdrA728Iu1uMtQQ3cffNX+TxN36VumZ80PBTb1C6+FNzYZ0T3hpMr/IKGqcEAEstctPTWyelTNjtuP3GN5huX14kWNAh9AKpR1Ux4wLd6vo2nbDGKGJJsVUY9QoqX9R08CPgPvS4J7l5MF6anlQO1HS33DyV+Uw6naTXXr+00AuEFiDr7o6PgW4t3VhaTjgLdhikcKC3Dzgsba/CGmwIwoJtnRAjpjZ53lOS1qquXetVyALWOvGw6k2IpVIVtC8/H/L/NNYShkG4+ykDjc2bl0yvPpJVdc5i/7BaE1skAEQYacuZllaKVq3qPQjWGrk5CcpeXRNlXYVRqh31NshNoHBCJbRkvZf++rTS1lUpF1UqSU0lTIOyVwEvNxgSrEI4o+VD2YIxljAOUguaZFVrLsUHVssejMUEsQgMr96wefMp5OUH/b36M3UOD4XzsfHL//7yQ6fYv8wTveN/8Gf/CP/C/+yvfNmX8nyez/P5h5wvPIgOo6fWzuEpsy5FBkqkntN6CQ1dPuuhMwZL65ZcFO1jtT++Snjh0lcPlzCyEY9Y6zhd+6YkEHzTpC+61P7h72miXlKxF7ap+EIt7QNqR5tujDUYOi46UurkZSVGq6iliLGOUjqn4yp8UAybXWCzDRhjeXpcBM+UKncvN4JTelqY58RuPxK8FVzTeeXlyy0+Sn2nMYY4Bs7nhHMG5zzrWhmnQG+dw3EmeFk1r2smRBkiD4+LfHh7hzGd7c2EtZ5lSUoDcFKjinhB1/URc/B079i/2BCnjTTH6Bq263NoLgOjekHLspBOM+W8iKplRQ3q6s0zdHwImK7DSoy4acANA867q09TcgTqFawN0HBTrdghEna3+GHUwVaGDD/tuPnmP8b82Xeo5yOmy7CQ08w6zxhjpfVICwmMs/gYRBmsoshCpxvD5vVrXnzz5xhv9uJhtaLgkqXdCnTQtFa6xVunHp8gz+ILlLftFRuGsRJiaTKwNONwccIrt7brqtmqCnqduHoT9mUrlOVMPh7Fx2pk8PfDIAPoKkrhZUg01mJCJK0LzhrxT9Z2mRrFOeHlZ623jkVDY7Xhgpch3UuwxyjXFB0aRaKO4r9sRYau0q9geIzUaxorIalurDZXdeHXvvyI8cWtkBNKktCQMbQsoTUzDNi4gVZIh3ek+Uy3krC/KOLGB7ELFGG1dR34W17ptRKHWyzSAIWm5KUq1tBzoy6rNmo18rrSDQy7jbxOteGi+EfL6Sw0jCFS16Q3VdCpOCtKbs/S1tSboNyMMeoHtgr17/ibF0yv3mC1Fet321nnxnd/U2xDb7+TeXj35T4Hn38nc/vKM4w/HEprjI5/+h//lL/073/nt/nKns/zeT4/6vnCg2gtnXmuLIs0t0DHe4t3hpwrpcEYLMFbWY+XjnzuG0qVPnOnH7jOWazrpFV9ek65oF0GTUnLt+sQ2XWVbL9vqHJem3tap6z1WtHprKWrsuODp2ozk/eS3J/nQiuF3TZw83LDECWQsK6F0yGxrgVrDdMmME6BWjtPDyfxf1rLy9c7NpsojUqpcnsnoaSH+xnvDK9ebWkdHu7PMmx2wzJnooLqW2uMG+Gl5pTZTNKYU2tjnKLQBZaCNRZv5QbAxcCaKtSVGD2liJLlLqtR/RBd5weG/Q43jdgxcjVoVhl4WmlaaSiKz/p0oJzPMtgYCy6oeinDv2lZ2psk+YUZIm4Y8EPUalEFyF+uIwtMHSMKZqsNt90x3Nxe4foyWEnSni6MSPvmU47f+U3y6Xz1/cm1aloWMCHihyBVlLVBrZRSMN5x8+Zjtq8/koDOZQjFipKpK3IToqy1u6Pmlb4coEp4Bowm4sVjSm8SOhLCqmxrtztdxa+AU6ySQuovaV5d/ffeWJ8eyacjtmvTlwE7efGcNvVqYrDOY4KlOk9bV628ddQlib+3oat7uUFA/Z6lFGpJOOflJsFq0ltxZ2CotdF6kzpXoJYkQ2CvCo1XQzYX60qjO61MLZkwBjav3hBub4V+gNg+LuB84wN2nCSM1jr5dCQvK3gn7ycQAL3T5qwsP3u96s2LXDBus8NPG7GAaPWpCR6r9o66ykAkNgRRUf0wiKrZBLHEhZWKEWRVa/r6yAbAqRe3K7D+chPcq1TVGiOhtQ6EzY7p9Sc4Cz0lvTv53XFq7fzy35pZl85n38pf9uVcz3d/I/O1Xxh+6EF0OwT+zB/9xvMg+nyez0/h+eKDaJXU7JqbAII7WC9DZoyWaABjtU++4QevvE5Zx/so36qpEmoMDIMnlY5xBqcf5rXIcOqdtvVodR9GlQtdHeYqH+a2y5r+YgPAyCA8DpGUZWAex8A8Z9Y1a2BoYHczEodAr41lKcznTM4N7x3T5BjGwOlceLo/czouuOj5+M2eOAaenhZyquz3gqF6uD8RgmN/M3A+Z9ZUub2daB2Wc2LaRGGZ1sYwReZZPljHMbAuGe8MYQysayHlhqUTAgxTxBjHfFxwzhBiZJ1XXHB4rcsU64GndWFBzo+fU5aPRFlFhvCukO7ewfhILZVyPlNOZ/EEDv464NOt/n1RmYyB1itxv8V7j/VB6hsv+CNzSTZL77z0nVeMdcSXr4j7GyxawXgtItABGUnLO2cZb+9IpyNpnVmXhMOJEl7FAhD1uahVVMdWKmEY2b55w3T3QobMy1Bcm4SFLogpHzE+0HGUwyM9nbHChpJ0u9UfA6UqSKOPBHaIG71xkqCM8cLgFD6YpuKbvOd7N5R1JR8fyadZhr+q6m8cBBKfJTzW9LXx40Q3nZYTtguJoK2ZvKxS1ICRnzUjG4haCoSI3WxZ5pmaFsZpI/NnKYgB1UqNamsSClJyQu/QS1P3gdHGI91M9AZ4GXxzxlrD+OKOuNvRU6Ibq+pvgVpkgI5i+yBXyvGR9HQvX8sZrMrLbghybdrcZNHaVyc8YTeMxO0Wg7yHsAZjJTQk7UpNwmKtkpeVuibCZqSnLF3yWmFLLhjn8HHQ11B+NlottAZ5XQhWCi661vW6EMTDqi99K5lw+4LN6zeiDOdZPca/O87f/H+eaLXz9rs/mwnzj28n/twf/zn+D//ur33Zl/J8ns/z+b7zhQfR3uFwyqxZPGWCY3IyTKVOSRV6ZRgtuXsejwVnGtuNqIKtdryTdV/9PvySNQZvpC5Q9VEJ09SC81bXaqqdKEsuF/kgtwask1BLCI60VnxoTOPAvGSilwH48LSS1kwMhhcvJ7a7QZTX1lnWxnmu1AJxCAyjxQfH4Zh5//7IMme2U+DNJ3u887x7P5Nz4eZ2onfD/fsjMTo228jDw4Ixhtcf7VnXwvm4st2NlCIDWhgC80nqPyV5urLZDhhrJcRURGGMk2PcDOTcaXllnAIpdw5PM5u9ILAuQ4Y18vhrh5pm5vPMR99coWSa1aFSFTIbA2VO5MMTBov3geb0ExsF1vdOqwXj1INYC2G3l++l3eJtmaU73FqMYn1aUdWoV8wwMr14LQNDvwSjxKd3Gfb6heHZCmVdON+/ozUYpo0wak8Lm82EHyzWOVFIDdAapRXG/Q27j79C3O64QtoNkFfxY2oi3biA8ZHWjazi01mbkmRAvayZKVX4ouqtrLVhtjeEOHxfWj7IKtpaBdqrzcBawJIe37M+vpPvr+9jjMGPozItE7UUTBN0lttuZQBaF6UHNNqayFmaq3yM1FooJWO83PRUaxhvbiSkVwsP3/kMXGLylzCZoa7SlGT15q6sCbq83y+kA5D2JEnsZ5w2lpWccMGxffWKuNnRcpKbwOBkuM0ZMwyYMCiLtpIPD6TDg1TJVqEedNOx4yRw/JTUK4z6cKCmgtvsiMMgA2OW1a/1Tp67mrUJzYCTwol1XvDWUWbBX4VpImwmISvkjN9MEjxLSd93De89pjVSaVQaU5SbKXLRxyr81bKsmBjZfPI1geKXJO/p3j/cqPwMnr/z/z5zeJDn/un+Z9uCsBsDv/TVuy/7Mp7P83k+/6HzhX/Dvr9fOZxlrXZ3E7i9iVjnOM1VuqJVwTucK/O8stt4hjiQVlFEQdbozjo67UOAqDZKKVhvoEkLirNSEwngvHScBw/rUrXt0WORVT+K7VlSZRw83VoOh4Xb2wFrLZ99fmJZMtvJ8fLVhu1ulIBO66xLY5mF2xkHz7Tx+GA4PGUe3p04z5ndNvLxV/Z0HN/57oFaGy9e7ii1cf/uwBAt4xh4+/bMZvS8+mjPw+NCXjO3dxvWtVJbZdoMLHNiGgUnk3Ph7uWOWjqn00KtHdMbt/uAjeopNYZpOzDPmVobNy9vOB1OGCsBDyFUyZB7fnzCD1u++Y//QYbdXuo4kTW1sYZuID8dKacT1kmjUq1FVu9ArfU6JLoQhA3pDMPNLSiLEutlreucKITqO6WB6YaUM+H2hu3rN1hr6WWR4dBpa9Jl+NT1N62QlpnDb/4aeV7E51dhs93Sa6UY2G020mRUKus8Y71l+9Erdp9+TVawvclAaQx9mSU4E/z1z4wTJbQe3tGWk8zc3gk2SVFNlCQDV22Slu7AtJc++rIomJ4PPsJLIKkbUVWdY318T3q8l/Uyll6roqbCNcVeU5Ku9mHAbyZKWrGtSlCpdfmSytns+vNS1yRtRkADti9f43qjns64DvuXt7z/7ltM64zbiTQvtJQIQ4DaWM/5Groy1kibFrKKN168oF4V87yu9BjYvH6FHUdazaKAe+GktlYxw4SZttLrnhLp/j3p6Z7Smvq7deC9WiG6tmqJ4liLKJvD7Qs8/erxlEfXoUkdbM/lipzK85Fynhk2E60UQphkyLcGE4NYQKaR1nUINfI1nJEgJMYyTRMFQ6oNL8lJGX4bdDLdB/Zf/znidisDvTXyHjfuyoL9WTq//vcWfutXVtLSLwVqvyvOH/nmS/75P/mL/IW/8stf9qU8n+fzfPR84UE0pUq08PqjDbttJOXO05OA0rcb8e7dv5/xofPiboQmjUWSgld1pgNWVq29G0oqWAfVWFKuOAc+iiLinUDx01oYp8jpsAhbPDic0/Qz/QrM3+8j69qZDzOvP5YB7zd+8xF65WY/8Or1ht1ukgF0raxzYZmTrPGnwHYfsdZwOCTu30sy/vZm4pOv3LDMlffvnmi98+qjPWmtPN4fmUZHHCLf+3xmGi13txNvPz+ylsbrlxNpyRiDKJpLYhykPaq0zv5uz7pmluNCquJje/FixFnL8eFMHD3DGDk+nhjGwPb2hsPDkRCjDASm41wgr5mHz+958fGnfOP3/l6G7Q3kCkMUdclYWsmkxyM9VYHQd2h5lXS7EeiqNQ78B7Ws9UYYI+QiM0IQ9qb1H1iLvSt30nRqK4yvXrF5+UradcrKRS00GjxBFVdapdfM/PCep9/6DZwPeB+ouQiOxzt2tzccnw4sy8w4DORcqFRuPv6E/adflWsvSQae1mhpleHQWUycMNZzUdfLw/foeeESW7f2UpBgNDBUdAVsqb3jpg1hHOk1qfdS1/hW/bIX0L0BTCc/vmN9+5kEiqZJ+Kz69TCi5HdVI90wYKYtNc9Y0xX5JJ7U3uUGzA+RvK7kZZaeeAy1FjY3r2BdWU8HaVWKkbjZcvsGTm/fUlslaJq+dshrxgZlufaOCQGcNBOhvlW5+RA/KTFw8+YVzjnKesb4yDBoP713mO2dqqiV3gr56ZH1/j2tVwkKaujOjKLyt1yEKUvX8FSlLQvDZotzXm5wuvbHIxxQnFgsLv+3pEw5HghxpLdOGEa66ZQ1M0ySgEcRTBcvaauVEMSugjVYYzHB440h5cTD/Yn9IM1vHUNzjt3Xvs50dyequLGYbiCOuiz4nT2pdeXZHh8bf/0vX3rff8c/rB/qDMHxX/xjP8dxyfwf/9pvfNmX83yez/PhBxhEnYXXLyd2+4HHx8ThkIgedrtAyob1uLDbWZpxnA6F7cbivCPXhreiEF2CMrWC6YU4OE7nQs2FEKXtSOUmcqlYXcU/vD8zjjI0OWeprVFrpbaOt3CzizwdMtY0Pv54z3kufPb5Ee86N7uRl693TJuB1iClzHxKlFxpDba7yHYr6tnxlLm/nzmcM3e3I598esvplPjsu0+E4Pj401vOp8S7twe220gcIm/fn9nvArd3I49PC9YYvvLxjsNhwXvHMEZOp4UYBX1lveNmO/D0cCbroB4d7F9uSalyfDixuxnpNvBwf1JmqCfPK/vbHWlZJf2L4fH9geW08JWf+0U++blvEmOkrStuu8HGEWM65TSTD0eZCZ1TDJCEdHprssY1Bhtk/WpDoKZMOy+c5yc2ty9k+KxVq+DFF9kNYBxlzRQ629dviOMkSKOSFeyKrMyRFiA0kdxy4ul73+P4ve8SotOaxiorWqCuFess0QfOT4/kEJh2O978/DeYXnysamqTAExpwvJsVRBAw4RxktAu60J5/FyGQu1nN6CrVhm4e0li+fCOZoWJalqj9/J9Si4fgPhl1ccla+10eE96fJDAUEM8r9HTijxe64MA7OkCW48DJZ3lmqI0xbRS6MpQ7VWGcdPAh0hrmW4d4xhppxOlZNwg5ICSM1jL5naPpbM8HalGAoTrPIu61xBOpnpFjfUQHJ1KPc1gDSV3enDcfvqR1q8WTO+UeabMK7vXH2HGSQd3SeXXZRZPaBc2qY/S9mRixEQvftVUqUmwVdYJCiru9oJpallqWK2j1SZoMWc/0ASw1FzJy4z1UbBr4yTot3khjFEqUmvDVE3Vt063gnLr3ehNgNxc9d6w6h3/6OPXzOeFtBxwprH7+jfYvnwtQ3MXpbUb8RCY1ujp/KP9lv2STlPWbq2dv/x/fmZoXo53lsG7C2Ht+Tyf5/Mlny88iN7cRJy3fP75mXmu0o40eh6P0rt9dzdSSifPiWmw0pakCmatknK3VjA5wRnWZLl/NxOCYbuLok60LlWHVVZ8a5J06xgcwUEYgyRcgZwrznTG7cDhlBkC7O+2PD1mHu5PDEFCRx+93hFGSZqntbAuhVIaDcvuJrCZRDl5ekrc3584nRK3+4E3H+15uJ959+7IOHo+/uSWx8eV+/sjt/uBOA48Pszc7CO7/cj5lBmngXH0HA4zITjiGFnOiXEMlNpx3uB94PH9iaKA9nE08u/PhfW0sLvdqN8zsbvZcjrNxGhwNpKWld4aORdBQ7mBn//Df5iXr1/jjcMYT9wPEu7onfV4ohyOMiBgqDld1abaOqbLCthYS0kVHyJlTfRSqGum5MShvuXmzacS3riA5I2lWySc5AKbu5eEEGjr/A8GeewlYCZr+G4sdV15+K1fZ71/En9vrtRScM5jg5d2nQ4lSc/3tN1QMLz6uV8gbLa0vOK0canlJKolgvSyccTGkY4hz0fa6UHmYU1PX1fxOvL2vFw9tK1b3O4OZ6Sq8/J3DKhqvMpwpapqq5n14Z70+CD4pd5FjTVQFqmsdMOkqeyEGyJ2GsnzCSv3Wgq7z1BlIDP63LWS8cGT8oLb3TJuRsrTAeMtYXsDXhmtaJD+vBJcZPjkY86HA+f7B8bNThLyrckKHoSRae1Vze5AyY0eHHdf+1RIB6WII7t3hjGynBbOT4/sNjt6E/tCXc7Mn39GOs9CHx0jxnlcdFJMUBttLaoCS0CtJLEY2ODFTtG7BKVqEX6pt4K5yllS9b3L86Y+57CZsM5RSsJ4qT+tSbrjWxXEUjOGYbOnp6wBp65Y1ybvdaVzOGfYv9hxIPP/Y+/PYm1b0/RM6Pnb0cxuNXvt5pwTEZnOdLqMix7JQqCSoG645QJxU1zAZV0gIaESd4gLhIALSghKopNVUAUXhUClAptCdhnjUuGyLaeN0006MyMyMiJOs/fqZjuav+Pi++fcEZVV+GRmZJ6MyPWlQnnOPnvNNeaYY63xje973+fVrmF5fS0PUKVqJGOR9wHkeUTZ359T+5uqGMSA9jf+8p4w/Xx0WuflzU+r/oV/7pf5cjvw1/7hlz+9F32pl3qp31f9Hlzz8PQ0c5oEfWSsYbcPNI2m7TqOQ8RSaFtPiAlr6/QNUFqJ/A6ZWGwPM3EOdK2hbZvqos+kmhGfSyHMGe+FXapEVco0TmhtGMdI3xpc65nnzKIztL1jvw88bwes1bjG8OpuifOC+4khk6J8D6UVy97RtpZcFLvdyPPjkRAzr257Npue5+3Aw/2B9brj5mbB8+OJp+cj602Pbzynw8R67bHOs9tPLHuHprDdnuj6Bq00w2nCWk1IFR6fC4ftQPWL03aWdtmy2w6UHFlsOkKQxqjte6Zhous76euUIhUYDidOx4n13Vu+/Wf/GRbrNaogZiJAWUOcZqbDkTyOlbkpzVCp7uuSZEKotBWzUIrYtpFJZpaHCbTGtT3j6cju/ZdcvftMOJPeoyjEmLBdS7Ncyxp2GgDR7J3xQahz3nqikJn3W/Y/+pzxcBTNYtLSkGtxpVOqu77Upsk6Fpslq7u3aOOkufOtgN9DEF1nTmKsanrJIteeuHsgD88YY4WXWc7vV3BLJQdKknNaSqEYi+vXaJUl81zX465TNagfmDUUNGUemXbPxJOwTi+5tDW9KYczpqo65vsFxRjBOeUMWRr1PAw11MFKIpLWxEGa42wt7vqWbr2BFDCvbikxVlxpwhhLKoE0SzKRa2qu+zTjGsFYlQTaCSZLGXkgENc+EGUSmqzi5t1rnNbEENFa9LvaWXIp+NaT08S4e8QZAzExPH5g3u/lemodxtuPUagpCTA+hEppqDzWUjDOStJToT4UVOKUNnKuk6zxC0niQ6tOU7SiilwycZ7orjYX6kJJkTBMKGfpbm7kgVZr8hQrCg5BSSkt6Ulak2OUSe9ySfvqjazjtUYbW6+/BGGULY7zFzzZz0r9/b955PGrny/n+3/sP9uzvv7pmsZulw2N1UzxT6BG4aVe6o9Rfe2f7MMpkDOsV46U4HQKLBYWY0zlXoo0MVd+p0yaKmw+FxonYOnDYcYaaFcNqkAMkVyd9FrXxqAISFuwoZo5RLzWgCPMM31vsdYxj5Guk5X+fh85HicaC13vuLld4L2Ay2MslduZ0Aa6zuGcISZ4fBzYbw+AMEAXy5btbubxcWC17ri6WXH/cGAaR25ullhnGU4zbWfRxjAOM6ulJOVMc2K1akkZQsr4xhOiIKFyzBwPEylLXvh606OtYfd4wFlFs+oZB1lj9osFYZ4vJg+0JYbAaXckRPj0T/8Kb779bZxzGKXF3Z4TpSTiYWLa7+XGW6c6BflclFLEKJ+jt4aSInOYLxPMNE/kOVQjlKaURNt3xBgYjnuWt6/kRl8yrqvZ9apAnOsktHZt5ykoRaD2ITDu9xzff0kYBnHnU4gpUlCC3ao6xVINU8pa+tsbVq9eQ13r66aR93Ne/xdQxkpcpmspyhAfvoAworU4/kvFfV0ms6XUaE3kffset1gKvzKJTEEJ9wrOjwz50jGRxhNxvyWPgwDeK/czh2ri0lq0rvV7mrYhK8O032ILIifQVC6n6CrPSKUy14mctbjViqZtLzKHMs2kECp0XkvsZ/0628jnf3rcQUhyPDGhnRArCmBUjb1VwiCdpxFaz80nd9jqOtfnHXoul7AAtEalhEqRaTyRDnvC8ShmrMZVPJRQIFKYq/5U3PvKqIuOWLsaAVub85JSXZlXWmuUtXjO0swrpQQRZl3Nlo+kEPCthCJc/k5KaGdx67U87ClpsJWGcm5kC4DQJZiCSFO8p331Fu28vJaxIiCxThBzp+mjjvhnDOC02pif0H+WAs/3P1+N6U+j/pv/pV/hn3yx49d+8PRNH8pLvdSf6PrajahSGusU4ygNxmIp5p4pxMvUwTst93oyYZbVm9ICuc9JMrXbVtbzuRpYUhG+ptKaMEWsVTIJzUVSmUCSh5Qmp8hi4YhJMYwzfW8wxrDdBYZhxhnFYtmwWrWiJY2pAuLFde68pm0M2hqGU+R5O/H8dEAbw92rBV3fsN3NHA4jV1ctfd/wcL9nnAKvblficD+MLJdixpjnSNNacpbEqLZrRZKQC95pYhRJwjQFptOMKjLlXV4tiSEy7A60ncVYyzDMdW1oCdN49nVhNUzHA8NpxjYLvvVn/zRXd7doNEpJUlCpUYrjYSANE0rpGnuoat8lGJycC7mo2qBALln0pLUxiONcwennRB5Z21vXMG23WO/wyyv8co31vnIrZdUPqrIflegllaraz8C02zI8PxLHiRRzZclmrLNYLRO7mFOFqhdc27K4u6PfbOQYjEE5J+vkc5Y7Gm0Uyreoppe0ot0HiWO0vjZD1GZCOJSUSmtQCqxHt5IXr8pH7qiYaipX88e2mhmIw0DYbaVRRmGsHBsoGYoaaZ5KythOmuOsLWk44jRoZUS3l6WJUgXyHCqeKsm3NA63WuB9Q64pRkTI52mllus6xRrT6hwxZebdUVJInb2gvc4PBkaLthotD0RhntELz/rd26qnzJfppPywazEnIZNkvVwRx4Fx+0w6iunt/L5LrlPW6kQvRdbhWonxiyzX9JkBjJKkLME5ZUiFrCT1LP1YE6q0lmYyJkEy5YRxEu8qqKdC0aDalqZbCKVBUaNUFVgjE9gaHCAw0UiOsrbv7t5iO6EzaH9uOOXYlCryM1JDF/L8sxXx+cv/bPcT/55T4R/96k/qXPfPiePuZRL4n/nFW7771Y7T+SHwpV7qpf7I6/fEEZ3GQNcYumVLKYWYaiKPBmOMTILKJcwGlJHpRcgSV3mO5qRyRGuGtlJa1otWYyuc/uz0LCjmMbJaWoqxHAcxS6yXjqJFHjAMgcYr1puG5dJfpmshyko+l4JvDE0jDe3pFNk+ncRcpDWvbpe0vWe/G5mnwHrpKUrx8HDAWc3dqyWHk2SfX131KBRhCjhviOnjcc9zlIZEKSgKYwyn00SYJRK17Vqsc0ynEa3Ad60Yf3KdjFWwuHAqQVMYDgMhKTavP+H1p5+y2GxQytSJm6bETBxPxGEkDhO2rkhVnS6nECvCRiY71nv5bzph2w7dNORxEj2edyIBCLJeto2XSfc0oZsGbT3Nao3xrTjHK7dSED3244rayHo+HI8Mz4+E44k0z8SUiVHSihrnhDFZI2FTNbO16xXLu1c0XS9zKOdQWhKNSozIyl8aQONbsrKk4USZDuLANmKOQmvRYZ6Tuc6MGi0pS6ZbynkqGeJ5GqovSU7yWZR63grD9pl5v0cjqT5n81NOiTyLXtMgemO7WOLWa2IIpOGISjIpTLmuq6tpL8e6wtfiyi+Nxy8WWIO4wSvmLEeRHyithTUba6CEVszjSDqNqCyvi1ICv68xuWh1+VnMqRByxl+t6a+v5GcwBjFL5Yxytp66ShXQGtstCKcDpw/vSeMEWRKllDaXdTylVNlAkUms1UwxEOZA0/VnEIOoHWpcptLmI4vValJK0oRqVXm1VU4gmp4ab2qJ01ybVJlEu+VKrsecJImqxq2axsvENcUq+aBOcT3N1a0gsWLFmyktprqSKcgUVkmSA2k8Mm1/tidm2ij+3H9u8RN/9vBV4PnhPzAlLfDbvz79ER7ZN1//tf/8L/JX/v7nnH5GDWkv9VI/D/V7aEQTfSvr6BQ+TlCMUmRgnqTZkjFUzbLOCWfrxA5qcySvp1A1n76glUIbhdGaWCHWMnFM5JK4XrfkAseTNJxd15IzHI+RMEVar7i6bml7gaznJOv4EKSpaFuLc5pcFId9YPd84jTMWKt5dbfCectuO5JCou8dMcN2O9J4xXLV8eHxBKXw5u2GMCVSOjehGWuq61dLSE+YJT0pxMzhMKKRBKmmcYQM4zjTeNEahhBxzpFAVvaV9051Lg9jwHVr3r17x9XNDdY6MXlkcXmnlAjHkTxPlTAkzUOMCRXkmHIQXaGqmrysJC7S1ISgPIx1KiT/Hsf5AhKXFW/ErVYs376jXa3lYSLVCVgRjJbS+mO2O5JcM2wfmR7vieNESZkwzWISq9rJlAu5JIkIrd9reXtNf30tHNOqES0lk6eaklTX6dpZdNMRYyGdthDGy/RTnTFLQCFcJAIKBHDvxMylzjEJJQvKqmSKqqt49fE6LXEmHHbM+6OQjhCNbdGC3CoxEecoEZKmSBpVK3QDphPkKHzLVDcHWh4iUhbDjrZWCJre02w2mJzI80gKAWOMpFSd19lFJoQlZbQqaO+JxyMpzPiKeTobOpTV0ixXSUaOiRATbr2mW3Z1Iin/Ry4frysFSuUqF9CM4wPj4wNpGOXYnaz3lTHCJNVazgeS+qS1IoTAsDtxTvXKbUtTk76kOTbyPpDJZVHlImfQRiQVYrAT6ah0x9R0JkmwUsbguiW2aeX9FXlwKEmkL6U2x7k+HItetcHfvJI0qzDLRLUgWuZSJSZ1YH6WC4xPj8Rh+H39cv3jXLdvHLdv3E/8mWjTf1IP+/g+fuNRn68/c6yuzB/a6/8L/9wv8S//xX/IFF6moi/1Ut9Efe1G1DkjGs56U9dKkQvEmNH67I6HlDMhRrRRokMsRVZwSpMLOCvM0GGcJfrTGNGmKZhCwjqZUIzDTNcour5jjtLoLnrLctkwjIntXpA9TaPZbFq6TlaROcsQJdWNceMt1snk8ul54unhwDRF+r4RRuiYuP9wxBrFat0SQma3H2hbQ+MdX3y5pWk9d2+uGY8jxoBvm5rU5IkpIVz9QkqFdtFyOtYpqFJ0ncW1jtNxEgJAa5nniHFV5zoFSikYq7HOgdJMpxPzEFnfvOb23VsWVxsZmmlNqWaMGCLhcJCc+B+zlKY5CPRfIVncyNeJHi9hnK4O+ojSNRzAGtHmnde/NSq1KEX3+jX9zS3ON2KAqW7vGiov/zsbdnIhnA4Mz0/Me8lyT7OA0mOUqMacsxxHNZLknPF9y+atRHVqpSvKp147sea354hyDdo3KN+TUiYdHihJ4ihR5vKwgxaXeMnqAiMvKHHV19W8OsdgzuOlKUOdXfXSkKV5Jhy2xGGQ82SU6BVLQWuDLoXEuZG2YC16seb4/j1Wlyq9rdP9cnlG4+zG170nnmaKLjjtKYedxIo6jzauOr+leZfYTVNToQqmbfDLNbpp2b3/ijDO+HPe/MVco9AVpZRKwW1WtMslioSMUI3oX7WCIvrWUvWnyjjCGBjffyHHWpt7pcB0FVafkiRSnSfOqjBPYkQsuWC9QyuYhpGiNE3XYpwTKoFVkAX0X7IEJigFcTgBCuObGgZVPiJbtcJYJw9tjce0bZ1sVn5oNb6hkKQka+vrKuI0k7XCoS8Te3k48dSxf0WAWVBicBufHknDVIH7P/+llOLTX2x+4s9uXls++Y7/XX/37/57xz+qw2JzY+kWf3iN6H/xn3nLv/Jv/+OXRvSlXuobqq8PtA+Z1hu0UWjFJY7SOmlC5jkTQ0JrmQBqbYjTJLq5AsRM17s6qZRITiHriObtNCTazqG1Zh5n+s7QNI7dUTij11ctbWs5DYn9YSanQN9ZNpuWpnHSP2hDDIlUj8N5gzOGcco8Pg5styeOp5mrq5Z37zaMc+b9+z19Y9hc9QxDvjjgc4GHxyPrdc/VVc9uf6Jxgv6Z50jTOFJKMhmdRRvnW8/DwxGrBZretgbXePa7AasKbSMA+rbzlCJrVtc4VMmydiyKYXfCaMcnv/gdVlfX+H4h7mEla2aMJRxFC0qW9blyFmImpShhP9qgsmRvp4ocMk4iHfOciCkKrL6usEvKH1NmiqTcKGPpX79lefdaaAfjIGihygKVQVVNS9IAmtP2ntPDB4lPnEaRc0yBMIXLhEsp0UpKljssb67YvHtH03UoVAXqU1eqdTqZE6rp0V2P9r3wLXf3KIowKVWRJw9tKKY2YzFKk1TjOk3Xo3KUVbVpIQZxS58nu6auaOtKNo4D825LThHdtBglee26lUjKiwYVcYPrrkX5luH9e5hHVCsAdjHt5TpF1KQcISqss0ynE2RofINOEd21gBMzjbEU8qWJLVnYmtpqfNvhliuUNjTGcv3pZzx+8QXjYaBrG5kep4RyjpwkQMGvN/hlL1KESiWQdXSACFQ5zFm3GlVhfHrGINPqlJPIa7pWHlxSQpVywSxpBcNxvOiMrZftifwP4jyivKe1FeIPdRof6sOUYR4H8hzEBBfl4cA4cblrLMoaigJjFb7vZbI8nigh1NGmmJTyHKvpTFXkbCIMI0rNjF/9CN58guuXtalXlTAQ69+P0oTvDxyet5Siabv2p/LL9mexuoX5XU1gKYU//8+vflxCzf0Xge/+w5++lvbttx1vv+X+6X/xpV7qpX5m62s3oo2rv4xyJqGrqcQyTZkYAoZC31pc1zAOgTRPGG8Y54xR4oI/DRGrofGGEBKbq4an55kchUM6TolpmFivPLloHp8mGg/Xrzp849k9TxwOM6Ukusaw2XQ0nas3RJiHwDwFYXh6jTGGOWnuH44cdkfmkLm7W/D69Zr9PvLVV88sesfdmzW7Y+R5e+Jm05By4fA88vr1Cms1u+cDV9c945iYxkC/bJjniGscIcgN2hnP/fu9TDoVNJ3FtQ2PH7Y0jcM6xzhMdL2Xaar3GO9JOWGahsPuyHSauL59xetPPqFfLtFe3PgSSZqJMRCe96QpiFu8wsB1nmTFbQ0qSxN3htcnVfCtxXpHmoTRKP8tC8JnHlFV15crPsmv1yzfvsOvNrWhCyhz1k+eV9fl4oIuMbL/8DnTdosqmel4FGRWqkY0ZIKu4ONqvsDVu3dcf/YtjEYMSFUbKGv483RCo5sWtVih3YLp+Z5y2oorW0sKVzknKmnBA5Xw47zPjG57dMlAAiNO9DrXr5pWe9ZEQM7E05FpvyOnJLpZZMKmrUUFQf1cXNhKY/ueYj3T4xPECW01Kc41ez1htEVbS0JQTTjN8XBEOUVrPXEKtJs12jriNKHPGt+YRYqgACRm0xiDW21qspSs+63x3L59y1c/+oLdbstmvQJnyTETc8KvVqJHDrNcJ5XNWeaBXDLa6koqcMTTiXQ6cqrXqOs68hzRKWDqRDmPMyjRqqY5gtYct7u6MbCY1mJ0PT/aYhuLCpHx4YHYtbQ1RjPPo0xftSXFKKv9s7yiyIqdlABFcVam1kYwTcYYcphIw0QJAd00F0OUMpKklKaZkgrTOMhGwWryNHL6wXfxrz+jv3uLIsM0VM2vTPnn3RPzflsbUM08//yt5v8gpZRiufnJ5rRfaj75hZ+cnP77f+UPzjH1jcY3f7j4rH/pX/tbHMZvVn7wUi/1J7m+diOqtcJawaHouvrc72ZCCCw6S9c3xKw47ke0KQQ0KhRar4hRMY6RxcITqlmlW3i++OpIYzXrTcvhMKPJXF21nIbEYXditbTcvhZTyYf3B7bbmcZpvDdsrnvazgk7McM0BFISU5JzojcdZ/jw1Zbj/kQB3r5ZcXW1YLufef9+S9853r5ZcxoTu+2Rq7XHGM3hMHD3ZoWxjtP+wOZmyfN+hhhYXy047kea1hEnkSCEmBl3I33XkuPEYrUgY3n/xTOrlRNTyTzTLhfEOWCsJxUtyTLWcDqMjLuBt599h7tP3kpqjHWXSZ1xLePxxPi4w1iH7zsxKiVZi2bZW1Ki6B5d34gxZZpoFj3GO+bjWI0kViDqxdbwgIh3DhFQFPzmitWbd7iuo0yDZH7bs75PVubnZvEcT3l8uGfaPpHnWN3TYvbRqoARU1usk0eVC7ZvWb95w82n34EijFHOmtVY2aDVYEPTYBYbil0wP76HwwPGNTLJzZkcBXOlbE1wGifJd3eGGCO2XcuEshR024v275xTblRlelL1jJFw3BGOJ0oquL6XKPphxDgvOeZFMFI5iWbVLtekAvPjE4ZM1iJVKEmc4cZatNLkHDHaU0JkihM0ls56cgG/WqOMJc8z2jkZ8M6SEa/rRLjkgjUa1zUyzbw029Uprj3vfulP8/lv/ia7w57N9YY4T7j1mqZfSIRoTHV9LS51DFUCYGWqbSzKWtrrWxrr2G+3TOMJg+CNQJFCIAdZgaeQUEZz2h8ZDyPeO6yXVKsQAs55iQudI2EcMUYThhMxJPpWGhljG/kZOp2w2mJcU1Ogqk5Ti2SllCLUjVfXaGdJx6NMiov8HYmdjfLAlDIlCj1iGE7kccavFvXvZFKMHH/ne8TDgcUnn2KdNFCKQjwdmB7v0caIfEQpyD9dfuXPYxmjxCPwY/Vf+K+sf9ffe/gy8Pf//a9nDHr9ieOX/txPfxp9Jjv8z//iP+Sv/+MvmV84oi/1Ut9ofe3fsIuFRWtNBoYhcTrOaFW43siN4zhEjC74RnE4FYzOLHrHaYiklFkuG0DRdzLIef/VgauVo1u03D8cWXaG1bpnu585HgPX1w3XNwtSyty/P7DdT7ROEFKrtaftKjA/F+ZJzDVNo7BOo61hjpoPX215fj5QULx7t2ZzteDpceThYUffOd68XbE7BJ53AzdXHSFmHp9P3L3eEFNhHgcW657HhwPXN2tcu2H/9EzTWsYxYIzgrHJWWG9RZeb2zZrDIfL8cM+r12vmmAlzpFksiXUaBRqtpYEeTgNxCHzrl36Z61evcF0rRqIsDnDTtkzbHfPzE77pRCNpFFTwf5rnahzxxBDwi07YqTngGivg82GSyZx35BKx3l7iKLWqznBjWFxfs3z1RhBOSfSl50lR0aKdU1VDqa1jniZOD++Z93viNEtsKBDPukhFNZzV1bQC2zbcfvZtlq/fkFOomtRGkpfmsa5ZxcSiuwW6X1NMw/zFb0GYME1DqRMzcYlbjG+kIZtGdNsCSiI1lys47GTO1a9kCpqCNNClCLCcQkFTcmI+bAmno6CZukaQQoO4iEuogHTjqjMbdNcR5pk8ntCq1OZUNJdag21bQSaljNGQpolpmunfvcVTmPcH+rtXkpZ1PKKsQ5c63a1weKrhyDUe14vzucQoDyLI6p+zyz0F3v3id/jqBz9kmCaa1ZJmuSCHmTjOlDrZVhlMLxGwum0o04wxDWiLWawwddKsNvB4HFC2wehqPEoZbcS9nnJmHmZiSvhVD0noB+SEtg7r/UWvWUo1OZWMihNaL7FdSxwCcRxAgfVNZcWWGrcpx5kRjNvi3ScobUjzjNaWNE5ynFb+TNWGNJdETplUr/Gubys1KslDGGC9Z/j8R8R5ZPOLvyzUijAyb5+qec8DpUoNXhrR30/9BxtTgLtPHP/l/+rmJ/7sb/47e06Hn2wGNzeWf/bP9zLl/ilVLoU5Zv6ff+9H/G/+yq//1F73pV7qpf5g9fUnokaTE+z2gRAT3iu6zlOyYjzNOKcJSRHnQt+J+3V3nGks9H1Lqk7f/SEyDYE3dx1TgK++OnC1caw3PU/biTkkbm4bVouGaYrcP4wcj4HWg7WK25uOrncSW54zIciq17pqqLJOgPT3W477Aessr9+sWK07ds8j++2B5cJx82rNdj+z353YrBpSzIxD4O5uJdGEOWNdw/OT6ERRiv3zHmMt0xTxjWOaIiiDMQlNZnO7YX+YmIeR27dXxCiau6ZrxUWtqrFHiaZ0vz/iXMcv/6f+DIvF+sd4i0nW32hOD0/kcUKbVhowXbWiyGRHO1fdwhHftoJrygFVZHUdx1HQPNWJf+EvKllhUhSqaWk3a5Y3NzKJOq/JtTQ30skpFFpYkTkzz4Hjhy8J+wM5RnLKhCmQK5Re6AVZsDtJkXKhXa149a1v011tyGGscHyk6c1JNJCuoSiF6RfoxUbMTl/+BlolivPgW1SKFZRuJUWnfj3eUxAZg20XlJPka5tuIealONdpYAXa12zyUjLhdCIcjhULJaaxeRjQtk6ANTV+M0qT1XVM80wcDpgaT1sqRYAYxcNlTJ3sKsIwMo4zq299m0XfMD8/sbh7RaEQjyfRt54xVlX2cDYnmbZBu06azhxBO5RV1WwjqUGctZbO8eazTzg+3mN9Sx5nUgzkEFBZ1vDKymT2DMoXfqqSBxPjRI9aMt433H32KdsP9xKtOU0YbQT5VBIxR3mwcTWeF3ngMJ3HVmZqmEdiSFjrCVOAIggltCXPkTyPlfbQiNNfl2poq9PeOaAXLd3dW4iJNE1oLXrdnBIgcaLKiotfnXXPRVi4vhXzTZxED5xyxloLSaanabdl/91/THf3Fp0DOUw1IEL4qMooSvqDrZdf6mP9hzWWf/6f/92T059mlVJ4PEx8/8OB//6/8at/qN/rpV7qpX7v9bUb0f0hMM8ZZxTrpRgRwixaPlu1oBaJrRznzHAaaVuDtVZMTFZxOM6UXLjatOwOssa9e9XRtI6n54kYEldrYYGOU+HxaWQcZloH1mrevF7QdIKpKSVXXmlB64LznlwUj/cD28c9x2HGNZ53b1Z0veewm9luTywWnn7Z8uHhRBgmrm4WUF3kd3dLwpyJKaKUZTrNrK9WohsMgcYZTsOE84ZpiuRcaKzwDn3b8fSwQyvYXC85DQFnDbbtCGd9odaoCu0eI7z69Nu8ev2GdrXgjFqkFLLSzONEHnZo6zBtU3mr1aWOIlUdKKUQY8R4TyziSC9ZHhxiDBeHt0DC5YZMCujKZbT9guXr17i2rsBq0wlUIGwFo9dUogyMhwPD/QfSNJJCZJ6jMBmralQb4UIqRc1gNyxv1tx88intckU+u5MLYg5JAYyVaaYSd7vyPfGwJ+2fRCNpPFqZekygrZd1ephl5W8tJc5gG3Fmn57lNX0raJ4cP94ExVKPsqIznI9H0ukkk+iqzUxhku9VXdjnxCfbNmAdIQQIs3BbixIWZhaNaVEKZa3oL5UmjgOpFNbf+jbdomW4v5dpodbE4xHd+Lrqrs1hoaKlEto0mKav56oA5sLuxNQUpGk828qJ44mUkrjL57kappCHCKPBWLlGQqRZr0nzSMmJbCPGyTVwhv9npJne3N2yffjAeEw4lSk5EVKQSyWfjVRCQbCNw7UNeU7SAKdyMV6hMk3fY4yFBKkirVQj8gCZUIMphWIljlU3jqZGd6Y8gsqkUaafpqnT6ZxRxlHmRFKFVDTTaaTpxZQWx+liHDNauMcFcJ1ILOb9gVI+p1n2aN/INHWaq97UkcOLRvRntb771Z4pJv6lf+1vfdOH8lIv9VL/EfX1s+ZjovO6on4ghFC5l4o0ZxorN9DtdsJ7zXrVEFIhhCg6zlOm76zEze1mnINXdz05Kx6fJiBzdeXp+obTWNhuB3IMeCPN7e2rBU0rmroUk2CjFDivZUIS4f7+yPZpDyi6Rcvrmx7nDPf3J47HiUXnaPuG7XYkx8ibtxtOQ0CRWC5bYqSagjKoyHLdEuZ4cfiHOWK0YhoT1mqUEWc+yrB7Hmi9xrcN0zhjvUcr0dRRsTppFni48wu+9Su/wOr6RiISa2NUCqQUCOMoGkEtXFDtXZ2GSRa6gL+FCzoPJ2nCdAGimHViFAxQTayRPbIYlEw1nemmwS9X9JsrQQ9V5tNl9qOVXB7nqEcgxsiw3TE83qOyMBtjiJc0m5QyOUeccmJqyQXXtCxub1i9usM2om01RqZ/JQTRJ1gjjan1KNeANqRTbUK1lvOnZHUnvbitTn9ZmwsWKqGbhSTijAPF96JrzJFzEpI01OXC1izzzLh7lslXNWCVmDnPbHLJEJPkY5aKFHKeaRjI44jVFTGVM9qIPCON4aP5ScF4OJK1YvnpZzRNw/T8KNNupZj2e2Gm1mhK8drUz0uBaVps28lkOopkQTtPqavnc5JRRRiQ40SMsWpU5TrgPGGnyJ8XiOOIazwY+ZwVFus7oFByFEpBJQgorVDKcvXJp2xtw+H9BxgmUo6S3lQvGIWA/p13xNNEKvU/GY3RmpwC7aKjaYVhGmOiZJkuC3u26oLPAFcNyjma6xtUgkKCrITuUMTtro2R7YASXi4oijWE04h3orkVppzIOJT9+CCizqB/NLZvaVYrrNESbZpkol+QiWw5R9e+1M9M/doPnjhNkf/R//XvEfPLRPulXuqPc33tRrRrJbc6hYTRYl5Kpcgkz2qmIOvZprX4RmIHVakxnbmim2pG/bK3rNcNU8iX7PmrqxbnHPtjZFcbxbbRtJ1lvenwjfADwxwv8aDWSszjNGceP+x53p7ECNU33Fx3WGd5fDwxToFF7/HecjxOtK1l6XtZsduCbxrmOVXUjMZQRFsZE1YDOTOGSJwlfrBpHUaXi95znmeaxoB2hAjaiTMeoylK0nbCNFFS4frNW169+4RmucA6LwkzKZGzIo4T4XiSqZAxMlETbhOqFNIcxOxkLJCZ54mIsFlVyagCIUZZ0eoi3MtSMTYpUShY5zBdS7fZ0CxWXCIXrZhR1BkTpYw0obXJmceZ8eGDpMzUVXSqiTznVKiYAjlnjDY1DrSj32zoN9cybYRL7OR5eop1KC/nQbmWgiYdd5R5ENnBmYlZeZel1KljyZdmHG0x7UKa2RTBd6L9jHOFossU+eLyr7zKeXcQ9FDVYZ5B6ijBlKGEs0plqxbnifMEYcJZW+MnJdtd2Zozb2J9sChM+wNzzqw/+4xuuSDs90ItcI44z5dGrtQpr0KmkVprnG/FlFVjJ0uYoTahwnPNH9O1SiLHmRhE/1hyqgEHgtsq+Xyt1vOeRcObpxljZOJOPeZzk66MrkSCUs+D4+rdJ0z7PfvnR1rvL+9TmFwa17UyAS8ZiqCTlJIHINc20vwqRaqGKeM7AeCPEyiNbmT6XpSSJnR9vj6h5Jk8jlXdYuq1INcBuaC9IWaYdlsMMk0l1dhYU5vqUqopS66jkjN2scAve/mKlC5fgzGUacRYh7a/m6P5Un9862/95gf+l//2P+Lh8CcrJeqlXupntb52I5qrU9rU7WhBkDwhFEKMNF7jnK+cSHFJz3PCWoVrHOOYSLlwtfY4bzgOiXlOtI1mvZI1peS8z+QUaVrDZtPSL3y9oRbinMjVPWzqBPZ0Sjw/DxyPIznDctVw+2qBtZanx4EYIqtlS0ExnCZ5Pddw3I90jabpGk6HGdmuCqLIGDFmUaTZyikTUsEYQ+MUSsk/h5jJJaG1ISW5KeaiUGHGOI9pGsZhZD5NtG3H3Xc+ZfPmjTipq/tcoicVaZqq/k1X93gUzZs25Gkmz0FYjs6jrSFMI6lkXOOlWaWIOUNJAyLSRGnAckrkmNHO4pcr2qsriak0jqI0ysIZXXRp/OJcJ6QyuRufHwmH/YWHmYtMpurgT5pcK/pC13i6zYr++hrXyhT0HGt5piSpgvBPjUEZB8aTQqSEAUWpJqnaOuYkU0Hp1Grzw6VJ1m0nJIdcXfspCurnbOY5N9Yl17XrwLzfEacg7WnVgOY4o7QVHSVKpnVKY/qeRGE+nlDziKnaz6K4sDJLKmLmQhPniTTPZGfp+462EYh7DhHTtrJK1md9bKEomagWJTxN573wUbURB/g8ygkLk0xba+qU4mzAGcUkpJRMd7XgnyhQYkHXaF2ZItbErBBR3RLjO5nG18m30rWJq53xObcdYzg+PDDvdnjnP0aUKjDeYZtGfl5SqhiqEaUkMtR1Db5tKCES54mcE02/vExuL1KDeh0p5/DLNabt5CFtCuQ4izxFG5l6xyjbBqXQ3jOHwPS8q0EJEmt7vubUeQI/B1nxR9kouOUCv1iiKrlBnnEkiesc26qd/bgleKk/1vX3vv/I3/3tB/76P/rqpQl9qZf6Gaqv3YgaXZgS6ALWaZluHme0hn7hyalczBCHkzQEfWdJCQ7HgNFwvWlxznI4BqYpsVpa+oVA7g+7mXGKKDJtY9hctfSLBl3TksIksHbrZBUvkZ+Rx8eR8TRRSmFz1XF7tyAmxVfvD5SUWK565pAI00zXCZ90PIy0jSamQh4kgtG586nQaKWIQRzVYY5oa1ksPdNhFEexd0zjLHJFXd3LyAY3TgHftpimZRpH0py4fvWKmzdvWFxfi8O7unlTSZQiXMbzehutZaVYDSt5mgX6jcK2LcpZyQY3GqscKgv0PGlz7ozqzd3KNDaL49gte7rNNe3mSliNnGMsBZR+yUHM8eKYn48T8+FAGk/kIOk1BdF95pyIP4aPKhWG3/Qt69d3tKsV1suaXRl3aUYL9fvUvHKsNKFxHCqD08qUL8pECy1EgJLPeebSKJQkGk9tHcRARniWAmyXv3NZ84pTiRRnpuOBNE7kOVwa6HNDq84cU6g6T4ddLIkpEYcjKswyBUyFourk8NzwpUyMkXkcmE4ji7tbuttbmMUslqaKmVKgnRhoUk2NOuOKtFIY30pcqLa1sRwkPcq5y7lEmaoFzsTahCrETQ81Sat+JlmLhCWnhOuX8tmXIt/Hy3Fc8t9tZUNq89EIVeNbT9st+x/+NoQJ37TEGCUm3gqZQVWuqpjlCqooCgnfd6LVzJkwz+JIbyp+q7r/xTSXxRgE2EZ+fsjlYpwiy4OUdoLpyrlSD7zE6Z4en3Hoek4CRospS9cmOqeIclauwTGivKZZrSBluRY0F9c9QXSn2nsxLaWXxJ0/zvX9Dwf+jb/xPb7/4cBvfzh804fzUi/1Ur/H+tqN6GkULqT1milkpjHStQbjZQ3ttOiwDgdx0C8XjmEuzGNi0VkWS1lbP29nUkosFpZ+6RiHzP4wM82yBrdWsd40dJ2rIPfCPEtjIfGfMrgbxsz2aeR0HCnA3e2K9aZhDvD5Fzu6Bq5vFkyz5Jz3i0bWvimxWHjmOcqkqKKUclFoCs6I1jHlQhhn+kW98Y0DXe/BOKZhwllDUmeBnJLJWs50vSemzP7hEWM8d599xvWrV/i+wzgvN9fawNEuGB8eUUEasBLkzxVKdJSpkNKEdgbbthQlCTdKS9ObS7443HMGXaom0BgwSvLMgWa1or95hesXNVM8UyruR1UnPjU3HaTBGvd7jvf3aGswVgDuIFGWcZwIcwAkWadEmQb26yWbt29p+qVMoqz/uF6/JAxR9aiAaynKEocDKgW0dXI8VdeJVqg6fWMeaga4kqmbb9Eqk+dJmtVGyAayDubja9RmO4WZeThVDmZdYSuF8baaeRSm7aqrXr6PWa6Z54kyDaiUJCUsF2kMz7GqdaIdQqiMzJnu1WtW795BmolVn5pjopR0MT9pBVnrap4ROYP2cr7kM7HVhFN1kFXGAWLwohRiGKWRVeqyquccB1rX4NoYTONR80yJMxknqULOV81xuEgzSv3/WpvLul0pOD49c/jiB+TTiDUClk9FtLm2aURGglzXOZ4TvWZc34qJMETCcIJccF1Xp6kiMSlZHrhUlXeYpsV2HZApqVDmmbPMWSkFSbYiKQaM9xStJAEqFZQpxFARVbZKKoxIG1QuYI2gzJRicXsrGu5KUjjH1pYi1xfIw65KhTy/NKJ/HOswBv6H/5e/x2EMLw3oS73Uz3B9/ax5U0Br9seANbBeekJWnE4TnVeEWDgeZzZrR7/oOJwSKSU2a0vXOeZQ2O1nck5cbTx97znsA/t9IBWwWrhzV1ctfe8u6S/zJCYE52VlWLLidEzc3x84nSast9zd9ixXDcdj5OHxhDWF29sV45QZTyNd50lZYXShaz1zSDjnGOeI94oYZDqYcyIXTckS9bdcN0ynGUri+nbDMEpUoG8FmaStkajOJJq3tlswjCMPX9xz+/YT3vzCd1heXeG8r0YMgY/nIuD47voVpl3w9Fu/TnPWsJXqAM6FlGViZBc9xVjCqYLZFVX3J4xKQfFoitEYa8kpEucZZSzt5prFqzuZpp4z1ZFjwVhpdGK8aANzhuPjI/PxgNZ1ipnh3ISGk4DxVcUkqaIw3tBdb7h69w7XdHVS1aB8K81jDJc1bymgrLjZY4Y0bNFV9ydO8Rohamruu9aUOEkaUsmiUV6sMFpTYsC0C9G3ZjEzFaXF2FKbNkomTgPhdBCDT0rifE9JjClw0UTKu8woo9HtgjCPEGb0eSqWJZUqw0eNppEo2zAMpJRYvr5l+eoWciJNY8VriTziDN6XFCFBPaUURWrSNGjTyOdTp8IopJlHGsyScp101ghVSg02OBuUcv0+ogvOIWC7Ht02mMaTxxFtm2oQqufaGgpGTFm6Tni1GJyUNpyennj67d+G2rynXNAkrDPoSiHISWQ3pQL85zBjvME1jZz/YYSU8csFtu2qyUzOdw6RGBOojF/1uM1GMGU5Q4yXofb574qWN6GNJWUYt1tUSrJCz7lySKVJFglJQWWZGIfjSMqJ/u4GbS25os1Klqm0mLkiOaTK0pUHUrdc/F5+p77UH3KVUvgX/3f/H2LKfPn8QjR4qZf6Wa+vrxHFMJ5mFp3Gecf+IGv0RWcZKrT+zV2HcQ3Ph0gOgUWn6HrPNMPhEHEGNtctxlpOp8x2J1/nDBhruL1p6TonhoYkmfQUcc3HIClGh2Pk/fsjYQ60reP6qmO96ZmC4v2HZ4yGN2+vOB5nhmFktW6JIeO84IrmacYaxfE4sVx3aApWa8ZppiANtVWJxaLhuBtQunB1d81xN2FtET1ajTVMuaAIWGexzvP0+EycEr/05/7jXL95jetatKnrwNqEKuvob17hFyuUMqzu3jCfjgyf/xDvXJ2Yxqpj0/h1L+fitMUZxzwlQpzxjbtM/CTxSKG9NF85CL6nf/WGxeu3oiFN0kioUuRG72RdfonHVI4cI6fne6b9VpqzuqotWlOUYtju0aVcGKFaa/zC019fs3j7ThiUYZQmtGll/R/nigOS41Rao31LmCdyEAi+OJiNyANykXV9TqIWSEEmeTGQisJd3aERx7hqO6plWiQJIdYGStd/D8RxZB4OMhUrRdbgzhPGnUwObZYm3VZIvnEU3zINp4oO1WAVjAGclf+ehPKglCZME+F0wljL8pM3OFVkUDpPF04pCmwrcPeSkqQiFUgh4FqL63q08TKZtQ5FbcTO+slcyHFCGQ8Z4jDIQ4DRxGmCjDTxqpDDRLu5rW7xLHrbnBF3+ApqU0uF5WtnRQ9pqVpdA0V0nsenB56+/ztQEqlm1MuUUB4cbWMBzVz5scaK8ci1Ft+0WCs8TmMMqmswXSvNv9aXSTJakWLAto5mc4PStrJd5TozxkrjWqUz4XiSBwVrmR6fYZpRtj5EWEuJEe1tlTsoYZ7OQa5ZMv5qSdN3lDiRY4AkZkuRxajKUq2YqxoCcdrvfyq/bF/qD17/7b/wN7jfjexfIjlf6qV+burrR4bkwN11wxQVD08jjSu0rWO/n7FW8eb1gmEs3L8/YHTh5qqhXzYMQ+F0mrEms143OGc5HSO7QyDGROsVxmqub1q63ss9MkgqitZgbcUOGcM0w1dfbhnnIDGfq4blqq7jf/SE0fDJt655fhyI08xq3TGNEd+6GjUok7lhnGlbR5hn2sZxGiaMNUxjovGatu/YPu7pGodpHE/3e66uF4RQIdfWEmPBqHJxtX/5vd9hub7mz/yn/5P0VxtxideUmSKpl+huweLmTgZOp4OsqrsFm3efEvZ70mGPqVMy7S226xhPA+E0SH55GiRPXiumcYSi0FpjvEcZpClRCr9esXr1hmZ1JZ9dFISWYHyUrF0rDPzCn5xnjvfvCce9vCcjzafKhTTNDMdRXqoC7WWK5+mvrljevREDyTRKI1Ud8gLQP7vkS42SNBw/fMG0u6fbvMKur2vjKLB8NLJiV5oST1BES5iVpbl5I5PLFCWJqU4Cz2vsyhOTVXbOxNOB+bCXtWup8bTOkWKqxm4toQApYoyWvPJuwXw4QghiptKaPIVLE11yrpNiS4oz82kAbVn/wi+iU0TVc1zmiaIMZY6YxqIQGD4xUZAGyTUGv1xUPS+o1ovbvKKZLhqMOEqiUynE8UhK8kAjjvjzKbCE45HmaiNnO0qKUHp6xnYtzeYa7Rtx1E9TRYpl8iiTc6ys8pUCrOfweM/uhz/AWUXBV2xSEXe5Au1Eu5tCFE2z1oz7Adt4fLfAO1sZtprcSPpaiVmuuSJmqBxFZ2w7T//6LeriTlf1GqpTYM6IpiRSDaM57fekeZI425goRa4frRVGW7lOlBAsFGJCbJcdzWop101KlFANTabmzKcoE3AtkoEcIsfDkf399vfxq/WlflqVa1Lbf+//+Lf53vuXh4KXeqmft/rajehq3bHdR8bTyNVScDW7Q6BfONYrz+PTzH43CZpp5elXDYdjYjgFvC0sVy3GWU6HwGFIpCzpTKUUrq9kVa9QhDkxx4SzGmvUBdcyTpkP9wcUicZpNuuG9fWC45D46ot7+t5xd3fN9vGEptCve46nmb7zpGLkJoa4Yhsvb9s4y/NuwBnDPAS63tG0DfunA33nUNYzHgecb5jmiLUGR0MqYIwk4IQpcHh64tXrd3zrl/80zfrqkl1dEOxOUQa/uaLdSHKRJCdBqWk3RlvWb97wsN9SYhQdnfcMh6NMg7QCquO8QBpn0f85i/EOpWEeJ0pO9Le3bD77Ns57SgpUMV818MjriASgRmkaTxwnnn/4fUqaMc5VkaUmhyQr5JTQSFTnGZavXUOzXrO8vZM1eZhlCuokGpE4c3biq1KkcSqZ4cOXhN0zxncc33+Obntct/x4fGcG5jxAScTTHtoVzfUroMiav3IxlbG1yczViW5k+poi4XQkDkcx9sRZjE3eo7TCWoP2wiIlSYOFMWRjCLstKgYBzgPpNAD6Apov1VSmlKQYtbd3NNc3WA3xtMUsVqRpkvSilDBOmmxplqpbPsw0vcMt1tJFloLybeWFxnouEDd7yBTjUTlIE5qDcFNTEhSUVhhnySlg+05c9jlAkgQj07aYpkO7VprQOYASnafKGaUtSss0FSumo+PjAw/f+x5WFbLW8iDoNXmW47JedKwpJtIcMc4xjwOFQtN32EpqSHFGGyfyhBRrw21QSlBkKQSUgsXbd5imqzrlALGAa2QSPE7kFMkxYVrRjw6HA/PhiG9bMgrjpSFOU8LVn+0SBbifS4aUcYsev1xVAL48hGhvZRJeZRYpzOSUUSmQSyHMgePDlr776eedv9Q/vWLKjCHxv/9rv8lf+rs//KYP56Ve6qX+kOprN6Jfvh+AzGZpiEVx2k6sVo6uddzfj8xz4vbK0XSOrvdsdzPjkGkbWC092sgkdH8KzGO4aPHevu3pli0pFsYxEGPGOoWxsq5HG47HyPsv93KjKLBeN6yvFuwPgd32xM1Nh3OOx4cDzitc2/H8fGSzkqSePAdxU2soSrSH1lpiSmilmcbA5rojY3h+ONC1hpgFw9Qse+YpYo3hNEgTa5Cm4rQ/UpLi0z/1y9y+vqNZLLBOWIh5niEmtG9w6w1+sZGpYcmgDCoraAxFaQgjTdewfP2a04d7ppAYnz8IU9IorG+wzjKXmZwK5cw7NUbW/VphnGNx9wnLu9do68QlnPlo1tBaGtIKuseI23x4euJ4f085G6ZiFjB9zFUikVElkULEGINrO9CK5e0t/fU1WmnJoa/rUn4sSvQi8HOelDKnD5+TTnuM68gh4nzP+PAF+vWnGN/X1XWkTAPEWSbY3Zrm+rWs+MP4UT9KuWTOkxLl7JjPieHpkTTPGOukKTMavDTCOolzP5+5ojlRtGTTh+0WXUBXDFWOAeWtTDGN6ChFzhDJqUDX0ayusBTm/RajPfk0UrSkWClrxHVdM9HPRjVtNbZdkIsR0kTbyjQ3xo9TdERziTaQA2E8QSm4tpM/D4IowhhimCoYX3SSuW4QXOsxvkc3bZ0Axo8c15RFI+yq6aqyOYftlu0PfoDO1YimkZV/zKAVGn0x0k3DgFGyWicnFuslWss1aVtPseL0J8k1n+ZAzsJrTSHhOsfy03cY1wgJAqppKMF0qqNeKLM8ZCilSfNMOp5ou7bqlAsY0bb6zUIemrQmp0I4nMgx4ZYd1jlpcs+4LiXXgUpJHqLaTtYWShi9GM3wvKNb9vLc81J/ZBVT5sNu5G9/957/9V9+yYR/qZf6ea+v3Yg2ttC2lmHIpJLYrD2+cTxvZ2LMXK0di6U4ex8fZ6aYWHSazaYFNId9ZH8YCbNggJrW8vbtEussYRYX/lnL6Wy92SnNcR/48H7PMMyg4Oa6Y7Fs2T4PnE4T/aIBZTidJnxbcVG7gdXCM8fq1C4JY4QlmTHElKHMzCEzTYGbm55pykzjSNc5QhR0E9Yxz5G2rU55I5idaYgcng442/DJL3yH69d3NMvFxeGdK1RetR3t9S226+WGXABEj1a0NAKXXHLr6W9fMRwOHL/6ADnh+layz40lp4RxH5NstJI1cdEat1zQ397Rb27E2Z3E0S4r+FzX3ZUPaYy8RMrsP3zg+PCIdaIVTGNNGAJB7eQzmzJhvcUvWnCe/vqGbrmselPRkqqK+hEeZWUHKdHapRAYnz5Q5km4lcqgUpaVqNHMuyeaK4eiUIZjnYBF9GKDW19RopiGzk7uUidpRZc6XZZ1fYmR+bAlHA8Y1xBHkVxo7xGzlWB8yhwuWebKN6QQCfsjRmlpQlOShCWjq6ZCXwxNuURyyaimw6+vMQrCfivnSRU5JzHJhDXnCsmv7N2YsY3F9SuKktQn7X3VJooZqtT0LOqDQ8kSlamUkoayXgBaC/RdXOK2fr7IpLwaz7Rp0K6FmCspoMoykJW16EErDksZpt2O7Q9/B+KMbyxFKVIUNqgYeAw4wZ6VVDcC84zS0K1WGCufocg6uEwqyxmUlQs5hkorMPSffIJuu3psWabGdRWvlP7Ip+1btGsJ08i020lTWR8UcBL5q4wlT0EQX1Ym5TFnlLO4xUJOW4zy4IdIF7R35GHkvG3Qjcd3DUUp9l++xyLhU6qmkb3UH26VUvjHP9rycBj5H/+bf/+bPpyXeqmX+iOqr68R1ZrtThzzN9cdBcV2F6AUNmvHYtmQsuLpYSKmyGbpWK0bYoL9YeZ4mIjzjLWw3vRcX7coo5mnyDhEcac6g28M1hpCgu3TwPbpxDRJtvTrO2lcn54EVL9YNBQUMUSa1l2cu31nJV5SSzKMcVYmirEQTjN9byUDWxVBPE2BaZxpO3k9dV6FK41RQCriBkfYqfE0s9nccHP3muVmje97Qc5kSDlStMFfXdEsV5imvUDrz2vkkqqJJec6sYSUEsN2Szyd0Aps22CbVhqgXC6TzRwlyUgBOEez2rC4e02zWkOu+JzKxTxLAC6NoRaA/LzfM3x4z3zcYZTCGF3B74WUMyFEpnHCVRC6MQa/7GivNjTLNb5bSCNiraxzK5KImlFeoZiUUpgPe8JxCzFI81NZj6ZrKpxdUcLM/PwVxglcPc0zdrHCekeZjgK9t+7ydynV+5+CfJ84U+aJcBoIw/BRn1ubIgBTjyfHs0ShQNORUmLcH2i8u0SFKiUmsJKymMAq5L0ACSiuwfULdMnkaRTHdimQRfpRCjDJir2o+lkXaUL9cgXaoYpwKnFOJq4VpA7l8kBTYpC89lIE0ZTyRxarNpQYsM7JVDNXxpEGjUbpmgiUc30woTah6uM/5zq5RjPtnnn+0Q/Jw4hrXNXCKmn2szTxyhhyKaR5lmecEChIMpnWEv9rzvQBbQQ4nwpFayCDlXOpjcb2PcZZ0jigKsNVqRoKYAQXlsKMdg7rG8Yhcrx/EFmNVrLZyKnyeCENM4SAaR14RZojWEt3va4ylVh1pqJbVue4V6XQ3v4YlcAw7I7kKaK1fK9Uubov9YdXf+OfvGeOmf/pv/XSgL7US/1Jq6/diB73M+uVrQ2n5ngSSP1q4+kWnmkuPD5NlJS4vfZ0nScEeHoeORwmVMl0neX6pmWxEMTKPCbGIVIyeG/xrUFpzWlIPD+PPD8fIRdWq4blqiXGwvPzgNaK5bIlBGFqOm8kE94bXOuYxyCTMC0rR200MUMMYkZSKKxzaJM57Ee6zrJadTW1yVCUIxZFThGjNdp5Yob90zMWw5t3n7G5FQSMbdtL+lFRBr1Y4RcrccDDZQ1Izh/B4ef8bwFjMp1ODE+PDA/3lJAw3gt4POU6oSzkUKH557jCpqG7uqa/eYXtFtQuiAtIs8BlAlanYCkmhvtHpu0TaTqhVLkk5KR5JuXMPM2EEKVdsQZnDW7Rs7i+oV2vMbaBogTNZGz1kRTRHwrhX4w8YWbaPROPB0hR0ofqNNg0YjjJFVJPzsRhIJxO2KaXVCqjoUSUqTGXQImzZK6fzyuZMifieCKOo/QVpq6CK5KnFFBZAPzn1By0pmhDnAJpOEqYgVaSV6+lCSoUKkEJqmYwF+Qho+uwCtJ4okadVyqAQmEosTJZzwmk1VBm26667rM0m87UNC6kqaKgrJc2OQVSnCtXVk5BzlmMN1nOtwDy60MEyOepQOsW0zS12frJJkqp83RSrhVlLNPpwPbzH5HDjO0kIakUKElQYVos8mKymmasM4Q5kEvGeYtWSs67MdJ05iga0JREP5yyPOA5i12Im972rXyWuVQCgAHEfIfWpHEU17z3zPPM4f17dOXmljyL2SzG+kAniKZcJLwhhUCOie56TbteyTQdOQ5jDDEETNOIw945QTlVacC0OzI+bWU67ipJISte6g+n/vo/+pL7/ci//td/iynmb/pwXuqlXuobqK/diN7dNLjOM46ZMAcaB8uVxzrLbhs4ngJKFa6uHF3nGcbEdjszDjOGxGLVcnXd0fWOFDPTFJlniURsOo1vJCrxcAg8PRw5nWa0KmyuOxarhtMxMpwmuvMUNGasFWd3TonGG5x3nI6TZN73HqUkejOeXfgUjBWI/TgEVI60TU3yqU1bVrKmyyEI/1Nrtk87UiqsN1fc3N6xWK1Ek2ccylpSSJSmwW9uaDZXqBzJwxFlaxNVUmU+1pOZxbGeEwxPz5wePpAmibbURqGKFkOQ0qKnS8Is1UajrMF1C7rrW9rNRsDqcaoTubpmrck2505KKc08zRw+vGd6eqqxlBVZEwshS/zkHAJhDiitcM7h2wa/XNLf3NIul3XyqSUfvuazU9mkBS2rW+MI08j48IE8nSqRKZOLJFYZZ2tfns9zySrzLDVZyEsik9Io4+VzqQzRi7FIyReVnAjDiTRP0uRqZBUOsh4uGZWVxJHWqbIyhqIt8+lEmQXlJU2oJFSpurqlguhlvFmjXhW0yyXW+QsU/zxhVFYLqiululo/N7OiWTY16lQmyeYCcBegexGnv5JmLM2TJCop0ZmeV9QKXR3eTpqyeZYHiDlgWjH76aaVhrdKLFC6PpfUc1ApCSTRXQ6nA7svfkSeZ1zbCH90lkYSZ7DeobUixkRJBd+1zNMECpz3GKMwxmIa+cxSCKQwoo1FKzleVdfktvW4rsf4RvSz0yDmoOqKVmeN8TyjrUV3HWEYOb6/xwC268jTLJPTVONbtQGVRbaiZIqdppH2+oqm62SSrLVoZCkSaVuntmmcAIVddIA8EJ6eD6gMymtpwKvM4aV++vVXf+1z/tW/9psvcZwv9VJ/wuvrA+1bL+zQkmkbxXLVUpTi/n5gHgN9b1lvWry3bLcTD88jOQojdLXpuLru8N4SYmY4BnKWHPO21TSdBWV5fhp4uj8wTYG2c1zf9Git2e4mSiqsrxeEOYkBwVuBVStpQJSqLsspslz1oAwhJGKUKVcpsvrPRXHYHuk7jes7UoySCIMM0kpIOGvw3hJT5PmrZ5pmwdtPP+Pq5hpbXcDGy5o5pYRZruhuX2OdgTBJ0+BFF1py5MyclOYpApp5mDi+f08cTuQsmsdcYz21EU3aWX9nnOBkilK0mysW17f4xVpg5GEW7IyiAuNrE1pNUUVppmFk/9UXzPsdRlVDCLYm1Mi0ap4jMQScd7hWtKmLmxv6m1c17UeBtmLagdoUVswQCIPSOsJwYrj/kjKcxDQC57GgNBlRNI8YiyqS7BNiwvUL2tVG3vs5T/4sZTg3oblqJ0shhUA4HohR8sNlylxqulDVGV4aZdH5ad+QcpY40XmSaR1cYPjkQlGJM56gZC1YrCRrdKu1GKCq/EEMQtTttj5v1mu2OaiScG2L6XrhpJaPkz9qdGWJ4ccQQoocJsJwlIbVWYwTYL3SVjimyqCUIY+DOMVDIIcJ4yymX0tDeA4hqJ3+OXGp5HjBXCnrGA87dl99TopBkr+0Jowj00lMYaZ1KKMJUyDnjHae6TRR4oy1FgUYYyVdyTniHKp5ToxPWmu0UeSi8Msev1qi6uSYFCkh1ohcmUGThKahasJSnCLHr+5hnkXikuSzqaf5Eg0K1OmpY9gf6K5XNOulNKFBzm/RsglJk8TllpA/pjRNlqxg3B0xILGgqj7IlURKP0bVf6k/cP2d797z//h7P+I3vti+NKEv9VIv9fUb0aftjNWlRnMKu/PpWZJ+rq4alkuPNpqHh4H39wNaZRadY7Vq2Fy1aK2Yxsg0ZWIEbQqL3uKc6Nm2zxPbpyMhBFbrlqubnhQL+92IsZp+0XIcIjkn+t4T54QxmlQE+WR6xzRGVusFxmrGYSLGhKu8xaYxxAyH3YHVshHXfIw474gxVmmjwhmNdY7T4chwGLm+fcurt69ZXt9IHKPSmFZwLikW7M0N3e0rrNaU6UQ5x1SWLBrGM9+yNju5KMbtM8cvv4Q6MSuhahKj3PBKLqQojnljqz7RWZqrGzaffKeab4qsqnOdEtZGTxVDDvOF5Xl8fOb44UsxChlhYaoippgUZd0/DiPkQtt14n73DYvbaxZXt9IElyL6Um2qFrHaiAsyZdQajGfcb4nP9+RpqprGuj6usZUlJWKINf0ncfavt+s1zXItkatFNIuXc6hqU81Z7ypJPvOhAunPuei16SpRQhK01rX5l+ZPG3lwSSGgUsLUNKa61JbITVXqJJSLuTqGgPEN1pjL1O3CFK0rbEX52CTVxkjrgmt7TNNXw1MlF1CndrNA8fXZWZ4lASqOJ0ouaFcb0/O6siiI8nXKGJS12Ksb1HCijCd8v0L5psqBK7P1XHUFr85RoGhO+y37L34ApQhuTGtiCIQpUFLGOoN1VhBNOeO7jmG3J02BpvUXAxJaiTErREoMNUkqVei8oyiNbT3+alNX/oo4jUI4qA9O8sOUL1sD7VtiTBw/3EOIkuCkCyXUayDLQ9eZGHHWDMcQaK9XtJu1rPiVTEDPU3ymCbKY/lII0LbyC9C3TM/PYtpDtLiliGykFCT56aX+wPXDhyP/s//7r/F8mnm/Hb/pw3mpl3qpPyb1tRtRb2CxsCzXHYdj4OFxwnvNzXVD20niz+ef77jfTqx6Q982bK46FgvR6Y1jYpolncVaaFtN13kKhvv7E9unA5TM1fWC9ablNCSO+4HFuiUmxTAGDJn1pmO3lVi3RWuZDrNMXWLGNWJYiuMMKWOUYppmVpuemArH3YHNuiOKrwRrqwtdOawTvmROkecPj6Sk+OQ7v8j11Q2ubS6GDbwjK/ma9s0tzXojJ6hmx6ucRPt2mRbW6Q9QlGb/1ZdMuye5SWZFGkaJ3swyFzrrOl3rL9M223f0bz6lWdaJF4U8jTJR4jwF5KMjul3J+/jRjxg+fIVWstpXpYhedo6UhDRnKWO9xRTB9WjnWd+9ottciUmnSJQoRtKOSB/Xzmh3afCG+/fk407W8WeHfjXNoD5Ors4rdUqgeE9//RrrO2lrcq4JR3I+iyqgS20kPBTJlp93z+RJIOrq7JguEIcTcZowzgt26Qyy15qUhWtprQPbyWSsZEwpdSppqj60TtxyIsaJdrWuJhhfYzOjgP7POfbqEppKiRX5ZIysoJseULJid6289/lEnieUdWjXybo4J9I4MO8P8iBgzMc0rnkW0HvJpDFg2kbe3xkYrzRmuZHc9XOnruuPtRHIe0k1NlUr4dM+PfH8xe+IUc15dOMpJRFOcp26zqOVIowBbS2+bQjzhCLjuyqboKDKx2uohBnTNtKQa4WxApVX2uAWS1mlhyA29DP+qj546FI/e63QriXnwunpWSajrSfPM+k0oUyVQWhbmfjVGKVE/uFWK/qbDel0AC8PYioXSuUv5RQFcK8V2ik5185xetqhcsa1XmQ2WcgHRUMpCuu/vqfzpX53TSHxL/5v/z1Cyjwd52/6cF7qpV7qj1l97d+w642nX7acTjP3DzKlXK8sXe8YT4Evvjqy3Qc2C4dziuubjsVSfrFPU2auBt2uMzgn+rKYCvf3B7bPByiF1apltW4ZxsxuO7BetwynhNaF1otR6nCMzHNitW5JGayTtWNWljQn2tbJ+lfDdjex3PQoFHEcWKz6mjMvRqZYzlxEhfWOeRrZfXiiX1zx5tu/wGLZCfzcOunBSqEME/bqmv7VW2E6/phJSOVCHo/1Rn12scjkKM4zuy+/ZN7vgMw8B3RWOFdZolqadOVsdbELG9P1S9affIbrV+IyL7k6x1XVUYrDHyOaQ922xGni4Xu/xfz8KKYsLc2t0rpONOVrcxGDS9M3jLsjxWiu39zRrdZVt5elkTy77kudgJ33viWTYmR6fiCPJ4mSLFriSVXBnpujyqAEKDlQcsStV7Q3d2htKJPcnFTX1dMlfEyqseacvJSngWn7VBmn8l6KQQD240icAq5p6zRRDtE4RwyROE4iObASbgAFdQatKwPaSfMbxGSTFLSLBWU44foeiiLGcGnqhJkq30bW+wVFRmnwix7j24uGUTedNKFhkqmh9aimraaqRI6Bab+TWEpjsa1MNsPpiHbyz1hbtZ/nqXmijANaybS3xHihEJCTTABTriYypBF1nnE4sXv/OUaBdhbbi9lu3g7oAqYRo1wK8l61sYRxEvmq0dizySxLE2qdI+coxp7q3NKmOuxzxGiFqglOUGCOH/WaSYuGGNka2G5B0Y7j+wfyHLHaADKdxBhypRgYLSQJZS2lCPc2pczV1YpwOOHahpLK5fohy6RVpXL5mdTOopuW3YcHynHALToJCSgIeD/IP1tXTUsv9Xuq86T7v/G/+GvMMTPML1Pll3qpl/oPr6/diHYLz3438uFxggJXK8uid4xD5KsPA1OEm5XDWMOrVz1tb5nHSJiR9BOdaVqL99IEzqHw1Vd7ptMERbFataxXnhAyKSRe3fYMk2i4rHc4r0m1yVmsJIXmvFbNyM1OI7zE8TRzOM28ultim4ZpnFlsVhyHWTK/gblonHO4ErFty/FwYv+w4+7T7/Dq9Wus8RhrMNZKM6WVIKaub1m+/RSj7Uf8TQyU+eOTvqKAb1BZUDHD/sTj975LPB5QWhGTcEAxSHIRoK2qK18xX2Et/eu3LF69xRiB8JeSKdXUBNUhXtmaKI1uHMPzI8+//T3yPNN0YsIQCLxM2MI4V4MHKFMooTAPE+16yebtO/xiWYOVjKTboFAlXVbOZyxS0Ub4mxXNJLnqso7V/uOEtiTRdZZqNMo54dZr+us7Sk7kSZKLlHUCsjem5n4bMe/UZiKNJ8ane/Kc0EqhnabUhKBwGqRx8TItLvOI6RZopwnzTMoJ13aVbiAmI3HuG0pxYspPCaaZqDRJFbrbG3SYyd5RrL0kGdXRtnBOjZEVbr0KAdzyCtMvJO5UGzF25ZqwNYmBTTsnbnGtyWFi3j9jWsGZaWNAFfIcUbYRG5jWaA2UWB9wNHmY0NqivZcGLRdMI2vxYrw0wXE+D9jBNUzHA7sf/rasn4tGK0OKEeYJJgl30Od8eGvxvWXY7ek2azaffounL79g+/mXdE4ic23TSMKUMZdErqwNpqm/VsYZ23XCmjU14jTXKbVRlZqQ6jreo4zn+LQlDid816G1IhyPKGsrs1bXplKhrBZGaclMw5H1m1uIAePkuhEcVhJtrRYsV0yVJ1zAaM9wOBCHE84aiZGNIg+Ig5j/lJHjPpubXurrVUyZ/86/+u/z/fvDJdPipV7qpV7qP6q+diP6/CgGJK0Vt9eexcJyOkUeHgbGOdM1mrY13Nz0GK0YT4FxEs2dMdB0Hu9lZXsaEo/3skZ13rFaeZrWMk4SIekbg2sM85wxWvR7MSuGw1R1ZVzMMjKoUygtN5HjYUIbePvpBlDM40S/WJBTxnkn5mmj8VphVCFj2D48M59mvvVLf4br168+ZlWnVPmaGtX0LF/d0l5dI1OWWdrBEChxqsYk6jEpmAZSzhwen9h9+SV5HMWzo7Rk1Fd2ZyqpBsj4isxJqLZl8fqd5NLXZoc0wzxfdIYSca/gHHOJYv/Vlzx97zdw2sn61hrSPMvUsVRHuVayWtaKHAIpZha3V2xev8G4lupAEY1pzX8v6uP5lgbWEUJgenqAGFBFvoYkAHHOyUchUZR8fihhujY3t3SrK2nMQkD7BuWcrLSVkeYNpBE1IicIpx3Dwz1kZAJo6wQ4JsLxJEk+XS8T2jDj+g7lDSEEcpJULJUr+gck3rPa9UUKINrFDCQF3atXGAVZge3aj476IqazXMqlQSn1vCilcO0S0y8lwUcpVLuoLvCBMo+oprvEXWIUeTgxPD/ilutqUKva3SDaxlJUpTMY0ulImibssq8GPSOA+wqkxxhKCkJy0IY8D/KZadGThnHg+NXnkhVfCrpr0daQxllwUhUCH6YJ4y3aGMJxoF0u2Hz2LbTx3Lz7lBgzcbena894KFn5Z865CZVAkQK27aRRjoEyB3IINRjgbMwSHqkyGq0N82FPPB4knSwnkdj8GAkiRwkvyDFd0ErTcKJbL/GtfP7amMuaX2n53too0jSJ476V2OB5t2caBnzTQEhybNqQRkE/2cZhWoupx/9S//QaQ2IKif/Jv/n/5bc/HL7pw3mpl3qpn5H62o3o/dNA4zRXG0+/8AxD4nkreeKL1tC0hpvbHqXgeBSnaU4ZbaDpGqwVTuMUCu+/OpJzoW1b+t7Q9479ITGMEWs1q8ahsCgdWax6QpT/ppF4R60UuWRSKkxTxBhNmOXRe7n0NJ1jnjMpJbquJcVIjImQBb7trIUUGKbIaXek8Qv+1J/9FfrVUpAzla1JdUvrxZru7g7fL8gpcmZzlvEkN39r6+q6akJRxDmw/fxztl99JX4OLQlJgmCScxrmRCkJXbTgjLyl21yxePMpvu8BKDlSpvGyDleI8aKUaoJSkObI/ssvOD18wNmm5o8bZP+qGYeBkjLOWdnoG0UcI8paVm/vWL9+LevdnEBbWQeDpD5VLiRZmq+MIQwj8/MHiQ6tekGJRawXS87CDtUGpeVYtdG4foGrgP8SI6ZpwXtZK5/RB6iPPMo4M+93jIdtJQEUdGPAWHJMEt2qqCtraeJdI9nqWcmK1dX0qhxnUhR+Z6E68rVMwi4rbK3pb29RQDwd0V60p+cqSDONOWOWJBFIK3DNQpq5eUIpg/YtZCEylDCB96L1TIkChP2O+biXJtTWRK40i4EsZ7Qz0gRNE/E4kcZJpqRa4xcrMTmleGkEJaLzrMeVh5tiHcpY4jRyvH8v+taipJEj1qz6KnuYI7kaxUoqzONAs+hYf+s7aOMv0+C7Tz5h575k2u3x2temUSab2WiUlvhR23Qo78gxC1y+NvNn7mwcJrmmvMG0HQlFmGZs05DnQJomecA5r9gVkjdvFSklCpmiFP31mm69JoeIskYiWltX/W0JbY2Yw4apTlDl9aYp4JyT1we0dYRhIs7xotHVSpOHmTi/6Br//9U4J97vBv7Sr/6Q/9vf+cE3fTgv9VIv9TNWX3813yjWa0/fe46nxOEoqUreKZbrhsXCk3NhOGXm+QwUV3SdQ4aLmRgLp1MkZ0VMGWOg7axMOXJEK/BOog2HYa6RkXUdiq4IlkyuurecirBEi8JaxaJ32MZy2E84regWHcNpQilZq2stSUk5F7ZPe+bDxKs373jzrW/R1nQYlDivC4piLf7mFf31LUoVcpw5o31SmGQaqIXJmKszueTCfBzYffEjTk9P6JwqA1RupqK71MQg626tJUnKtp725hWL1++wbScr7ZwEP2MMpfyYAUUBRqIo58Oe/ZdfEI5HjHGCFWo0tsaChjrVdd7JTbkUcsm0mw3rTz7BLxYQBLmjrL+41Ms5IalC+DGWrBTzcc/8dC+TLW2hshl1NX6kcSbPk0gJara5bTx+ucI4TwkCntdtLw1dnThfXPFaCeR9mgjHA3kcsdqR0lyxSGIYyiHW3HYrf14h8VhDosjaGrjA2bNoTU0Fr0s3GMWUUgpZQ7feiEnndJTJcayoI5DzYsV5rhBzjARICddVaSvTbN+g1DlGNVLmCbREVpYwCirrsCOOA7brPzrwszTW0ljKqQiHHapIVGYp4vb2i4UkVNU8epS8tkg3Kis0g3INWhviNHB8eE/Y72V6q6ShzhU2f354yBcokkg1+usNq08+xdTm+SxJoMDy+paUFfNpECmv1iJdiAljQbu2yivkge4soTmjCOIomw3TinEooRn2e3lI0+qj615pYkwSFoESZi7CoE250K4XtJuN4LS0RmXQTstxaiXTUOfJx+GjEc4Zxt1JZAVaXd51jiKzca3QP0zjKTExjxPTafi9/2b9E1AxZf7BD574ra/2/IX/129804fzUi/1Uj+j9fWB9nc9Slued4FxCFCSGJY2DW3rCKEwTYl5jKSccU7T905Sj0LmdAykVAixEEISCH3TYazldJJs9LYV7eLpNMoNqIBvGjICrtcU4hwu0ZtKK1IoWAv9wlG0Yb8dMFajrGUaZ8HyUJmPCrmxDDMqad596xe4++QtzvsLa1RlRdEKu1jhNhvaxfKi/yslSSZ4SrU5MVU7mNDWEefE8f6e3Zc/JJwET6KoTUiGogpai8M/p4zRFmM1ftXTv35Hd3MnTUZ9zRKjNLfIewVqIyoaxeHhntP9V9IAaVX7U1vX7zCPMzll2vUSyDLBU4b+5obV3Rts20vD6yzY8xR0+ggKP/vBtSUVGJ8eyccdxtSYxSSrZLSlFEUYTlC5pOc1rPEe3/fC3wy1oWhblLLUXbtEmJ4NV0qA7vNuS44RoyVv/ce1sJQkDaH72JgAGGuYc0RlhVfSGJIEE6RdIw2fUtIgV6dRDAHTdXSrJUZr0iT800tKlBItI6iaPS/TU5Jkr39MS0o1LamRTPMYxFSGksY0TJSSxVQ1jti2q3KOIpPTGMQ4VQkIaRilie8FFWaixMZq4+rrUvPi7UcSAVquj4rzCmHkWPmxOaZqmxOjjlIZY2UaGoZRDE71oW9xc8Xq7SeCdcrpYzOeRcJgfMP1J58y7HeE/V7MSDlRcsL3y/reNKlikORD+ogZU7Wh106uq+H5WX6mvL9E1CprUEqjsyWPuWKskjjt0dhFR399JZ+pzqgsP5+5ZIyypGmSZK0kZjDjDNo4xv0JTZXdXH4WqzzGiT5ZW4u2hhhTRTe9CB1/vEop/Dv/4AuGKfK/+su//k0fzku91Ev9jNfXbkRTUuyeJ+YpiIu9s7IGbxzDIFGdMWUUhcYbuoXFN4acYRozMRWB2Q+BmCLXmw7vHadjIEa5KZYiMZy5KHLRGKPrP4u7OMQoU03zcQJjNXSdI2dFmCPWW7SxzHOsvUuFkJfMaT+QI1zd3HJ1fUO/XtZVscQ3Us0lbtHTbq6xziHjJTk2Qqi6uxoDGatuUmuO2z3br94zPj2iVXXAV7xMyglUvsDIQVKhbONxixXd7Su6W9GD5jBfGt0ztqeQKJhLwkuaJg7vv2LaPl40d6pOuLSRxnc6jcR5xnUt2ijCFIUP+uo1/ZWgmS4pP8ZVfWqoU7PzFFCDNYThxPz8SB5PcnOXN3X5u+RMiVWKUcolN90tevxyKQ1TAayVCdsldlRg7RREG6ogzSNhvyfP8yVZShzQdeoXcz03BqiGlZSwXY9fLnBacdpvmY9HrFK1mRftqXKGPEfKLFDzlCOm7+mub1AlCRIrlYvm9ieTUgXZlHMSY5xW2KaVFTmgm1Z0tTkBSbBL+tyEzuQUJHUoR7R3dUoqHM0c5bo6w91zCGjfCbooTpChWV2Loatef0qf9bTlYwyoUmJmMoZwOnL88AVhf0CjwOrLRFNVmYg0izIlFS5qpluvWby6wzr/MToUqMJsmewb0a32V1dMWjE8PlBixLUtdrGS93WZolaolNZVDyrud6U0scBpu0XngtZGmu96rkH00yUXOV8qSgynUrhFy+LNK8mQj5FsMuRYE6skrjPN9SGgck6V90z7IzkkVBY5Sw3Nkge4mqJWatRnTomY5HedW3a/t9+qP8f1b/3t3+E4Rf71f/e3vulDeamXeqmfk/rajejjsxgHvNf0C8tqKVGbp2NiHKSZ1EbRtJbFwuN8ncxQMFaRx8LxOFMovLpd4J3heJzExYoSrqACVVeq2nBZnVkUkYJtxJmbYiaGiHeKftGCUsyTaDeN86LvrI2EtoY4j5wOI1235vazd2xur7GXG0+FVyuFcg3t1RW+FSMHiMO3hCDNVZbpmsqlOoATCdg9PPP42z8gh5G2bdDaE1WqAHHBIEk/W1C24m2co3/1hq5mxas6RSRHJM5RifsjV/xMRTBN+z3D4wem7VZe3wgCx1qHNjIRm44n5tMJ23h0dcs3qzWL29f45bLOAgV6rowjh6lOu2qTc276tGba70j7Z9LphDnHTSZpvnXbVHd2EkapUsJqtBa33Ei0pXMXTaVSWvib1e1fYkA0oTLlTdOJeDpWfak4yOMsf0db9zEBqTbkJSVKCljvaVarmq8uMZ77918whYj3rTTWRpqMNIlUI1OwyxXd1QZdBBSfUyan2tgpmUxKTKdcCzKtUyKn8K2sipWSBlRpaeQLqBzr1E9TwkQOEzEEitYY5y/XUTlPCaFKJiQpTDdi8ik5QchY38pkPNVJ7pkYUb++fCRyQSnMxz27H/4OZDmP5IxWmqKK4Ly8pcRMnCbJWneWEgLNckV/e4fxrVzftXkkpdqcy9T3/PlpY3HOM2mN21zhu5omVkkJJNEWi1lNf6Q1aMjGc3i4R8eM8ZY0z7XpFM1pCjLd1LWRRIHyFuU93fU1vm3JKZLJMmit3NCSijS0nBObQLuG8XginkbBRaUkFInLtNwIzqkmkeWUCMNIyZFm0WKM+/38bv25qr/4qz/gt77c8//+R18yhhcU00u91Ev99OprN6KajPOKzVVL01hyVhwPgXlOhDmRSqGpaTBhzlQPBCnDNEWGYcY3htW6J86BaYo4WyeLyPpcKU3KMpHS1qHI6JJlYuoMsRompmlm0Wq6RUuIBa3BOicNZcqEEGXiowRin0Nmc/OGu3dv6VdLSQuCj5M2Z/HrDX65wrma1INozIjVOW8UNe9RAN4UYgjs7h84PD2iSxDwvdZkauN4vhNK14AxcsPzqyXt9SvRJGpT8UhcnOnnRCDhaQpbkpwZj0f2P/qBsCiNkWZV3B8SBVkK0+HIeDjgW191oQ6/XNPd3F7OkTJebPdaSzN4ZoYqU3mfEs057x4J22dpJuwZ9q7EMOZsnTAGchHTVSmyXvXrK3zTyPuwjo9xiYA6N+b1/VmHUopp90iZR2n8AW2trNzNeYpcH0xygiQyByj4rsctFpdYxqJFH7u8fsXD55+T4ki/WtYJepCHB6Vor65wi0V1Z4+UlMUdn0W3q4wYyC6NYlLoqg81jaCW0EaaeS1SiXOjqLw0m6VOQeM0ooytzvhSz/FZ2ynqzDiO0twbIw8UJYr/yzdyriuH6ZJolD82oDK6lenfdNyz/cH3yfOEtY5cUn2IkXOqnL005LpeDxTwi5VcI74RWUHFb6lcLucaJetytGhu8zSRU6S9vpHzEROqEhpAMuTrM8NZWi2wtabh+OEBlSpyq74HXWUFOQq2LRdVpSxJGnGraNYrnPekaah/rutrFPIcOGfWqwJKniMJ80w8nqgI1pqQpSSBy0lilmhaFSXV7z/PaG+FxhDy1/01+XNZf+lXf8j/6d/9Ls+nF9PWS73US/306+snK1nF5rql7T3TKXM6zYxjZJqCIJGsTCVjzLhVgWyZZtjuZg77kbZ3NI1nOI54b9FWbqqybhQ3a0oyyTT1xh5LRmRsihAksSWHmc3KY70nnidLRf6XoqxFu75nmiZOzwdy0rz57FvcvnlN2zUYY2T9CqLFc47+7jXtciOw8Gr4KNNIjrOs0y8TvFgz32E8nNh/uGc6HNAkjG/IRdbTF4ZmzueeA2MMyhqam1vWbz/BWIdEQ8aaP37W+WVJZ9IalMgMUoH9lz8inHYoErpxVVsoX2O9o5REHAMpRHzbYb2lKINfrljc3slNPpdqSqomoxgvHYK2NcITiHNgPu7IwxFVU4eEpaqFImA/JtpQzU85R4z3NMsVtrq1qSYcaV4UynqZLMdJTn79fk8/+B22P/w+i6s1i5tXwrKsXEfdNNIop5mclWhQtTSlrl3iquEHqAgpkQu4tmP1+i2PP/gdrNP4VnLmcZZuUY1T0ySRn3CBy0sjKBM4rao+FYCEVgXbrmT6qUQ6URTSuMUZZRxYTz5rPosijIM0dEb0xCpnMgXjNKqax9Iwoo29MDxLCqisMa6R81ivJeoK/senodTzrLVhPp14+v73UDljvRN3/Blyj5jkSsrE04hfdOS61rdtK5NQ62qsZalPkYli1OX6V2dtMIo8jcThCFYSqUqKcl2mqqfOpTbekCUNQq6FxrP78j0lJZqFJE8J11NXPae495U16JjJIcrreUO72eCcFwwZ9fXrA2epca3KucsmRhnLPI2cnrboVGpirDxk5STn0lYtKiGSdW1Cg+C3XNMIOcP6r/0L9eep/s737vkLf/U3eDxM7IYXhNVLvdRL/eHU125EX93JDf90jAzHyDBGxilURJOmhELTGjZrR9tapqmw3U7sDyPLVYN3hjBHus5L8o6xtZHJ1dUsJMIYE7qOeoqCMWS8t4SkmA8nXr9eEjHMQViBuYC3AlfXFrzvOOyPHB6fWa7vePvtb7NcLXCNx3QtKktsYsZgF0v6uzeyUixISlHIohWM4dIoUZA4TQ1Yw+H+gefPvyCGmVwy1rjqUI9oY6VZKALe1kY0rbpt6d+8Yfn6LUYbSKJTxDpx6KcKx69YIeUE8B1T5v7X/wHpuMN50XIqJRioFCa0VqicZYWtDe1ywXwayMqwenVLd3VdwdxWJlqVfVniVJuZuvqsmsN5GJl3T4IcChHqKlm4lV5iP5VMbSWTW/SaznqZguaqCXSuTiAzWDmPJQsqCQDtyKXw8Ju/wfH9l2itOT494foFTb+o61NbJ2SBeBqkqapRnG6xqJ9b1XPWJgqQhts5FouecH3FYfss5AInjbKiUKZBmpzauOQUpVn/sTz4XPWTlIDWFrfYgDLixrZOGuA4k+ZReKi+rQ8HYuqZD3uKqRrllGoDJRQB5QURlI+zxGFaK42S1miyRG+62gDlREF/9MyUHzPQlCKs1fHA4eEDpjrPC2C8g4uaQVx7YRwx3knMbYy41rG4vsb5RqQFyINf7Q6lCdViJFNa0qRKmonjUT4jIBOwTVOntPXhSgNOVz+aohApbcvu/pE8BpruHJZwka5efta0lQlwVme+a6ZbL2naKhlQZ01xPTYtpADddLJdcBZSIio4Pe5QNTO+FEWMqeKxLNboKjVJwm2NiXgayDHgV8sacUsVyf7Jqffbgf/u/+FvMsfMcYrf9OG81Eu91M95fe1G1FgBzh+PkdNp5nCYSCnReIczGt8aNiuL7zzHY2b7dGKaIte3okmMqdB0HlUKvm2JQcwc8ywoFlsjKqUhzRQ0KSuatuGwP6GBd+82jFMmxkDT+tqESXym1oCx7J+eef6w45M/9Su8+/a3cGf3rbaQZJ1eUPirGxZ3ws+Uu7aFMApup2SZbuUIqWr3nCVby9MPvs/+qw81DjBjjDhzU2VlQl1fK1Xv36L5W332GYvb12hdTUHnW28KlDTL96cikYzcZMfjkaff/g3S6UDJEjGqrcC+cxKDBxRCiGIOz5k4HFHOc/3t7+C9q+vxRlb8QrUXB3ed9Cnrq2HJMh8PhP0zJU7kENHGoaoZS3tXJ18ByY9XMr0D/GqN8x7mSe7bXc8FwGnOzbzwJcV0ZMgx8uWv/0Pm5yd80wpqKAaev/yCzas7fL8CJFEpxVQB9w4oIqHoevl8CoIgirNoQRXQNORpoMTA1Zu3mMYx7nesVleSOz+dyOMgZrAYyUWYlEUZkQZUiQcoSpgl2Wu1oWgD8yh55UpDGAXKrh0oK1GmdRc9PT+irMP6VgxoOaNQstavMPZ4OMp1UhOhKFW+YTv5nEu5gNZJtSGoeC2gPjwo4jxxeHyQY0rpgqfKSbLoyYWUM9N4wC/aCxbNec/y5hXOd1xiW8+rfnE/yTmtJiy5ZgpxtyccT6hcSDnRvHolUpcQRWKgEM0lCuWE1aqUZTieUDHKA1Uugs867+4rKeKshSbLhkQZjd+s6K9vyPNYfzZbChmtSn0vEZRFUUjHk8gEvOPwo/fk04SxRkxvZ4WNM5jWojmzV4scewxi8Gs91jo5B879iUgHyqWQc+G//i//VUqBkP5kyxFe6qVe6o+uvnYjGrPisJ84HSdOp0CKiaaxtK1hsbCs1p6UDbttYvd0wDjN2082TKM0SdYouZlpwzxOFBQhRI6nQNO15FyIQZzusWi0UnSt57A90DeG61drhrGaQVxDDOJedlaDtcQQ2H71FXHW/NKf/U/w6lufoOsNTVapmjwFktYsP/0W7eZGnN81HYbpKBpFkJtjLsKRBFCakDVf/tqvMTw9Yo2YU7Q2KEpNdZKJSwHQBWcE/WM2a66//Qs0y03Vm1bovfEw7IECthpYqqkHZdh/+MDhi9+pvExR0uo6DRQMU031ofYNORPnyDhO+B7CeMT3b6t5p653w0wO44VNqpyTSZwS53PcP9co+QKIRlJXgxI1ilFQVBLDmlPCtQ2uYpRKyqh+IRPQnFGmkQaq0gOwYlYaD3s+/JNfJx5P2K670ACMcQyHkeN2J5Gc1fyktKB3lNHy/bpOXleLOavkLOladXWchwMlzJh2ARRa32CWK1TJYobKCbNYkkK6YJrkOskoqz6a13LCNQ1usZLJ6TiIxAD1sSlybeWpSupUJjPtnqQRszKZM9YJJ7TyWdOUSNMgAQddU/s/0UNqX9fxua6ISyHHUjWpH6NTq/2dGGcOjx9AKebjkZIy1lqMlu2CfM6adDphnalmnYzrPMtXd7h+KXIHiSj7+BkL9kHMR+cmNSfScGTe74hTQGtFc3OFVoo4jkIKQFKbBBwvn3vOmWF3ZD6e5IFFicZaAhTqNX9GhikgixkxpUC3XrK6vSXPFSumqhlKFYqyqJwE8UUhbHeE4USz2XB83BH30pTGlOQhwEtkr9JGpqgFCjLVTWEkh4RpGvxyJe/ZGNHq8vMb8TlXTN5/61/56+zHl/X7S73US/3R19dPVvpqz7HqQnPKdJ2naw2LhaNbNORi2O8mtts9601H17XsdhNN6zCqVC2hxgDWe1JKpBBYbzrGKREiog0tBec0VhuO+xPLpadfLZnnWAHckgCkjaZgSWTSNLL9sGWxuePT73ybfrmQxJdUwKrLfU51Pes372iursUJr+W4yjTAPCNO21w1bdKEKiPHcf/d7zIPB4x1wl9EVyfxGatU6jpeSxNqDM3mius/9adwbUcJQaZOZ3ZkkCmoUrKeR9cJWMocvvqS4cMX6Ay5Tuhc2wKqpsNAnMQ4YKwRaHgB5Ruub64puTA8POCv72jbXlaP8yyIG6VRTSu6TyNxlaeHD6TTgWq65jwZs41HWS3T0RoZWlKq0aAB13XYppOpWYFinayTYxKeZpqrGSZWp7fm+PTI+1//x+icaRYLaXjK+fsW+n7BaXdAac3i6gpjhVGqtKJZLbBtj6yNzWVyBkq0gbYhHXcQAtq3wu08HZm3T+ScyXbGLRYo50nzSCkyfRPkkZJ1uQKVxVRjm1amldpQ5igTWGMocZS1vO1q8yRmoRwj4+5JPlNjSajahEYuHqNQ06B8S9GaFCV21RgrkH91lk7Urzm/v2rqkgeeLE31PHP48J40jRRlRfucFTEkrC3yM6AksaiUjHaalCLGOvqrW1y3rpPWUmUayPdHmlHJWK+mqFzI08i0fSYOE27R49YrOR9ZrnvTNhJ9mvOlaS6xMBwnDvePeGspyqKtrMFRmjLNoMWBX5RIdHJMpHnGLVsWr9+SQxISRoEUI6ZxFVumahhAIZyOTLsd1luOuwPDw5amlZjaUlJd+Z+bWAWROnGuE/E4Y5zHr1YoVd9z/QxK+vlcT++HwP/g//yr/Prn22/6UF7qpV7qT3B97UZ0fxyZZ8nU7hcNXWdYLj2+a5gm2G8PTNPM9e0Kaw3H40jTNZSYUFZTitzgxpBpW3HWK+cY5ySTIJUwpWCsIFTinFgsPW3fEpOs4EIsCIPTYowmzjPj7sA8Rt79wq9w99knNG0rN9VQETrakAC3XNG/eiMNQPyYn17CRJlrQlIush4shWIsaQ7s3n/B7sv35JzwTVtXuDKh/IhBMjIdy+C8w3Qt3atXrO/eYZpGmtCqs5Po0Igiy1qwGi5KisRp4vDhPePjPRppQFXJuKahUMizrJ9FvieZ8bmuXa1vafteVulGo03D8OFLnG9QMVSepr6kJymtiNPE9PxEGgdZ2wO4epNXCu0l+cj4RqQJOYu+NiV81+L7JUoJE7PkVAHiEeU6Mb2kCv/XipID+4dHHr//fbRS+LaTm3wdOudUUT2Ac579/QPW/f/ae5Nea/Itvev376LZzenePpt7DSVLfCZmiK/AhC/AFMEAmDBAWEgIYUa2hC2LppCwMRjZKsvgqls3m5uZb3u63UXEv2OwVuyTZbDIqrpVWU0s6eqmMt/37L0jYp944llPEyRZwAf6q2s5lj8Ot9e1vLEe4wzluMOUgunX0kN/OjA9PmCsxzdGsj6dyAKeJJaSCGC1ax1mn1iLa3tgBquFgsVW1fX6Rs+FgLiSEtPuXiKTQkvOBec9VGlAst5hslGTjACoUgpMJ/ABu1kDc5OYChPVjCSpAUYBuchX4jRwvL2lZJFplDyABhHkKeKcpBaUXBSEeuIwEpqWzbMXtNtr/fycmXU5EdI7z5wXq8coHffEuztKhbBZEzZrCbKfxEQopjIxfM3sKtUwniaOt/c4LEHZ75LiGcDWUoRJV9c6VUQrzeWGzcsXGpUm8Wl5muRhNGVsq/KIIhKHeDhim4ZYCoePH2m7VmKqDML4ahObtR5Tirj+s2QT11qwxhDWa3mwi9NTJFZFAP1foXk4TnzcDfyX//MfLCB0mWWW+dnnJ/+GnaaMd4629fS9ZIUaH9jvM8fdEecNz19eSLvSOOGDJw6T5BimIiREqvjgmMaJUqSeszUSd2SrwXtHQRzyXeepWM0XrcIYmipywJiYjpHT/oR3LV/+zu9w+eqlZFbO5hUnukealm57QXt5LaxLLeo6LsJ41Cr1jHNYuROd4HQ4cv/9dxwfHkQ2Zx0FMV7IzdLgnCU0XsPAK7VzuLbj4osvWF3dKBCI500qGoaOMxg0yscYShwZ9weOt5/Ihz0YaaWhiou71iLrR2tlnWwAKlUd/dZamr6V9+ncOX80Hw4c3n1Pf3UjqYra515rZXp84PR4h5kD4vXvmjlaKHiwHlMTGDHupOMBUqLpW0Lo1CwiaHI+BgTNv8wis8B7cprYfXjP/u07grNYJ9WOc1j9rJctCOjxbUvnLIeHe9bPXrC6vpFzNzvwlUKtVZhHYx1l2FOL9NeXNJGmgUrF970Yi5wVQJOisn2OMofvG1QXOtexBmF0ndOuc1nlGh/OTnmJ15JzWvMoEVCmSjC6ghfBqWJaM1WuOevknKU4ARUbAmF9KTpMvc5qKQo4rYJuvYBqhmopaeJ4dy8d6Jo/CmIyqhSpdy2VFCfR19bKNCZsCGxevaa7fg5ATZNqsme3kEgAjEaDzTmnOQ4M93dYa2nXGzKFab/HeY9tGjUeSl5p0SD7iiGNkdPdIyZl2s1Ksj5LpkbRhxonDvaaizywKoPr+4bV82u59nOi5EROYiazauya33M6ibnIdw1xHBn2R9q2xWBIMVGK6G5lrf9j3XI6bxKsc3SXW0LfU+Io78nMvjUrMpq/AnMYE//82zv+jz/8yN/9P3/zc7+dZZZZZhngjwFEg3f0fRAWtA2kbDg+DpQUWa0ll1JWgpZxrJSYaYLTuEgBGzP7UnLBq6EixkwTjPzMJMYb7y1TMRJs7x05Z2HRGjHwnHZ7xiFzefWc159/zub6UsLWtXqR0FCdx67WtFfXhM2FrDU1YJsixhBZv+n/WyO91KVwvL/j+PED0+GI7keVgbRzEo4063hhqlJMuKZl8/Il/c1z6W+vRZgfzFP+ZRVAjnGylqyVMo0c7x/Yv3+HKQWrndm1oDdqDYqvsw5VW5uCxzcN1jh15jsFrZWcogCLCuP9Hb7t6K6uxTQ2Rab9A+l0wBpPrROmFqoG2UvUkhpUzkGVkI4Haq10fYez/rySrjOlWSUupyobjRWQGIcTu7fvONx+wsmHl4eLIit5q40+gIByNQq5tmW1fU5//RwXlMVUo45iJq2zzKJ5NVZW7mmSjEljsaFVtlbC6MURrg8AzmHnlqwCJYvm0c3yAtUBG1fPK2vjJbaJMrcgVWpNuuYvZ5BsggDfWpEHj1LUMS/B63maqCni2o5mvT2DOGaJgDVivjH5CYhmadjK08Th9o4yids+jaNs1gtUKk3fynp+GkilYqwljhM2eC7evKG7eaapDtqM5ZRZLkWAmnuSmoA0XeVppFlvgErOSa4vjU7jnGwwisFLV98pV/a3O0zM9Nfy/SuTyEmMtVKtOSVqLlJWMPfSO0u/WUOu5KKfLSacdxq+L3pb4yTKrcaI7zphiO93OOfxwZJjYTqOwmo2yPdQyxSss8RYSKlinaXdrmi2W33vTr6eaJyXb+Tz/iWelAt/7599x8fHgf/mH371c7+dZZZZZpk/Mj8ZiF5ctGwvOrCOw37idJxoG0O/aomxQs40jSfrmi20rUSlVGE7ALnZFNGuTaPkBXaNpesCOVcKwiRV5ehCIwxJUd1cPOx5vH0E27C6uOH5F59x8exaI4W0LrFWbNvTXD2ju7zGBXVt65qY2ZxCFkYoyyrS9ivi8cjuhx8Y7j4Ja1vV9a5gLxdhuJyzojcrRVawbcvm1Rs2L16KprBkra4sop2cDagVse2qU/9095Hj/QNx/6g97JZidd1rhGUUBlbAfIqiWfNNi2uC3JztnAogus48SdapsVbec5oYd/e4tayrp4d7aS5CMz6Dx2Q9JkZ6wG3TqAtaDCI5F3xoCG0rkgTjnoDqzPYpM4pmUBrvGU9HHr77DcP9PU7bk0quWM20xFkpFSjmbFgSA1Bg++wZ21dvcN4LyyYLbQGtQlFLfqd+VlOrgNBpxASPc16AT1W2s4qEwjYteRrlOigi9ai14kKDb1tlT+fkAiMGM2v0PXI28Eiu7CRgyHisK+SahKE9s5vKntssAetIHmiJE77raS5u9IEh/0ijoMfGQLUamo+YoNI4cnx8kApQL1WZlKIGIzks1nlSmuRhr2lIKeGawMXr1/RX18okq/45aBzTNMp59A1n7XOtlDRRrcH1PfkkZqRSVGbgnVZvastYzvK9NRZcYLi7xcREs15JdW2KVM0CNvoAUZICTCch+MVUmnV/fqCquZzNhkb11HL+HSVGyjjh+p5SCodPd7iKJFfotYGa7aoWMjjvpTZ2krzdSsWvWrrLC4zhnGNsVXJR9NdjGU9/vN+qf4Hmb/3uHzDFwn/3j7/+ud/KMssss8z/5/xkIHp5tSJXw+3HI9MwcXHZ4YNnGKTlpxpDzBVnJSQ6aVNN0ZuJQdbZWMt4nKg5c3kpDuGYZO3vUMbK2tmjIVpFA/u7O06PA/36iuuXL+jWvYTEG3OO3ikY/OUFq9dfiCll1j2WLCHqpc6iOAEmPmCCMID7j594+O5bhod71FuFUaZRNugGayTM3gVZ5WcM/c0NFy9f0a7WshbPMwsqXegoIJ3X4qjrfP/2B3bv30k+qZnNOkW0oYZzw47glEKeEiZ4bBOEuDIWa6Qy0npHTZGUtJdd3CZAxdlAPg7sv/+NOIaL5E5Wa8TVbSzVPHWVM4fX10JW13ZYbQhB46w0o1MMICJr+HHeKkYA2+nxgdtvf0M+HjFOfmZOSQCZkzzTnJNmUbozyHBdy/blS9Y3z0QG+q+wUXM4/hkE+wAU4mEnRqC2wRintaUzi6zA3AcBgrlQo1S0QsX3DWG91aiqOSTdqoFnjkry0jCkbvA8nMjjQRMJ5BqyRgBoSQnfr6mqlzQpSwd6lIii0K9p1hey5s/S3GUcqg/liYk25vwZ0jRwfLwnTcLcltnUk8T17eZWohiJccK18jDhQ2D1/LnIG+yPNKjWYVwjRr2qLK6dK2klYaGagrFeqjSTymmaRplQPeVzdqs+DBTfcPx0Tz6eCOsO4yXIv+hDFIiLvij777wUNpSSaC7XNF2r2Z4KljXcXrYqIp2pKVFjxLYdBcPh9p46ZazKGkpFSwP8GeiaRs1eMZGmiZIS7XpFf3EJWPI4chaFyhHFtV7kO3O17F+i+S/+p9/nw+PA7/6Lt+cktWWWWWaZv4jzk4Hoo4bTlyJd8b71PO5Gla5puLyuWyHLzaVWjKkis3KOlGH/eKQJlsubtTCMk2i/6qwRNY44yYrfO8v+cOLjd+8JruXZmy+4urlhtV1jgMPuyOk00V1cQGhoVmvWz15IVmPV9XvOTx3dzKYMI8xeaCkV7r75msfffCM3XM3n9N5qY089fy7fBGVOEtlYVq9ecfX5F4Q5c3Su5USjhObDIS+JsY6UMo9vv2X8+EGMHrp6tWcd21wlqX/ZOqjKXDYBZx1eb66uaXFtQ0mZFDNVtbiSLykygoowS0a7vI12r9qmkRt0raqJk89rKJgiN+taKt3FFc4rwLZOMjOrmktmcSmcwaGx7gzq42mkbQPFGHLU42KFta4xK+gBKJQCYdWzefWSbnup+a756ecrk12dE3CgB7VSSacDOU3iUI+JYjUDtEDJWaKUgoDEPI7C4GlTUehams21/rwqXepWX+Mcj6UPEZq9moYjcb8TgGTrmY02VsoSnFZQWh9AQZPxIgnw/UpNUFoIoI76kqTRS54f7NOKvGTG/SPHh7unWLEsLG6OEUrFtg3OCZhKMarWMWK9Zf3sBd3lzTmk3syK3FolSaEWeSDjCfyVOFEouCDsfh5GsBbXBpUgyIkXrbIw9oZK9Z77799hhkjowrn/vYwRLPKAMCVhHqsE15cK03Civd7SrrRYAoOpWXShbaONZgWzXkuX/DDg2w6M5fDxlng4qTGsaiSbrP+NNQJ2g5gCS5zIcSInqe/srkWHOj9wWR8wajwDeWAqpTwVC/wlmL/9j77iH//qI7//9pFx6YRfZpll/hLMTwainz7uaPuGV6+2gGH3OJ63lNb8GJEghgPvSSWSYqRtPeNUeLg/cLFpuHm+lUxQUYGSk9RE2mqwJtEEuancfbzj7uMjlxc3XL94web6gtV6Jeu5UglN4LDb0714xfbNFwIUc4YkgfGyuk0KKI04ELRdyISWaf/Ip1/9AeP9g4Rvu4aUo2ruKsZI/qD3jnbVUFMV80fTcPX6Ndvnr8REk0ZpoVH2SlwU2stsDdgG4wLjfs/9b74mnw6Sg6rraMnLzE9rSnVMl5xxBuhayhQJQfrjjZOba63ikC5RtXfaYGTU5JHUqBLaThlHAToCyswZJLvgqc5DLhiqdqM7+pvnAmBSBBd+FKwuPenVKPM7h6xbx/2799x9/RWN97RtI4c9FzHuFFl/GhGHYo3BGgECbt2xff2adrVRIFJ/FAGUz3KNOo4C8pGK0ng8UIpoRMs0KtuqHeo5ifnIe9UEV8x5NZzwTUPYXgiCzBG8PjxMo143QaKdAEqiWkc+7JgOO1kXa7Um1mIwlCzvTdbXokme+8/rMODaDtd2+rCiFauWp2gvY3VrIHILUwvj6cDD+7c0fU8ZJ6k9netaa8F5h9Pw9WosrmsoecIFS3/9jO7qmXidSj6nAuCcgOOKnFcj0hoTvIDQmnBdL0UNpxMgNZcCqKWa1Mz5oqUoE93x8PY9db8jtL2+R8hxkl2IPrCeQV9oMFim04DfdKyurzE5qyzBSGVs32KKaLCb7RZjLdN+J3m6bcfh4YF8GmhCoJRMmqIwqFmrf0uVc2oMxEQeIiVlXHB0N9cqGUiUccT1nbChqkm1QXSrpgl4/5fDNf93/sm3/Nf/6685Lm1IyyyzzF+i+emr+ZsVV1dr9ruRKRWCm1fVDuudMDcxyy9tYzElYaqAq9Nx4rgfuLlZc3G9JY0jzlsqlilXgrq1JVIzEMfIxx/eMQ6FV5//guuXL+hXHd45WW9aAU9d22O6Fds3n9G0jQabF3E650kYrHmNqzdhWcc37D+85fEP/2/KlLEGppQkJqpW0bEZL5Euq462EdZxjCeaq2uu3rym32xk1Z8nMXxYATtG173n9acP4APDw46Hb7+mjANFTRLSviTaR+tmJ7eA5opoJQmy0u1WK7wP+uf8OX6mZGWLNBIINYTFmCRwfLXW/17VFGLAS7A5OQt4tUaAs5U1qu9XhNVWwFFJmEYC5E2ZHfvyAGHmoPqcpa7z66/Z/fCDJCUUQ7VON9nm3JTD7KKqmWKFTWu2G64+/5zQrkS9oLmPVNUrGjlWZTiJa3p2/u8eiKcjrhF5gGt78I48TCKhaBq9rlR3m0QXSB7x3hM2l5IzOQ2y5s9J8zt15W+MsIZealvj/pHx4U767dHjUCUb1IWAa3vy6YRbrbHeEfd7ycasBWs9rulVL21EA2ygpJkp9qp/tFqlaTg93PH4/gdl4kVPm6cJ0zTCPqMylpyJUyR0EqHkg6O7uKK/fqE5muWslTXGqFwkg5HigVplo1GTONTdaoN1juHhA3maaDYbiTVrlBG1cz2vJB/YpuVw/0B8eMS7cH7AqClp85R5qkydz78tnE4Dvm+5evOaktJ5K1A1QmrWBDcXW0zwpP1BCgLWG4bTkeHuXuK0qCpRMBSqxGlViVKz3pJzpgwTMU4YW1ldP8c1HXVKlDyd5S41qmbcIFppY8T4mP9i77Z/79s7/oO//U8ZU2ZKf/lkBMsss8xf7/nJQHR7seHu/oixlsYJi5eqsBemVLyGck+5EkoUjFZh9zhgKbx6c4kJLcNxpG0FoOxPhbU3NI2EUmM9+8c9d28/4sOKL3/nS65fP2e13Si7VKhObk62W7N5+Zr185ei/Zsd0LZRBk9ijIyaHeaqwlIN97/6fY4/fANVzCPjOJKKmqWsFZbJWkLwNG0LxhFLoX/zOddf/lKMxmk6gyRcIzf4mJ6YvNCcDTmH2zv2339LnUbKFLG14rogq8kp4sOsu9P1fJEMymo9aTjRNS0VIzdnZ6ipqBzT6s1a1vtV44hykQikpuufDD3e69rZnPUCvm0ouZBTxgJpmnBdT7O5FCd9ytB2cgzhR4yaedKFmkquhQ+//jX79+/wPuCCVwCEMHWlUIsApJyUFTUGi6W/vuLmzWfCrFZhpARbCHCk6cAWGA4Cwr0AtuH+jjQMuK7Hdx0gIM1mi9V+dOODng+jMUyiY2z7jcYzeWoeRfpQdb3uW2lRKkWinpoGSiYNR4a7D4TVRmUJ4nAvWRqnapaVrtXg+fH+jnQ6ibHNOcJ6LRsAU1XGYc7nkBDEpa1mGWpmOh7ZffyAsxJUH+Mg0VYh6MOOUca4EscR33bnVIXV9pLu+tXZ+f0kmVEGHoNpO8kdzT/KuB2P2KbDth3p4U6SIS4k9N406h639vy64oI3HHc7Tp8+EUJAsi6keCHHKLnA5el6RbcA8TRSTOX6F5/BmOTBtBqq6rettcTjQFitwFnibk/e78E6psdHhv1BgvONJU/5XIYhGWse7z22Vd3rOJI1Tqy9usT3K42MmrDBYbtWtMzeQ01YZdNrtlgLw/3dn/DX65/d5FJ5PE78O//p74rRq/7FBsvLLLPMMv+6+emB9o9H6W2vmYol641bAKghZphyJlAoxTDFzOkw0jaWy6sNqRjScaBvAzlDjJWLxtA2Ejgfi2F/d8/xYcf22Rtefv4ZF9cbjPWk40m0kxr4HS4uufzFL2lXAlBzKU8NN2lSc0ERNstq3WRoGfd7bv/wD4iP96JXy8IaOisu3Cbo2h5LaBqsN0y6jtx8/gUXn30h2rrxqASrABJDgaSOYOupTio783Bk9+kjxw/v8CEAVuKZnMV3HSUmicVRxkjWsgUXAqVUXM00FxfkMRJCEIBVK6UkzX9UlqtWTJWw9FgkszH0m3OVp/deneCqeU0J45wkHJRMrZZiDO22J/QbYZL1mJ3BkQ+YZKhW1/FFahrTFPn09a8Z7h/o2haDFX2ns0KolkLOEiBfNXXAOosPge7qipsvv4QyO+71YlMGU0CnSC2wUt9ZgXjYAYXu5kbZVl0PzyvUWjDVShh6KcIcKnh03azRhHI6Cgg1ymg3UlhAlvWxPBgUyjQw3N/i+7Ws+TGiD8UI0IqTlAKEVsDpOJKOR+LxiFmtaDeXamrSCktdAVMFWIuDyyrrmZmOB/Yf3mOrHD+qVF5aZWZF2SBAtOaMbzWmqmb6iw2r65fMAuXZAW+1ChUnD0kUSY3AWUzTU8YTxjeSKrB7JE+jFgiA8c35HBpjqCWJa70UpjFx+nCLL/I9wsuDYjqKTCEnlSGU2a1vyDkzxsjLf+t3cBUSVYIDlBG2xhAPh7PDvkyJ6WFHLQUXDKe7ByiyFZGsWge5YI0l50nizDQGrcRILRnnDK5fiZ48RfI0kkuhbVbYmqney2dPkUrR45UZ7nbsP93+KX7F/nbnqGkj//Z//D+yYM9lllnmr8L8ZCDqNIDc+SC16M3MdFTGVLE1E2qCatkfI+M4cbVtWG10tVUrTRMoWMiF9cpLN3qSp/n9x3uGU+T557/k2ZvXdOsVTJGSJ0oRAwLO010/4+LNaxpTqccdNC0mqO6uyA1PxJNZVocxUY1huP/A/rvfUMYJ7wIpRgwSTVRKpetaqQx00hFerSFlMH3H9S//Bv32ipIm7TjXsHxl+moU05YJDYQOUzNxOHL/m98w7R9pegGdJWVC16mxqxA2a7GP6Mq4qOkrjSPOSjh+zaIDNKZCifLna1Z95pMuNZeCcbDabnHtSmQD3gswNEZXxDMocboqTaqHTfSXl4SmE/BuULOVaEyZ1/HBqVlGjFnTlLj9+ivGxwd8EBaZ6rSlqJw1hNZIHFFR41doAhevXrN987kw2TWdTVuoxMA4R53zOZtO1q61kA6P5JwIm0t5CBlH1eE6ZchQ/0yRTFNtkiInjA9a2anGI9nBKoAMwjar3hZjROIwHCinPc32ktkxb6yjlEwtmVw0mL7rMVa0imU84ZsGFzzt9kaSF5wTsFsi1bgfXUPyc6q+ZppG9rcfhMmzoldMqWDIlFi0wMAI0MfIObayku42G1bXz88ylKprcKOsNNZinITKlxhFQtE05OGRmjJuvSWeDiKBCI1ej55a4lneUnPFSPMAKSVOnz5h1eiTc6FO8qBkjMVbYY1rRbJai5z/VDI3/8YvaLuedDiKvGCKWF3915SwRmKjoJAOe3LOuK7hdDiRpkTXS+UtKr0ouWgigNSfuiAPHylLdJdrPM3FFopk6ZZcaDZbXHCkg8gpjG/IoyefjmKU8oHpeAIbfku/bv/kc3cYGabMv/9f/e982o8/99tZZplllvmtzU8GohXRV1rvsBjiNInmz4DFkkthjIZpigRTuXre45tAKYZs5WYUvMNYiFMlZa0dHBOPH26Jo+Hm1efcPH9B17aQCqVKT3RMGb9ecfnqFZvnL+QmOexFx+kbqKo/E9GdZmBKjmCucLy/4/Tpg4TXG4gamQTiqp3bkUCNQ6VSjaW7vuHy889p+pXEAYGyiqo51BVlrQYTZD1fYiROI/fffcf0+CjZm7M0wEnUlMHg21YyOlOkTJLXaZtOGC7rMd5JBuRsQDLKgI0TxjhpfakSJ1UA23iaXtzYs97OzJpA1VRaY6nM7TcVSiXlxOrmBh+Cmmfs+VjIiX/SzYqJRvSg4/HEww/fk/Z7vHcYFBgZiRAqaoZyzlHVfWxKpWlbrj57xfrqRl6vJHVUWw3VNz9a+wIadl5zkQpNCr5fUZKYtKxzen2KJrcaMfFQNZtUwYm1Btt0qj0ErMeuJAtVCnfEyT+vr2tKxOFAGgdcI1Wf4hivAhxzosSEsRK0buzMxkbRrJaKbdqzW18eOMYng5rXpAXnRatLIY0n9h8/aL5roE4a+q7Ztb7xYvKxwiqWlCUb00G72tBfPlejmqYnzMB8PoXWPHXLYyAEynCU66VZkU8n0vEg7L1eA2UaROJghdE0ynTHKfP4/hOMkbaX7M9SI2WKGJBIMS3BEk2xtjRR2X7xhvXVJel0xDSBPAy4vhV2v8hDmlv1kmer4f/95QXDOBFPA92q1/MuUPscvYTBhVau5SKAOMeIawLdzRXOeeL+SC0Jv1pjnSefBqr1ep3Jg6hrOjFGjRNpnKR842ect/cn/qO/+8/5vW//4kkElllmmWX+tPPHAqLBO+k2n6bzms0bqeScUmYcEptVYL0OGOeICdq+hSzZjVMu2NnEUuCw27O/P9GuL3j1xSu6psFjJO4FQ9ZA6s2zKy6++CXdxaWAjZwxvsG4RoFgFSBTIlAxWVayaYoc724ZHu/OpJ7clDO1gA+yKvWtuMhLTORacV3P5vUbNs+fC3mWRrC63p4dzwVZy1uHaSwGSCkxHA7sf/gNdRgIbSPxSEncwBaJ+nEKTkqM5ClinBWmDmEPjRUQaZ07s55gIEZZGaoFvRqUGQ00XYcx7onA5KnpSPSzTtqZYjqbV3LOpHEkpYT3GstkvbQK1Tn8X932wOzkH3Z7du/fk08nQhP+iOazSLo9ipM1f1V+RugCF8+f01/diCHFSLyMaFyfTE1lHMA4ic2xljJNxN29ZEP6oMBDUgIkrF6BuhE3vKyPC2UaRQrhPbZZi5MbzvpWYzw1J2pN1BzPDvlSEuNhp4BlJQAqSbvXvAUopUhsUmhUOytoz2hzl1uthX2cY4402go1jtU4CeDXWtk0Thwf76klYq2TmKkYqTVjjVRbOhc0oQDmhrCSEu32ktX1M4zxymbbJ70tep061adqBJR1ljwcqXHCNR1pPJFOJ80aFanH2bhlNAPYSf98zpnj7QMmZQmgxyoDnmUl7iTrNcUsipkqjH2msH5+xfbmhnQ8YIMmDKiprMYk3yun7VbKQDfbLeMUGR/2tI088FU0ikx75AGMtTgvtaF5ksQM6wztxYaw3pB2e2ot+PUGEzx5mqS3vl8JgDaAsbjVmjScGHYHMI48/TwGoA+PA//Xd/f8g9/7fgGhyyyzzF/Z+clAtPFeXOUly6q8yg1vSoVhkrXY85sO3wQyMI1Z9KBJVouiEayY4EjjyOEwgA08e/Mll89vaBuJyimxkGKWOKcQ2Lx6xeXrV/j1lYJQBZuhVSZUVuVk7RF3Apb39w+cbm9JxyPGCRgqpUjzknNPN0ydOE1y07u8YPPyNf3llQCGkjHGKUP0JMoyuu42CmpE1/eB6eGWmmWtJ6v7DAi49M6pthDyOKm+rxFgnquwh1nzJJ3VbbVRFtaIYUmD37N+bt/3hKZ9YjmNkRW50xrRUsB4XavOEgBh04Sx9Ax3n3DPnhO6tQa6i3yimidDDMYQTyf2t58YHh6gZELXUpL8LKt/1hqjEsiq5h957+2qZ3V9RbvaynsqolOt56YrI672lJibdADS6Ug87gQMOy9aUMkMk9eYAZd1AqR/dM0aI7WttumkbAAjDxQKjKkiMahV3NwlS+VkHI7knGg3G0wt5FTOVaQGYW99155TCjBiAKIIcLP9SupFNYZL5BxWnfFVNLHKVBvnieORw+MdcThha9XA9iz1l8bi2lZbjIzEH4E2Zxma1VpzQgNPvfHlrB+cmfA59nW+Tkoc5TptWnIcSfuDhNp7bTkaTtRSsNpMNv+8kjP7j59IhwPtaoVrGpEPDAMlF6y6zUrM5JyoetyqMbQ3l6xfPNNIKMQMVwq27yknKT44f59n5th5xuOB3buPBOMkLm1uxMpybiQzouKs5JLmXCRdwFSa9YbQdZRRNjjhYiu1weNEPh2kJtcaebjWkxmnyOH2QcD4v3JN/XnMYYj8vX/2Hb9+v+d/+Oc//Dm/+jLLLLPMn+/8ZCDq2448DORUiDHrjVmC1L2rrLYCQiniwm6C3DBikSge7yzGwng8ctpPrNZX3HzxhtV6LYyPrspriZQC7c0NV599zurmmazoaoV4egIuWtep0e/a8GKZxsT+/TsO79/KytN5QCJuSqniiFd9qxh3ClOWiJ7++ortq9c0/UpA5KyVNE5uUvp6yFs9r9wPHz9wuv1AHga5yWl7j/VO2LZa8VpjaEpVXaEwesIaaWNNBSjKXolsYN4ulzO9JbrWiiF0PT40Ana1GtL5oBrUubHHaai/NM9Mw4E8RqzzEgKOoeSJcfeI69bi0p7ZOyNVjMY6pnHk4bvfcHp8xIeA97pCT5mnCk153zUm+atG2Nt2vWF1fY1vGnX6F9W6guS66mVoVOIgglam404ikBDA77zEKtV5la6xOhLppDKJIoHs1je4biUPBJouMDOhdQbl00kNTvJeSorkcQCg6ddiLipgzGykmpuc0GxTvb6Mxhgh9bLWayg+6vw/P7CINGMe4zwpThxuPxBPR90cCJidQ9WlHchjg5fM2FIUwGeavqe/vsZp3zsYyNIZbxCpg4XzA1cpuh6fBmEvQ0uJkXQ8YZ0/JxeIwacqG46A+ClRrGf38RPD3T1N0wBGmMeUzg8BZQbe1ZwZ5FIz7eWW9c2V/JyUMCGQhqM0UMUJ45yA2nE6m+qMMZyOB3Yf7qRJzGtKh3xSckry4IbISUqV73jJYlb0XUt7saXWSh6PEoemzUxlHCjjSNXuenlQTqTTwPHxKA8fRo6Z/XMyBZVa+c//wb/kMCb+we99/+fzossss8wyP/P89K75mxd8+PYraaqxhpSzCP4by2rTk7QLXfRsosNzzkjcjJVQ6t39ERt6XvzyM66ePyM0LVRhwua1L75h++KGi8+/oNts1FhSxERiBCDVOMoNt0rkkcGAbzjc3/P43dekw0FvpE7XpeW8vhVNnSOlUXSGFVy/YvvqBaurawWEut+eUeC5UlIZVE3yL6Wyf/sDp49vRYpXK2WS6kXrvbr3DT40WOfVsDRh25ZaDcPjjqZp8a1mJlKF8VFdZpkZvx9NTuLybvq1sKm1kFPE+kbbZJDe7yyFAWIUEcY61awyAXd24BsjsVu1CPDrLluspgFQEqZUpmHP3Xffko4nmtBQjcTHGI2LEnmmMKkGRAuLHK5uu1YQKgyhAEaN4AqNsLY5SZf43EY1DsTjjjgMFP3Zrgnnc2Kqgg0jjVRWY4GK5p46H6RdK0j+pkgMxGhFnbRZKT2d35ypcSIeDtqh3uFC80deb9ba5hRJpxMlJnzX4nsJ+TdG5BXC1vozSy/XSqCe4ZMabEJDihO7t9/KiriovMQ6aVnC4huVZmgEUsnCIqc40a7X9DfP8N1cVgBz89P8XqWAICtAl3NV0ijr/n4FuZCOB/n+VAHXxhplW4VNt87L9RxaHt++Z3p4pG1bjHHkpA84s1RAtbmoScpZT0wTYbtm8/IFrmoOqvPkYVLpAuRhpLm8UE1vlWxP55hOJ3bvb3GA7zVgPyWJNjMi5TBVzXgVkr4fasX3LeuXL8RYNo6iDW5byjhSjntKzlStJq4xkceJEkeG3YE8aVNc1oxX/uyR6H/4d36P45j4h7//4c/8tZZZZpll/iLNTw+0f/GS+/fvmNKecRTDw3rl8aEhTsr+USQmxc1MijBi0zCxvz/QrS95/sXnbJ5f4XDUKVMMYC1pjLhVz+bN56xfvha2rmRqypQ4YkOLDa1EzqjYU9glceI+vnvP6d13pHHQXmphQX21FAPWWQm9N+qkL4ViHbbvufnFF3SbCwVJyijpKh8MOJ4YNWVu4zjx+MP3jPd3WFNxbSAOR7kxO0caB4J3uNCocSRhbcG2LTFm8pBoQoMP/qztpAorUlMSvSQG5+fcxsI0TTR9R+jXovEcJ2EsnZdGIWOoWVhBqY8UA1dBWn6qAhkwFMpTdqYRId+022FDR7u5ZK7U3N9+ZPfuO0yBpu2EAS3pbCoyRvJIpVZVgGDOEki+fvGM/vJaWqvm1iA0sDx4NepI89Ucjl/iyLS7p6QoxhEFtXMofMlFwYZ+bjNLDoC5aai/eGJZ5/NWEVmHOv5nRltivCaGhzvwjtA05+YmyZlF9LsV8unAdDiQhkFiRNuGmiPOeXXje80tVRa6FKwTQxSza91a0R2myO6Hr1TLWJD8TXm/1gdso2YzNSblFLEhkKME12+evyR0vVxbmhjBrJt0okUtSZuGjOhD8zSAtbj1FkqWeCkjRjKMvgdjcK6RfFRrqTHh+hW79x9I93c0TYM1VmQ6WaQdorMtYtrzXhnGQirSQrZ5+QJnpfnKNa3KCwqh20jsFQr39MGyjiPj6cTu4x3WWEIjkhYxOAb9vKLbdI3HhECJmXSSh0sbLJuXzwhdRzqezhrsWrUO9niS77QPaoqTqtM8RdKUqFVambx3OBeI0/An++36E+Y/+e//Bb9698gfvN0tWaDLLLPMX8v56RrRtmNzdc3d3QPOVvqV1E3WAqH1TFOmbzxQNFDccTiODLtHcqxcPn/Js1cvWV1ucdWKHlBvJqchsn52zfUv/obE5BirIFT0cLZfixQgTsLwGHvuk55OA/ff/orx4e7M8FXV7DnnBRwHR2i8aMpmk1Hfs7m6ZPPqtTQ7gdzA9bY4g9Cq/dNiVpL/fvz0iU9/+CvqNErVpnfkOGGdUfY34oPUNIpOrtKse4wPnO4fqLkSml50lUbX2uoML6rjFCmD6EKLMl2+baXVx4hhhKI94V4YTTHciF6yFGTVWyvTOOB9UOAl/54gbGlVo1GtlZIiw+1HrJXayN27HzjdfsA3Ld55pmEkp6T9AGJqcU2j78FAhjRlCpWLVy/Z3DyXaJ1Z96nMnNRKFnWLK0MIlGli/PSBHCdcvxbwmgTkWB+Egati+DJODHG1VnKRPFjvPK4XI4pkH+nrztIKKjSNnOuczmzs+PAJWWZ7wahGEhFqyWLccpZ8eKSWp+pEG4LKPJ3oledjq+7rOk1qjlLQpKt9rKfkicd331BR/aEmKZQYhf1t2/OqWPI7xZg0HU60q56L12/wbS8MqAJb+cpESTZAXksqPEWOkONIcUjsVYzE+3uVUsh7LEXbvfTar8iKPqy2PH685fDDW0InqQw5ZamfVe3ymTl0TmQZTnTQxVQuP3tN0/bk4SjH0jrKeJAAfjUUhq45x42FiyvM6cjt9z9ArRKSb400KlkxtcnTq2SIGi/lCUwJayvVwcXnb/DdinQapA63bQWo7g+SSawyF2usbAiaQLWOuDsKc2408qrCNI6zXPW3Ov/tP/qKv/tPvuXuMBHz0oa0zDLL/PWdnw5Eu55nX3zJ4+0HTBVNFxVM4ynVsOqt3DiLgKghZo539xgaXn7xJVcvn9FtVlL9N0UqEGMkV8P61Uue/5u/g+/XMK8Js+Qzmm4DVVanZRzOZhMTAoe7e+6//jV1OEIpuNCQs+hXrTYN+a4ndGLkiIeBajzFOa7evGH74qVkYmKoasoxVtuNmFujsq4Qhcnbf7zl7lf/UnrZZxZSaxutMcTThA0NLgTSIHKC9kIyCk8PDwK+bENRtotqVIopeZIiafBiXKKStR2n6Ve40P7IQAWo27+mJOtbA2WMVBICLgrT8XDuoC8pC3jxDpufTBglF2VhLel4ZP/+e9HO7h/pNluMdaQpPuliS6ZWcXvbICv+PI6S39i1XL75nP7iUkxLSf4c1kLKknSAVllqgxGlkKeB8fFe3OjdSlnCLGAuG/IYqaolNkbzMA3yPrA4a3CdXD81ZmoaoOrPQkx2RvWi5AjdmjKeOH16iw2BYIOulyuguZ5W1vpxv8O1Adv21MOJWkUzHfqVNinpOtx6cK1oT2sFI/pTnDnHJuU4sXv3rQD5USQT4nIv5xzVkiQWKgNpEuNbxdC0ge2rl8qIi5O9grxWLdJ7P6Omqr3tGPJ0Io4n/PZKMm4fPmGDF0YwJpzvhA3VuCfjDWVKmNBwOBw4vP+Btl+RSyFFic0SKUJDzk8SkuCcfP8MRAwXX76hW69Jj48i2ekC0+OOMibCxs9CT4zv5XhrecLh/gGmiaZp1WSnbK/zwsbP0hJr5ZpPSUxPFtavX9D0PXGcICbcei0vMw7Ew/7Jb1i1WrdtMN4z3N+TY8I3oimvpTKNIyEI0P9tzNxM9vf/2ff8rd/9A2GVl1lmmWX+ms9PD7TvV6xM4dUvf8m7r36FrRXjG1IqlJKZcmYqsFk15HHi8cMDq/Vznr95TX+xpr3YiFZzjGAhjZHqGl7+zb/J+tnLP+LyrmkUQBA6uYHnRDntqdViO1k1P/7wjsdvv6ZMAxjwym5YI1aYkgvtpsc3DSVX4pipxhO2G1YvnrO5vII0PcX+qOt61upJOieYILq/mhJ333zD7Vdfycq9baTnWnu6U8w4Ywj9SmKcdnvarqG7uiaVyvHDJ4IPGN+peeWpUzxPEdRMJOk8hZzELGK9pdlcULUJqmbR8fm2PbvIK+Xssq5Zwu5LLQz7B5xxUGSlnWPC1IL3Uht5BpaafzP3gY8PjzjnCH0vbGyMFCzVOKqTStdZ01uN0WSAgu86tp/9gna91YgjeT0ycj69Fz2wd+Bbed8pUmNkOjxSqbjVRkFtFkf3NImMohSMC2I0KmCqA1Gz4rse33Ty36IwWOeVuvWSLassFzlSfYAUGT++xbggDvdZC2xFv0oWGUF8eJDV7nZNmZLmzjY0mw226YSVNnNmaaZOgzDobQ8xqnykiFYRePzuG1IcMblIDqkXLWiNknVKKSL1jMo6Wk+cRjBw/eYLmtX2XGErRisxlIkeuugHtxA8pEyZRuLpiN9e4rwnHvaYJmBDoE4J6wKliokPvc7n6s6cMsd3P9D1K7xvMcPEcDpSCnS95ONaVyhJQHDOhZQTxhTWn71hc3nJcHtLjpmw6kW3PE1nvSde3nMeM5CpdeL0uGO4v5cAsGJUq6k1qnWuNkUC/Y0hnQbRlueEW3e0V9eUlMmnI77rReoyRtLhAFRsEI2yDS1+taZUGPd74mHUpiaDNZZhmgjBywOt/dMB0VorKVd+/X7Hv/e3/reZkF1mmWWWWYY/BhAV7VhgffWMbv2WaRwYYyZlMedU62mDYdztOZ4Kzz//JZfXNzRdR7PulanRthgq3YsXXHz2Je3mSkwm6oQmTdoWZHQNb0QXWiqm8cQp8fGbrxnef8AZI+YeMilXnJMweucc7XaF9ZY0jpSUSBm66xuuPv+cMBuJsupMnZEu8lJ1Tazvx4lzPU6Jj//yX7B//5a2W4kOMXhx4mdIY8YHT7WF6XiklEzbd7TbNSlnpv2JppVjYK0RIIiu3VMSMcAMgqiaLeoJ607C9FMGkvpeGnGJe6trdcB5yjCK49gbcqrElAjtCmstJRWy5lY636JHWj6veYrWijGCleYja2Tdn1LS42HOQH2O5HEGDJkpJsK65+KLXxLanlrS2TQCAiaqsVK/qo1CNUfR/44jadiLSSh0Eu1TC9ZLzqO401X7WOtZylBrwfk5fNxRola7OrnxGyNsNapfZHaWO08ZTkz3H6RFKzTCK/oGlIOezTtxv8M46VuvORP3O2qONOuN6GrLnC6AXNuaMUvTCTgMjYbrW0ot7N5/LxIORDlggjvXaHK+BiBPiTIlXOeJcZImqjdvaNYX54Yk0fvq2tq3GD22VU11VVMT4nDAdh2u7cjHvZi5mvZcXlAm0Z4SHCSRw9RamabE6faWJrRiDsoF8aIj17pBXOqzVAZLHCeMhf7mis3VFeP9A8YYussLSsqk05GwXeOaRgLwSyGlTHy4x/ct0zAy7I44I9pMnCUXMSgJ4RwwpeIaMa9Np4npOIo2uHWsrp+pQ34krCQ3NuVMPg3yHTJWpB3O015cYkJgeHzg+LBTU6U82qQYcRacsxLXmp8kGX+S+fA48O/+Z//Ln+pnLLPMMsv8VZ2fDERNyVjn6S9vaC+f8+mrr8i50LaeNnhiShzvj1i34ovf+RtsLzZYa3GtVArOQKYYQ/fsNZdvvsBpk5BRcEESZhCnrTOoJ6FWqgtMx4FP33zF4cNHmrbRlaZBaiXl5/s24NueWitxHEhjwncdmxfXbF6+JrQdxOmcHSlaxyJOb6vskga5UxzH20/cf/Nr0vFA13UUwHl16lqnq01LyYnpcMI5R79e06x7TvujHKNuJWv+2W2P6BfjFHHaVmUQEFGigO/QNzSrNWWcFFwYCfH3sn4tUd+n5dz7jXfEcaRWQ9P2GvAPUHHGSLST9+ScxH0cJJuyxsg4juQ80XadOJdLpNSq7VkGW5OsMq3Degd4cpxIU6Tdbrl88xkhtGiGj+r6NALIGGqWoPbZoFRzIQ8D0/5ezDnWkwdhwm3w5CS6WJzHVtEsnqUApkoFpPM/AoRWAtdLEuONxjJRxDwmDxyBMh4Y7z9IXJGXWk9jnF4HCaoTKcLxiLEWv15DqaThRB5PhL6nWW2kBcoa/Z8TPXOtmF4C8KuZI5UsuSSOH9+Rdo9qHJKueiFoJ5xrJLLIGPI4EYcB5z0FaNc9m2cvFYRmTSmowvRqdqtR7SnMYKsICB1PVGsJqxV5OErAf9NSqwUXhL21wmibJPIXqiQiHD59wgHOB2HZkY55b4UpTtOEc7LCtk6u/1oS7cWWfrPl9PEj1lnai0tKzqTDXsDzeq3nRuQozotu1ITA9HCEYmQ9rgqDMpvuMMQ84rynaYI+SBV56KmZ7bMX8tkmCei3TUeJJ5V9SE2wtRbXNLiul2ixaWC4eyBYaa0S31c9Sy0qaFTan46/XEDoMssss8y/fn46EG06rHPE0wBuTS3QtYHgLePhyHE3sr15zvPXb+jaFmcsJsyrZqgx4vo1l29e0V1eyQ0wJyWTLMwVmnrjAxTAVnISbebj999iUmLVd9ggVYYVcQSXnGm6FmsteRqlS95akRS8fMn6+lpWsOqYBifGEgpzfaaAX1nRllwZHm7Zv/+B0LeYXEmnARcUMKTMOIzqFoZaMu1qTRM8tmsZhhM1F9quF53jzNAh2YRlzpec/10tpFHAX7teE7pem2aqmKA0NYCa5LiUotmqGs0DpCj5jS4Ean3Ko5SMT6dATbSiVl3aOWViHIF6jlgqKZOnTDUSxVVKVVOMON+rkTihXCrtdsv1Z5/hu/Xsiddzp+B5BjpWdaIlU0skHgem/V7zaCGeThIbZL06/oVNtc5CqdIs5BV81SrxSnNDUmjkJbVekiDxQvK69uyoz6cdcfeguk4rzVW6jpXGJEkoyONEyVmNYUYBYKZZrwnbK6kHVSMZ1queVDWLaVLj0vyzRo4f3xKPO5wPYuyxDjSQPfS9AO/TSB4jaVRZCpXQBlbPXhDalUpGtNRATUJ6AakGNoERgFpjZjo8UGum2V5QpkiNkwT7i6hUNKQq0TD6/awVcjWcbu/xFawyrLUIo+7VoJViwXs1utnZlDfRX21YX18Sd3uss/jNhjxF4uFAmSbCpsdqPFWJEYOl2Wyg6dh/uqWOE8Gpuc0aKFYNbVVW7IBxjpwqNY3y0OXkOKdUcDFRUyFs+zN4rXGS3zMqZ7FdL4kYOTPc3lFLJXStvK9SyHGUGDVr1bD4o+zgZZZZZpllfuvz01fzTctpf+Tu6284vH1Haz0lJ3aPB2qyXD97zdXLG2Eq9eZvcqWYggktzeUlq8srmq4X3acGgVc0ANs6jJM4HLnHyo1oPOw4fvzA/v17YUut3nxn5gKoGHFva6xSimLeWT97Rn/znH61Fv1dzRpzg5qt6lkfWnM6M6HTOHH4+Ik8Hmg2K8BgvQRu2yA5n8PhQE5J2TyDX/X4tpEsw2HAGUtYrYVNDEH0nCmT5iQA5zXVJz1FG3lL27Q0faefz0irjndUq0aNKkyxmDTkZluqrt6NBW91lf0Uim6dx2oEVElFM1gLMWdKFX2nMZacKoWkEUnpHCBurayWTa0CTrL0za+uLtk+f05YrSXyRsVvpuh6GGRdrfFMtVRqmqROcpAoH1Or/GyrwC1GzVGVyC1jgCbM228MAkqtAlGjwfG1FFn9By8NRinqtSImnBxPpOGkq3S9ajQFQWpQZYVecySfDnJcc5QKySptXKHf6jpc4p1mkAqil56lJHPUV44Thw/fMx0esU76zw2AqkBc02KwlDGShlG0wmjU2KpjfX1D6KXdqar+U/Socl7mXNuaIqQk7m8D6bQnp4l2eynSBu29n4MDREsqkVLWB1nH50QucHx4oI4DvmlFR6wgtGpUl3NOjlNJkpVrLClOuLZh/exGcnobAXaUTDoNxGEg9C2uEbZ9Nu3MUVO7Tx85fbqj0f54rAbhmyLO/CIrdhcaaq6M+xPGZKqF7atnYkQcxCzXXl7pLwWJr6opigfMB9HGqi51HAZyqbIhMfIwd7724FzSYGdJyDLLLLPMMn8m85OB6OPb9xzevmV8uCc4z2ha4hDp+0u2l1f06150X0l0erN51zYd/dVzuu0GW5K0qDQX4igusko860fTIGyogZIKx0937H/4Ttyus0PYGHUX6yhQAgGQ1EpYrehvbrh4/RofWgWZojXEeAhe3Ps1KTDVnEsLw+Mjx/s76cJugriCxwmn7T3TFInjQE5ZDD2NxzUB14jGreRK2zd4K+tF5zzGe0qtpBT176mkoGQx7GTRv3WrTpqS5lV8CLL2rYUSR9HpWkHfVQPdZ7Zq/mdhEWXdLMk+ol0UjZxEQZUc9b0UQteIQ7uKG18AZxH5gb62gLUiTmvxSNNtL9g+u8HrmhM4g5xqrcYIVWoxUBIli9s6DuI6N0Eie0qVuC9jDfncbW7VBW6VTTYKmIWls81K1rvqFpcYJjG/GN+IgQjOa+p0FGAmkUv6OloaIBFhInUwtpCHk7DIqp81QFhvsdokNBORchKEiTRzVigKwLWq8vDhe6bdg9bOFiEiNfHAegXXJRMPJwmrVwDWrtesn78grLcClrVaF5Bgdjt/Z9BrWI0/1pFPO7CV7upGzWtS4zk/sokGFmoRwFxLUtOZ5fh4T3x8JHgvQDDn+fDKM5w2lVXE5Ge95KFWU9k8v8E3vbK1AuLScSQNJ/l+dD05ybV1Pobesb+95fjhE06vX+u9sJNkfXiUh6pGNwumFKnjdZX15RVd11ONoWkjKU6kccDaTkLqj3Our0RLzXreeDwwHY7gGmwIlHEUEDpnvWphQtU4uHlrscwyyyyzzG9/fjIQ3X/7FXmSVadvGtYXF6wvL2i6lrYNsrYfk8DFWqnB01w/Y319TWgC5EmcDv1K2IkyOzTU5JEmZSghngb27z5w+PAekmQrFiqmGtVTqjbPnHEIJSVh6a6vWb98Rbfdir5No13qbEDyynjojf0MSKph/+mW4fEeayqhkSiolMRcYrxjHEam00lCs70jtEGMHBXGcRIWtAsKNJwCBtGg5hTlpoiYUsRLLayQcY6m7zSwXbIhXQiYmSHUaBrmnu0qLFcu+azfM3oshUw2Z6OQfMSi61gBTkVZytB6YeRypqhZyxjRBTpjKHpDnm/EOSYIjs31M7qLK1wjLnYBF4IuDJpAMDdiaYtRGo9MxxMmNNhWqiUpRYGNNiVV9NyKI9rMDxzGYIzXlboCsTO9ZyRKy4h8pM6xVFaMKXH/yLTf4VYrMXlR0UZH0Q0aR9I82JIm0igufQnnd4SrazFEzWBEm7zmuC20StPMmmPnKCVx+PCWab/DhkbxsiYN6PkzBfCztvLJrOfbjv7mGWG1YQ75x1px4v8otoo6B/s/nZ903GGMIWyu5OGkVkzTMZuXOAfBy3p/rkPFBY53D8THnWTbKnueczo/+Fm9ztMwAkWZUdlQbG+e0V1sRa9b5Zyn04l4OuHaRjYDyGctFpyxuOA4PDyye/cBNwN8a7UyFeZ4pZyTZIF6LWLIiWoQmUQvBkAXPL7xtHbF6WHH4/sPBOuwJVFEkS0PUY0jx4E0jrSh5ThORBewxsrvB4NGYaHxasLkO7cA0WWWWWaZP6v5yUC0xKK/9AONtfg2iA7MWby3Ylh2wqD59Zr26pLLN58JUJsGMP7JqJDzU9tNkjgnAIzl9PjI7ofviY+PAlatJeeKMXpjKFV+hqLQUrIwRtbR31xy+cWXtOuN3HTnKsd5Fejsk3t61n0JMcnD2x8YH2/lhmcsJVdK1GrQxjMcDkynk3y+EPDB47uWnCR0PISWECTX0wXNAS1i6qilCOMIGFNVFymmHN82P1qdV2yQaB2API6A1SpMaVwqRbSbeRKQUHNR3Z92e9cqbKmCtaph46hmcjYfeR8EGMzsH1Wzz62ADCo11bNeTiKnHNsXL+i2V+cVsxzPwhNTLSvZGsVBbrynTInxcKQai3eqAdYc1lKq/LWsfd9GdKGSA4s4ol2QlbgmBFQRMyog1YeKoD9XRcnGWOL+QcBg02rDlUZllUpJCesb4jhKTWhwpKlIriXyINFeXmPbDrDn0H2sfl4rEV/VaFtSnasgK4f3PxD3e3F+m4pgVGV75/VzzdKMhVEpgmg2Vzc3NKuN/BHVAoO4840LChKzNoyZs8wg7h8gNLjVljwNlHHA9WtmvWo1FdQ5fr7uY8SElsePd0z3D3ij7HuR1bT1zZmZxkCcJgkecF4fbgyrmxs6TREoOYk++3jAlEqzXuPUvFVm57tz+KbhtN+zf/cer0UAoj3+MeDTh6BzaH4WA1tJ+D7QX2z0GtT8CSvXhQ8NpB2f7m65fnaFc45SsjQ75cx0POGaFms9K98wnE5k4yR79HiiFCl4sFZ+1znvz8UayyyzzDLL/PbnpwPRCtaZM2tlrcFh8N7JCo2KcYbm4obrL39BaFt8v6JMAxWDXV9p88qoDt8ijEocJUamGh7fvmX37i01Rrwz4Aw55vPW06pDWfSPhRQnKhW/WrF98ZJdr85FAAAHZ0lEQVT+5rm4cNX4NLNQwLmB5rzOLQXjHdM48enrryjDkdA21JSJccLOtZO1MOz35JQJXUPo2nPHei0Wg6NtA84Ks+c0o7EkYUFLzuQi62zrJLop50wphW59Ia+jmkPrxZGeszh9jR5zQxUTRS6SnTiMwoHKYT+78c+f1QhwmJurhKSuTNOolZpeAWg+/xxvNZy/ilN4Zladygr6i0u2L1+JdECZTKOtPbPuz2AgTwJ+nRUQGiPD4wMYK1mfKUlXgIa4W+fOK1EQkGOtAKeaI65pce2smRU2ea53lHNcZB0//7Ou8oUJfcS22hsPxGEEDCYXXNOQY8RYcG1gjocPvZhZfNtjm4a5evPM1KnGuBoLNgj4zOlcC3r/mz8UU5sG3ct6t2pBAeRccU50lcF7asr4xlKrp724oru4lOOo12nFnpl1YZnj2d2OXhvTcQfO47oVZRwhiTFwlkoU+6NrJGfE3Fdw/Zr7Dx+Y7h/oupY0jqrjzboit6gigmmcSFMitBIZVSr0l1d0W4m2Sse9Sk0MYbWSh6umFbY9RWou8oAWAtMwsHv7juAcdY4PMwaLVd1zObPEIXTgDONpIKWJpm+4ePFMta3K4iOGtxITNVdWmw2UwuPjjs3lBUEfXsbdDlMtxokRyXUNmzYwnAbSNEmWserGvQWn7WN5AaLLLLPMMn9m89PNSqiAf2bPQJkSWaXiLdvXN1y8eCM3QeuocSCPR2wnWreao0QzqVmiqks9TZm7b37D4dN7vHc0nd7sorTrGAqhaUWvpVrCNEYKhuZiy+Vnn7G6vBGgMA5UyjnqqM4ZgOd1cZIWoaZjf3fL3R/+SgB122omqMTSWO9EcxYj1huMbfBNi8rWpCqUrKHXwnL5vpMVb4xqfICqWkmnbFjS5qdutcEqYBT9mjCYOSZZ46uxpdYsTVS1KkAdJZ6qCKAwSK/4ee37I02bVIgKCziNUm04xx2VKkyo06aq+fzmLKDSt1KFmWKku9hy9fmXym5PorVTjSclK2BPwkA7JyDUGPI4crr9CFSazZacxA3vfdD2IGGG515766ysgLNoSl0IeF1Rz+U2T+BO+EdCK+c2qVnLOqbdHdPjI7bpz+YkSQ9Ar1VhxU3JwtgpaJ8NUC60ki/qJRQe1bzOkWK1ov9s5jdELZnHd7+RMH5jz/IIqcOseOeVva7EMdH0DZYKFmKKdJtLNs9fc2ZIjcFUPZdGtI01iqmIqtWutRJPe4wP+NVWOtxrwrbNWbVQa8FoY1EtItEoKWKbnuNux/ThE23bnrXAVFnbW+e0E14AfC2FxqtRjUK4uqLZXpCOJ3KMhPUK1+p3VB9YS0xnpts6Jz3zFO6//0HixGxDqpNuUgSASkC/vA/nPFV1s7VUfBNYv3iGD53qV6W1q6RCKZFqCjlH0hjZPH+B3T1y+8M7NtsNfhww1eI0GsoiOaHGOppSyI3jtDtK3m+KsoHxjulw5PH+8Y/1S3WZZZZZZpmfPj89vsmCGGG0/3nWEJZKcUi3+Ksvld0DkyL5sMN2a0xoNNZmBk2zXq0yTYXv/uk/JR+PrC83YihRBqiUgUql7Tq9ISlQK4VsDKtnN1y/eS2mDlspp0FWqEYMP0Z7uuscol604jJ03H77LYd33xG8mHVKNcRpxAK+aUS3WDKhcfh+TTxGyjRhu5aCmFx826rb2+A1aD4PE2WaqMaQiwB3a+0ZcDhn6TYXzKHs1gWJEKqFMmlzkuokFWpRQfWpBzbXN5SYsMrQVa1lPDvUa9X7udMMxUiKo7DWZ0a4Yqo7yx1qlg73UjkbRuaM1u56zfb159LAM0m0kGSEqrZR3yNVWUNdbZYYGR8+QqmEzfbsMHdNQ8pJGrDUmWysw4dZTytyCu8DfnUhoE6rL6UOdG6+Qs61c+eYL6whHfcM93c022tlafmRjnJmGQ1MA1bjmShVShRyxrogMUfeay0nAq61zQhrBHAbI9FH1oBz3H73DWUY8HMM0BDFGlSL5LXq+UnTRLMSZrh2DXnM+NCwffmZfMlyZI4kE8Zz1toqk4/RqlKYjnvyMBAurvXhLoP31CmKQcmAQdqSapW83jxFbNMxjZGHb75lvd5KNm2t0vRkRWKTpkgtmaTMedcEvHOMo6zz11fX5OOJmiU71PfdmZGupXLOPDX6wGoN1Vkev3uLzfJ9KUUAKqh5S9Mw5ug1DJALKY6kOLF9/oJ2vZG61zSnFbhza1jJiWm3I2wuwFma4Ll59YL9/QO1eLqVxGCRUW261OOGvqX1nhILOVfCpld5Sea03+HDb6fic5lllllmmf/3mDrnlSyzzDLLLLPMMssss8yf49j//z+yzDLLLLPMMssss8wyv/1ZgOgyyyyzzDLLLLPMMj/LLEB0mWWWWWaZZZZZZpmfZRYguswyyyyzzDLLLLPMzzILEF1mmWWWWWaZZZZZ5meZBYgus8wyyyyzzDLLLPOzzAJEl1lmmWWWWWaZZZb5WWYBossss8wyyyyzzDLL/CyzANFllllmmWWWWWaZZX6W+X8APCKO0MansPkAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create generators for the video frames\n", + "num_frames = 150\n", + "\n", + "frames1 = img_arr\n", + "height, width, _ = frames1[0].shape\n", + "\n", + "track_path = '/home/haw027/code/private-physics-bench/stimuli/stimuli/generation/placement/b3d_track_imgs'\n", + "frames2_base = [\n", + " np.array(Image.open(join(track_path, f'{config}_{trial_index.zfill(4)}_{i}.png')))\n", + " for i in range(STOP_T)\n", + " ]\n", + "\n", + "for room in range(20):\n", + " print(room)\n", + " simulation_path = '/home/haw027/code/private-physics-bench/stimuli/stimuli/generation/placement/b3d_simulation_imgs/'\n", + " frames2 = frames2_base+[np.array(Image.open(join(simulation_path, f'{config}_{trial_index.zfill(4)}_room{room}_frame{i}.png')))\n", + " for i in range(num_frames)]\n", + "\n", + " # Initialize the figure\n", + " fig, axes = plt.subplots(1, 2, figsize=(2 * width / 100, height / 100), gridspec_kw={'wspace': 0, 'hspace': 0})\n", + " ax1, ax2 = axes\n", + " ax1.axis('off')\n", + " ax2.axis('off')\n", + "\n", + " # Initialize the images\n", + " im1 = ax1.imshow(frames1[0])\n", + " im2 = ax2.imshow(frames2[0])\n", + "\n", + " # Update function for the animation\n", + " def update(frame):\n", + " # try:\n", + " if frame >= STOP_T:\n", + " frame1 = frames1[STOP_T-1]\n", + " else:\n", + " frame1 = frames1[frame]\n", + " frame2 = frames2[frame]\n", + " im1.set_data(frame1)\n", + " im2.set_data(frame2)\n", + " # except StopIteration:\n", + " # anim.event_source.stop() # Stop the animation when frames are exhausted\n", + "\n", + " # Create the animation\n", + " anim = FuncAnimation(fig, update, frames=len(frames2), interval=100, repeat=False)\n", + "\n", + " # Display the animation\n", + " # plt.show()\n", + " plt.tight_layout()\n", + "\n", + " anim.save(f\"/home/haw027/code/private-physics-bench/stimuli/stimuli/generation/placement/videos/track+simulation_{room}_wo_gt.gif\", writer=\"pillow\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "gpu", + "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.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/demos/graphics_edits_demo/demo_visualize.py b/demos/graphics_edits_demo/demo_visualize.py index ca0f5df8..c73713be 100644 --- a/demos/graphics_edits_demo/demo_visualize.py +++ b/demos/graphics_edits_demo/demo_visualize.py @@ -22,7 +22,7 @@ # "shared_data_bucket/input_data/shout_on_desk.r3d.video_input.npz") "shared_data_bucket/input_data/desk_ramen2_spray1.r3d.video_input.npz", ) -video_input = b3d.VideoInput.load(path) +video_input = b3d.io.VideoInput.load(path) data, object_library = pickle.load(open("demo_data.dat", "rb")) diff --git a/demos/tracking_online_learning.py b/demos/tracking_online_learning.py index 2bde0719..1ec8ca8f 100644 --- a/demos/tracking_online_learning.py +++ b/demos/tracking_online_learning.py @@ -2,6 +2,7 @@ from functools import partial import b3d +import b3d.bayes3d as bayes3d import genjax import jax import jax.numpy as jnp @@ -56,7 +57,7 @@ color_error, depth_error = (60.0, 0.01) inlier_score, outlier_prob = (5.0, 0.00001) color_multiplier, depth_multiplier = (10000.0, 500.0) -model_args = b3d.ModelArgs( +model_args = bayes3d.ModelArgs( color_error, depth_error, inlier_score, @@ -104,7 +105,7 @@ # Creates renderer and generative model. renderer = b3d.Renderer(image_width, image_height, fx, fy, cx, cy, near, far) -model = b3d.model_multiobject_gl_factory(renderer) +model = bayes3d.model_multiobject_gl_factory(renderer) # Arguments of the generative model. # These control the inlier / outlier decision boundary for color error and depth error. @@ -154,14 +155,14 @@ @partial(jax.jit, static_argnames=["addressses"]) def enumerative_proposal(trace, addressses, key, all_deltas): addr = addressses.const[0] - current_pose = trace[addr] + current_pose = trace.get_choices()[addr] for i in range(len(all_deltas)): test_poses = current_pose @ all_deltas[i] potential_scores = b3d.enumerate_choices_get_scores( - trace, jax.random.PRNGKey(0), addressses, test_poses + trace, addressses, test_poses ) current_pose = test_poses[potential_scores.argmax()] - trace = b3d.update_choices(trace, key, addressses, current_pose) + trace = b3d.update_choices(trace, addressses, current_pose) return trace, key @@ -175,7 +176,7 @@ def enumerative_proposal(trace, addressses, key, all_deltas): START_T = 0 trace, _ = importance_jit( jax.random.PRNGKey(0), - genjax.choice_map( + genjax.ChoiceMap.d( dict( [ ("camera_pose", Pose.identity()), @@ -191,7 +192,7 @@ def enumerative_proposal(trace, addressses, key, all_deltas): (jnp.arange(4), model_args, object_library), ) # Visualize trace -b3d.rerun_visualize_trace_t(trace, 0) +bayes3d.rerun_visualize_trace_t(trace, 0) key = jax.random.PRNGKey(0) inference_data_over_time = [] @@ -202,22 +203,21 @@ def enumerative_proposal(trace, addressses, key, all_deltas): ) ): # Constrain on new RGB and Depth data. - trace = b3d.update_choices_jit( + trace = b3d.update_choices( trace, - key, genjax.Pytree.const(["observed_rgb_depth"]), (rgbs_resized[T_observed_image], xyzs[T_observed_image, ..., 2]), ) # Enumerate, score, and update camera pose trace, key = enumerative_proposal( - trace, genjax.Pytree.const(["camera_pose"]), key, all_deltas + trace, genjax.Pytree.const(("camera_pose",)), key, all_deltas ) for i in range(1, len(object_library.ranges)): # Enumerate, score, update each objects pose trace, key = enumerative_proposal( - trace, genjax.Pytree.const([f"object_pose_{i}"]), key, all_deltas + trace, genjax.Pytree.const((f"object_pose_{i}",)), key, all_deltas ) - b3d.rerun_visualize_trace_t(trace, T_observed_image) + bayes3d.rerun_visualize_trace_t(trace, T_observed_image) inference_data_over_time.append( ( b3d.get_poses_from_trace(trace), @@ -286,7 +286,7 @@ def enumerative_proposal(trace, addressses, key, all_deltas): next_object_id = len(object_library.ranges) - 1 trace = trace.update( key, - genjax.choice_map( + genjax.ChoiceMap.d( { f"object_{next_object_id}": next_object_id, # Add identity of new object to trace. f"object_pose_{next_object_id}": trace["camera_pose"] @@ -302,7 +302,7 @@ def enumerative_proposal(trace, addressses, key, all_deltas): (jnp.arange(4), model_args, object_library) ), )[0] - b3d.rerun_visualize_trace_t(trace, REAQUISITION_T) + bayes3d.rerun_visualize_trace_t(trace, REAQUISITION_T) inference_data_over_time.append( ( b3d.get_poses_from_trace(trace), @@ -332,7 +332,7 @@ def enumerative_proposal(trace, addressses, key, all_deltas): (jnp.arange(4), model_args, object_library) ), )[0] - b3d.rerun_visualize_trace_t(trace, t) + bayes3d.rerun_visualize_trace_t(trace, t) rr.set_time_sequence("frame", t) rgb_inliers, rgb_outliers = b3d.get_rgb_inlier_outlier_from_trace(trace) diff --git a/notebooks/aug1demos/slam_color_room.ipynb b/notebooks/aug1demos/slam_color_room.ipynb index 0c0f059d..a8273e85 100644 --- a/notebooks/aug1demos/slam_color_room.ipynb +++ b/notebooks/aug1demos/slam_color_room.ipynb @@ -1621,7 +1621,7 @@ "# convert_rgbd_to_color_space = lambda x: b3d.colors.rgbd_to_labd(x)\n", "# convert_color_space_to_rgbd = lambda x: b3d.colors.labd_to_rgbd(x)\n", "def intermediate_likelihood_func(observed_rgbd, latent_rgbd, likelihood_args):\n", - " k = likelihood_args[\"k\"].const\n", + " k = likelihood_args[\"k\"].unwrap()\n", " fx = likelihood_args[\"fx\"]\n", " fy = likelihood_args[\"fy\"]\n", "\n", diff --git a/notebooks/bayes3d_paper/interactive.ipynb b/notebooks/bayes3d_paper/interactive.ipynb index b4724748..670fbde8 100644 --- a/notebooks/bayes3d_paper/interactive.ipynb +++ b/notebooks/bayes3d_paper/interactive.ipynb @@ -169,7 +169,7 @@ "# def sample_likelihood_func()\n", "\n", "def intermediate_likelihood_func(observed_rgbd, latent_rgbd, likelihood_args):\n", - " k = likelihood_args[\"k\"].const\n", + " k = likelihood_args[\"k\"].unwrap()\n", " fx = likelihood_args[\"fx\"]\n", " fy = likelihood_args[\"fy\"]\n", " \n", @@ -628,16 +628,16 @@ " rendered_rgbd = renderer.render_rgbd_from_mesh(meshes[IDX].transform(pose))\n", " rendered_color_space_d = convert_rgbd_to_color_space(rendered_rgbd)\n", "\n", - " k = likelihood_args[\"k\"].const\n", + " k = likelihood_args[\"k\"].unwrap()\n", " image_height, image_width = rendered_color_space_d.shape[0], rendered_color_space_d.shape[1]\n", " image_height = Pytree.const(image_height)\n", " image_width = Pytree.const(image_width)\n", "\n", " row_coordinates = genjax.categorical.vmap(in_axes=(0,))(\n", - " jnp.ones((k, image_height.const))\n", + " jnp.ones((k, image_height.unwrap()))\n", " ) @ \"row_coordinates\"\n", " column_coordinates = genjax.categorical.vmap(in_axes=(0,))(\n", - " jnp.ones((k, image_width.const))\n", + " jnp.ones((k, image_width.unwrap()))\n", " ) @ \"column_coordinates\"\n", "\n", "\n", diff --git a/notebooks/bayes3d_paper/old_inference_algorithm.ipynb b/notebooks/bayes3d_paper/old_inference_algorithm.ipynb new file mode 100644 index 00000000..5e9aa9bf --- /dev/null +++ b/notebooks/bayes3d_paper/old_inference_algorithm.ipynb @@ -0,0 +1,412 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "### IMPORTS ###\n", + "\n", + "import b3d\n", + "import jax.numpy as jnp\n", + "import os\n", + "from b3d import Mesh, Pose\n", + "import jax\n", + "import genjax\n", + "from genjax import Pytree\n", + "import rerun as rr\n", + "from b3d.modeling_utils import uniform_discrete, uniform_pose, gaussian_vmf\n", + "import matplotlib.pyplot as plt\n", + "from functools import partial\n", + "import importlib\n", + "from ipywidgets import interact\n", + "import ipywidgets as widgets\n", + "from tqdm import tqdm\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from genjax import SelectionBuilder as S\n", + "from genjax import ChoiceMapBuilder as C" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Scene 49\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 49/49 [00:03<00:00, 12.69it/s]\n", + "/home/nishadgothoskar/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/torch/utils/cpp_extension.py:1967: UserWarning: TORCH_CUDA_ARCH_LIST is not set, all archs for visible cards are included for compilation. \n", + "If this is not desired, please set os.environ['TORCH_CUDA_ARCH_LIST'].\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Loading data ###\n", + "b3d.reload(b3d.io.data_loader)\n", + "scene_id = 49\n", + "FRAME_RATE = 50\n", + "ycb_dir = os.path.join(b3d.get_assets_path(), \"bop/ycbv\")\n", + "print(f\"Scene {scene_id}\")\n", + "b3d.reload(b3d.io.data_loader)\n", + "num_scenes = b3d.io.data_loader.get_ycbv_num_images(scene_id, subdir=\"test\")\n", + "\n", + "# image_ids = [image] if image is not None else range(1, num_scenes, FRAME_RATE)\n", + "image_ids = range(1, num_scenes + 1, FRAME_RATE)\n", + "all_data = b3d.io.data_loader.get_ycbv_data(scene_id, image_ids, subdir=\"test\")\n", + "\n", + "meshes = [\n", + " Mesh.from_obj_file(\n", + " os.path.join(ycb_dir, f'models/obj_{f\"{id + 1}\".rjust(6, \"0\")}.ply')\n", + " ).scale(0.001)\n", + " for id in all_data[0][\"object_types\"]\n", + "]\n", + "\n", + "image_height, image_width = all_data[0][\"rgbd\"].shape[:2]\n", + "fx,fy,cx,cy = all_data[0][\"camera_intrinsics\"]\n", + "scaling_factor = 1.0\n", + "renderer = b3d.renderer.renderer_original.RendererOriginal(\n", + " image_width * scaling_factor, image_height * scaling_factor, fx * scaling_factor, fy * scaling_factor, cx * scaling_factor, cy * scaling_factor, 0.01, 2.0\n", + ")\n", + "b3d.viz_rgb(all_data[0][\"rgbd\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-214395.84\n" + ] + } + ], + "source": [ + "import b3d\n", + "import b3d.chisight.gen3d.model\n", + "b3d.reload(b3d.chisight.gen3d.model)\n", + "import b3d.chisight.gen3d.transition_kernels as transition_kernels\n", + "b3d.reload(b3d.chisight.gen3d.transition_kernels)\n", + "import b3d.chisight.gen3d.image_kernel as image_kernel\n", + "import b3d.chisight.gen3d.pixel_kernels.pixel_rgbd_kernels as pixel_rgbd_kernels\n", + "b3d.reload(b3d.chisight.gen3d.image_kernel)\n", + "b3d.reload(b3d.chisight.gen3d.model)\n", + "import b3d.io.data_loader\n", + "import jax\n", + "import jax.numpy as jnp\n", + "from b3d import Mesh, Pose\n", + "from b3d.chisight.gen3d.model import (\n", + " make_colors_choicemap,\n", + " make_depth_nonreturn_prob_choicemap,\n", + " make_visibility_prob_choicemap,\n", + ")\n", + "from b3d.chisight.gen3d.model import dynamic_object_generative_model\n", + "from genjax import ChoiceMapBuilder as C\n", + "from genjax import Pytree\n", + "import b3d.chisight.gen3d.inference.inference as inference\n", + "import b3d.chisight.gen3d.settings \n", + "b3d.reload(b3d.chisight.gen3d.inference)\n", + "inference_hyperparams = b3d.chisight.gen3d.settings.inference_hyperparams\n", + "import b3d.chisight.gen3d.visualization as viz\n", + "b3d.reload(b3d.chisight.gen3d.visualization)\n", + "import b3d.chisight.gen3d.visualization as viz\n", + "import b3d.chisight.gen3d.image_kernel\n", + "b3d.reload(b3d.chisight.gen3d.image_kernel)\n", + "\n", + "b3d.rr_init(\"dynamics2\")\n", + "T = 0\n", + "b3d.rr_set_time(T)\n", + "OBJECT_INDEX = 2\n", + "\n", + "template_pose = all_data[T][\"camera_pose\"].inv() @ all_data[T][\"object_poses\"][OBJECT_INDEX]\n", + "rendered_rgbd = renderer.render_rgbd_from_mesh(meshes[OBJECT_INDEX].transform(template_pose))\n", + "xyz_rendered = b3d.xyz_from_depth(rendered_rgbd[..., 3], fx, fy, cx, cy)\n", + "\n", + "fx, fy, cx, cy = all_data[T][\"camera_intrinsics\"]\n", + "xyz_observed = b3d.xyz_from_depth(all_data[T][\"rgbd\"][..., 3], fx, fy, cx, cy)\n", + "mask = all_data[T][\"masks\"][OBJECT_INDEX] * (xyz_observed[..., 2] > 0) * (jnp.linalg.norm(xyz_rendered - xyz_observed, axis=-1) < 0.01)\n", + "model_vertices = template_pose.inv().apply(xyz_rendered[mask])\n", + "model_colors = vertex_attributes=all_data[T][\"rgbd\"][..., :3][mask]\n", + "\n", + "# subset = jax.random.permutation(jax.random.PRNGKey(0), len(model_vertices))[:len(model_vertices) // 2]\n", + "# model_vertices = model_vertices[subset]\n", + "# model_colors = model_colors[subset]\n", + "# mesh = meshes[OBJECT_INDEX]\n", + "# model_vertices = mesh.vertices\n", + "# model_colors = mesh.vertex_attributes\n", + "\n", + "intrinsics = {\n", + " \"fx\": fx, \"fy\": fy, \"cx\": cx, \"cy\": cy,\n", + " \"image_height\": Pytree.const(image_height),\n", + " \"image_width\": Pytree.const(image_width),\n", + " \"near\": 0.01,\n", + " \"far\": 3.0,\n", + "}\n", + "\n", + "import b3d.chisight.gen3d.settings \n", + "b3d.reload(b3d.chisight.gen3d.settings)\n", + "hyperparams = b3d.chisight.gen3d.settings.hyperparams\n", + "inference_hyperparams = b3d.chisight.gen3d.settings.inference_hyperparams\n", + "hyperparams[\"intrinsics\"] = intrinsics\n", + "hyperparams[\"vertices\"] = model_vertices\n", + "\n", + "\n", + "num_vertices = model_vertices.shape[0]\n", + "previous_state = {\n", + " \"pose\": template_pose,\n", + " \"colors\": model_colors,\n", + " \"visibility_prob\": jnp.ones(num_vertices)\n", + " * hyperparams[\"visibility_prob_kernel\"].support[-1],\n", + " \"depth_nonreturn_prob\": jnp.ones(num_vertices)\n", + " * hyperparams[\"depth_nonreturn_prob_kernel\"].support[0],\n", + " \"depth_scale\": hyperparams[\"depth_scale_kernel\"].support[0],\n", + " \"color_scale\": hyperparams[\"color_scale_kernel\"].support[0],\n", + "}\n", + "\n", + "choicemap = (\n", + " genjax.ChoiceMap.d(\n", + " {\n", + " \"pose\": previous_state[\"pose\"],\n", + " \"color_scale\": previous_state[\"color_scale\"],\n", + " \"depth_scale\": previous_state[\"depth_scale\"],\n", + " \"rgbd\": all_data[T][\"rgbd\"],\n", + " }\n", + " ) ^ \n", + " make_visibility_prob_choicemap(previous_state[\"visibility_prob\"]) ^\n", + " make_colors_choicemap(previous_state[\"colors\"]) ^\n", + " make_depth_nonreturn_prob_choicemap(previous_state[\"depth_nonreturn_prob\"])\n", + ")\n", + "key = jax.random.PRNGKey(0)\n", + "\n", + "trace= dynamic_object_generative_model.importance(key, choicemap, (hyperparams, previous_state))[0]\n", + "print(trace.get_score())\n", + "og_trace = trace\n", + "b3d.chisight.gen3d.model.viz_trace(trace, T,\n", + " ground_truth_vertices=meshes[OBJECT_INDEX].vertices,\n", + " ground_truth_pose=all_data[T][\"camera_pose\"].inv() @ all_data[T][\"object_poses\"][OBJECT_INDEX] \n", + ")\n", + "results = {}" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/nishadgothoskar/b3d/src/b3d/modeling_utils.py:87: UserWarning: RenormalizedLaplace sampling is currently not implemented perfectly.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "T = 0 \n", + "trace = inference.inference_step(\n", + " key,\n", + " trace,\n", + " all_data[T][\"rgbd\"],\n", + " inference_hyperparams,\n", + " use_gt_pose=False,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "traces = [\n", + " trace.update(\n", + " key,\n", + " C.d({\n", + " \"rgbd\": all_data[T][\"rgbd\"],\n", + " \"pose\": all_data[T][\"camera_pose\"].inv() @ all_data[T][\"object_poses\"][OBJECT_INDEX],\n", + " })\n", + " )[0]\n", + " for T in range(len(all_data ))\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import b3d.chisight.gen3d.visualization as viz\n", + "viz.make_video_from_traces(\n", + " traces,\n", + " \"output_video_test.mp4\", \n", + " scale=0.25\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import b3d.chisight.gen3d.inference as inference\n", + "import b3d.chisight.gen3d.settings \n", + "b3d.reload(b3d.chisight.gen3d.inference)\n", + "inference_hyperparams = b3d.chisight.gen3d.settings.inference_hyperparams\n", + "import b3d.chisight.gen3d.visualization as viz\n", + "b3d.reload(b3d.chisight.gen3d.visualization)\n", + "import b3d.chisight.gen3d.visualization as viz\n", + "import b3d.chisight.gen3d.image_kernel\n", + "b3d.reload(b3d.chisight.gen3d.image_kernel)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/45 [00:00 0) - * (jnp.linalg.norm(xyz_rendered - xyz_observed, axis=-1) < 0.01) - ) - mesh = Mesh( - vertices=template_pose.inv().apply(xyz_rendered[mask]), - faces=jnp.zeros((0, 3), dtype=jnp.int32), - vertex_attributes=all_data[T]["rgbd"][..., :3][mask], - ) - - outlier_probability_sweep = jnp.array([0.05, 1.0]) - - choicemap = genjax.ChoiceMap.d( - { - "rgbd": all_data[T]["rgbd"], - "camera_pose": Pose.identity(), - "object_pose_0": template_pose, - "outlier_probability": jnp.ones(len(mesh.vertices)) - * outlier_probability_sweep[0], - "color_noise_variance": 0.05, - "depth_noise_variance": 0.01, - } - ) - - trace0, _ = importance_jit( - jax.random.PRNGKey(2), - choicemap, - ( - { - "num_objects": Pytree.const(1), - "meshes": [mesh], - "likelihood_args": likelihood_args, - }, - ), - ) - key = jax.random.PRNGKey(100) - - trace = trace0 - tracking_results = {} - for T in tqdm(range(len(all_data))): - trace = b3d.update_choices( - trace, - Pytree.const(("rgbd",)), - all_data[T]["rgbd"], - ) - - for _ in range(5): - trace, key = gvmf_and_select_best_move( - trace, - key, - 0.01, - 1000.0, - Pytree.const(("object_pose_0",)), - 10000, - ) - trace, key = gvmf_and_select_best_move( - trace, - key, - 0.005, - 2000.0, - Pytree.const(("object_pose_0",)), - 10000, - ) - # viz_trace(trace, T) - - if T % 1 == 0: - trace = b3d.bayes3d.enumerative_proposals.enumerate_and_select_best( - trace, - Pytree.const(("color_noise_variance",)), - jnp.linspace(0.05, 0.1, 10), - ) - trace = b3d.bayes3d.enumerative_proposals.enumerate_and_select_best( - trace, - Pytree.const(("depth_noise_variance",)), - jnp.linspace(0.005, 0.01, 10), - ) - - current_outlier_probabilities = trace.get_choices()[ - "outlier_probability" - ] - scores = grid_outlier_prob( - trace, - outlier_probability_sweep[..., None] - * jnp.ones_like(current_outlier_probabilities), - ) - trace = b3d.update_choices( - trace, - Pytree.const(("outlier_probability",)), - outlier_probability_sweep[jnp.argmax(scores, axis=0)], - ) - - current_outlier_probabilities = trace.get_choices()[ - "outlier_probability" - ] - # b3d.rr_log_cloud( - # mesh.vertices, - # colors=colors[1 * (current_outlier_probabilities == outlier_probability_sweep[0])], - # channel="cloud/outlier_probabilities" - # ) - - info = info_from_trace(trace) - current_outlier_probabilities = trace.get_choices()[ - "outlier_probability" - ] - model_rgbd, observed_rgbd = ( - info["model_rgbd"], - info["corresponding_observed_rgbd"], - ) - deltas = observed_rgbd - model_rgbd - deltas_clipped = jnp.clip(deltas, -0.05, 0.05) - new_model_rgbd = model_rgbd + deltas_clipped - - mesh = trace.get_args()[0]["meshes"][0] - is_inlier = ( - current_outlier_probabilities == outlier_probability_sweep[0] - ) - mesh.vertex_attributes = mesh.vertex_attributes.at[is_inlier].set( - new_model_rgbd[is_inlier, :3] - ) - - trace, _ = importance_jit( - jax.random.PRNGKey(2), - trace.get_choices(), - ( - { - "num_objects": Pytree.const(1), - "meshes": [mesh], - "likelihood_args": likelihood_args, - }, - ), - ) - tracking_results[T] = trace - if debug: - viz_trace(trace, T) - - inferred_poses = Pose.stack_poses( - [ - tracking_results[t].get_choices()["object_pose_0"] - for t in range(len(all_data)) - ] - ) - jnp.savez( - f"SCENE_{scene_id}_OBJECT_INDEX_{OBJECT_INDEX}_POSES.npy", - position=inferred_poses.position, - quaternion=inferred_poses.quat, - ) - - trace = tracking_results[len(all_data) - 1] - info = info_from_trace(trace) - rendered_rgbd = info["latent_rgbd"] - - a = b3d.viz_rgb( - trace.get_choices()["rgbd"][..., :3], - ) - b = b3d.viz_rgb( - rendered_rgbd[..., :3], - ) - b3d.multi_panel([a, b, b3d.overlay_image(a, b)]).save( - f"photo_SCENE_{scene_id}_OBJECT_INDEX_{OBJECT_INDEX}_POSES.png" - ) - - -if __name__ == "__main__": - fire.Fire(run_tracking) diff --git a/notebooks/bayes3d_paper/online_hb.ipynb b/notebooks/bayes3d_paper/tester.ipynb similarity index 91% rename from notebooks/bayes3d_paper/online_hb.ipynb rename to notebooks/bayes3d_paper/tester.ipynb index 4c03e8ba..9b373c03 100644 --- a/notebooks/bayes3d_paper/online_hb.ipynb +++ b/notebooks/bayes3d_paper/tester.ipynb @@ -6,8 +6,15 @@ "metadata": {}, "outputs": [], "source": [ - "%load_ext autoreload\n", - "%autoreload 2" + "# %load_ext autoreload\n", + "# %autoreload 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup" ] }, { @@ -16,29 +23,14 @@ "metadata": {}, "outputs": [], "source": [ - "### IMPORTS ###\n", - "\n", "import b3d\n", "import jax.numpy as jnp\n", "import os\n", - "from b3d import Mesh, Pose\n", - "import jax\n", - "import genjax\n", - "from genjax import Pytree\n", - "import rerun as rr\n", - "from b3d.modeling_utils import uniform_discrete, uniform_pose, gaussian_vmf\n", - "import matplotlib.pyplot as plt\n", - "from functools import partial\n", - "import importlib\n", - "from ipywidgets import interact\n", - "import ipywidgets as widgets\n", "from tqdm import tqdm\n", + "from b3d import Mesh, Pose\n", "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "from genjax import SelectionBuilder as S\n", - "from genjax import ChoiceMapBuilder as C\n", - "\n", - "b3d.rr_init(\"dynamics\")" + "import genjax\n", + "# genjax.pretty()" ] }, { @@ -57,7 +49,17 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 49/49 [00:03<00:00, 13.80it/s]\n" + " 0%| | 0/49 [00:00 0) * (jnp.linalg.norm(xyz_rendered - xyz_observed, axis=-1) < 0.01)\n", "model_vertices = template_pose.inv().apply(xyz_rendered[mask])\n", - "model_colors = vertex_attributes=all_data[T][\"rgbd\"][..., :3][mask]\n", - "\n", - "hyperparams = {\n", - " \"vertices\": model_vertices,\n", - " \"max_color_shift\": 0.1,\n", - " \"max_pose_position_shift\": 0.1,\n", - " \"fx\": fx,\n", - " \"fy\": fy,\n", - " \"cx\": cx,\n", - " \"cy\": cy,\n", - " \"image_height\": Pytree.const(image_height),\n", - " \"image_width\": Pytree.const(image_width),\n", - " \"color_transition_kernel\": drift_kernels.GaussianColorDriftKernel(scale=0.1),\n", - " # Example of writing a mixture kernel:\n", - " # \"color_transition_kernel\": drift_kernels.MixtureDriftKernel(\n", - " # (drift_kernels.UniformColorDriftKernel(max_shift=0.1), drift_kernels.LaplaceColorDriftKernel(scale=0.1)),\n", - " # jnp.array([0.02, 0.98])\n", - " # ),\n", - " \"color_outlier_probability_transition_kernel\": drift_kernels.GaussianDriftKernel(scale=0.1, min_val=0.0, max_val=1.0),\n", - " \"depth_outlier_probability_transition_kernel\": drift_kernels.GaussianDriftKernel(scale=0.1, min_val=0.0, max_val=1.0),\n", - "}\n", - "\n", - "previous_state = {\n", - " \"pose\": template_pose,\n", - " \"colors\": model_colors,\n", - " \"color_outlier_probabilities\": jnp.ones(len(model_vertices)) * 0.01,\n", - " \"depth_outlier_probabilities\": jnp.ones(len(model_vertices)) * 0.01,\n", - "}\n", - "\n", - "choicemap = (\n", - " genjax.ChoiceMap.d(\n", - " {\n", - " \"pose\": previous_state[\"pose\"],\n", - " \"color_variance\": 0.1,\n", - " \"depth_variance\": 0.005,\n", - " \"rgbd\": all_data[T][\"rgbd\"],\n", - " }\n", - " ) ^ \n", - " make_depth_outlier_probabilities_choicemap(previous_state[\"depth_outlier_probabilities\"]) ^\n", - " make_color_outlier_probabilities_choicemap(previous_state[\"color_outlier_probabilities\"]) ^\n", - " make_colors_choicemap(previous_state[\"colors\"])\n", - ")\n", - "key = jax.random.PRNGKey(0)\n", - "trace, _ = b3d.chisight.dynamic_object_model.dynamic_object_model.dynamic_object_generative_model.importance(key, choicemap, (hyperparams, previous_state))\n", - "print(trace.get_score())\n", - "viz_trace(trace, 0)\n", - "results = {}" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pose(position=Array([-0.06365717, -0.06389732, 0.9016483 ], dtype=float32), quaternion=Array([ 0.25908902, -0.87780774, 0.36045524, 0.17999579], dtype=float32))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pose(position=Array([-0.06617196, -0.06403518, 0.9024389 ], dtype=float32), quaternion=Array([ 0.26273286, -0.86704 , 0.38232538, 0.18177064], dtype=float32))\n" - ] - } - ], - "source": [ - "T = 0\n", - "key = jax.random.split(key)[1]\n", - "print(trace.get_choices()[\"pose\"])\n", - "new_trace = inference_step_without_advance(trace, key)\n", - "print(new_trace.get_choices()[\"pose\"])\n", - "viz_trace(new_trace, T+1, ground_truth_vertices=meshes[OBJECT_INDEX].vertices, ground_truth_pose=all_data[T][\"camera_pose\"].inv() @ all_data[T][\"object_poses\"][OBJECT_INDEX])" + "model_colors = vertex_attributes=all_data[T][\"rgbd\"][..., :3][mask]\n" ] }, { - "cell_type": "code", - "execution_count": 13, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 0%| | 0/49 [00:00" + "Array(91953.95, dtype=float32)" ] }, - "execution_count": 258, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ - "T = 0\n", - "color_outlier_probability_sweep = jnp.array([0.01, 0.25, 0.5, 0.75, 1.0])\n", - "scores_per_sweep_point_and_vertex = propose_color_and_color_outlier_probability(trace, key, color_outlier_probability_sweep)[-1]\n", - "print(scores_per_sweep_point_and_vertex[...,0])\n", - "plt.matshow(b3d.normalize_log_scores(scores_per_sweep_point_and_vertex[...,0]))\n", - "plt.colorbar()" + "key = jax.random.PRNGKey(0)\n", + "og_trace, weight = b3d.chisight.gen3d.model.dynamic_object_generative_model.importance(key, choicemap, (hyperparams, previous_state))\n", + "trace = og_trace\n", + "weight" ] }, { "cell_type": "code", - "execution_count": 105, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "Array(91953.95, dtype=float32)" ] }, - "execution_count": 105, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ - "plt.plot(b3d.normalize_log_scores(scores_per_sweep_point_and_vertex[0,:, 0]))" + "trace.get_score()" ] }, { @@ -421,621 +278,334 @@ "source": [] }, { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 17, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pose(position=Array([-0.06365717, -0.06389732, 0.9016483 ], dtype=float32), quaternion=Array([ 0.25908902, -0.87780774, 0.36045524, 0.17999579], dtype=float32))\n", - "Pose(position=Array([-0.06365717, -0.06389732, 0.9016483 ], dtype=float32), quaternion=Array([ 0.25908902, -0.87780774, 0.36045524, 0.17999579], dtype=float32))\n" - ] - } - ], - "source": [ - "T = 0\n", - "print(trace.get_choices()[\"pose\"])\n", - "trace = inference_step_without_advance(trace, key)\n", - "print(trace.get_choices()[\"pose\"])\n", - "viz_trace(trace, T, ground_truth_vertices=meshes[OBJECT_INDEX].vertices, ground_truth_pose=all_data[T][\"camera_pose\"].inv() @ all_data[T][\"object_poses\"][OBJECT_INDEX])" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 0%| | 0/49 [00:00" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "plt.matshow(all_scores[:,:30])\n", - "plt.colorbar()" + "T = 0\n", + "b3d.rr_init(\"inference_1step\")" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 26, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 0%| | 0/49 [00:00 1\u001b[0m trace, step_weight, metadata \u001b[38;5;241m=\u001b[39m \u001b[43mi\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minference_step\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2\u001b[0m \u001b[43m \u001b[49m\u001b[43mjax\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrandom\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mPRNGKey\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m26\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[43m \u001b[49m\u001b[43mog_trace\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43mall_data\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mrgbd\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43minference_hyperparams\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[43mget_metadata\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 7\u001b[0m \u001b[43m \u001b[49m\u001b[43mgt_pose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgt_pose\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 8\u001b[0m \u001b[43m)\u001b[49m\n\u001b[1;32m 9\u001b[0m step_weight\n", + "File \u001b[0;32m~/b3d/src/b3d/chisight/gen3d/inference.py:175\u001b[0m, in \u001b[0;36minference_step\u001b[0;34m(key, old_trace, observed_rgbd, inference_hyperparams, *args, **kwargs)\u001b[0m\n\u001b[1;32m 173\u001b[0m k1, k2 \u001b[38;5;241m=\u001b[39m split(key)\n\u001b[1;32m 174\u001b[0m trace \u001b[38;5;241m=\u001b[39m advance_time(k1, old_trace, observed_rgbd)\n\u001b[0;32m--> 175\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43minfer_latents\u001b[49m\u001b[43m(\u001b[49m\u001b[43mk2\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrace\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minference_hyperparams\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + " \u001b[0;31m[... skipping hidden 11 frame]\u001b[0m\n", + "File \u001b[0;32m~/b3d/src/b3d/chisight/gen3d/inference.py:233\u001b[0m, in \u001b[0;36minfer_latents\u001b[0;34m(key, trace, inference_hyperparams, get_trace, get_weight, get_metadata, use_gt_pose, gt_pose, include_qscores_in_outer_resample)\u001b[0m\n\u001b[1;32m 224\u001b[0m log_q_poses \u001b[38;5;241m=\u001b[39m log_q_poses\u001b[38;5;241m.\u001b[39mat[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mset(\n\u001b[1;32m 225\u001b[0m jnp\u001b[38;5;241m.\u001b[39mwhere(\n\u001b[1;32m 226\u001b[0m use_gt_pose,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 229\u001b[0m )\n\u001b[1;32m 230\u001b[0m )\n\u001b[1;32m 232\u001b[0m param_generation_keys \u001b[38;5;241m=\u001b[39m split(k3, inference_hyperparams\u001b[38;5;241m.\u001b[39mn_poses)\n\u001b[0;32m--> 233\u001b[0m proposed_traces, log_q_nonpose_latents, other_latents_metadata \u001b[38;5;241m=\u001b[39m \u001b[43mjax\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvmap\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 234\u001b[0m \u001b[43m \u001b[49m\u001b[43mpropose_other_latents_given_pose\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43min_axes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 235\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparam_generation_keys\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrace\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mproposed_poses\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minference_hyperparams\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 236\u001b[0m p_scores \u001b[38;5;241m=\u001b[39m jax\u001b[38;5;241m.\u001b[39mvmap(\u001b[38;5;28;01mlambda\u001b[39;00m tr: tr\u001b[38;5;241m.\u001b[39mget_score())(proposed_traces)\n\u001b[1;32m 238\u001b[0m scores \u001b[38;5;241m=\u001b[39m jnp\u001b[38;5;241m.\u001b[39mwhere(\n\u001b[1;32m 239\u001b[0m include_qscores_in_outer_resample,\n\u001b[1;32m 240\u001b[0m p_scores \u001b[38;5;241m-\u001b[39m log_q_poses \u001b[38;5;241m-\u001b[39m log_q_nonpose_latents,\n\u001b[1;32m 241\u001b[0m p_scores,\n\u001b[1;32m 242\u001b[0m )\n", + " \u001b[0;31m[... skipping hidden 3 frame]\u001b[0m\n", + "File \u001b[0;32m~/b3d/src/b3d/chisight/gen3d/inference_moves.py:80\u001b[0m, in \u001b[0;36mpropose_other_latents_given_pose\u001b[0;34m(key, advanced_trace, pose, inference_hyperparams)\u001b[0m\n\u001b[1;32m 71\u001b[0m trace \u001b[38;5;241m=\u001b[39m update_field(k1, advanced_trace, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpose\u001b[39m\u001b[38;5;124m\"\u001b[39m, pose)\n\u001b[1;32m 73\u001b[0m k2a, k2b \u001b[38;5;241m=\u001b[39m split(k2)\n\u001b[1;32m 74\u001b[0m (\n\u001b[1;32m 75\u001b[0m colors,\n\u001b[1;32m 76\u001b[0m visibility_probs,\n\u001b[1;32m 77\u001b[0m depth_nonreturn_probs,\n\u001b[1;32m 78\u001b[0m log_q_point_attributes,\n\u001b[1;32m 79\u001b[0m point_proposal_metadata,\n\u001b[0;32m---> 80\u001b[0m ) \u001b[38;5;241m=\u001b[39m \u001b[43mpropose_all_pointlevel_attributes\u001b[49m\u001b[43m(\u001b[49m\u001b[43mk2a\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrace\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minference_hyperparams\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 81\u001b[0m trace \u001b[38;5;241m=\u001b[39m update_vmapped_fields(\n\u001b[1;32m 82\u001b[0m k2b,\n\u001b[1;32m 83\u001b[0m trace,\n\u001b[1;32m 84\u001b[0m [\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcolors\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvisibility_prob\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdepth_nonreturn_prob\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[1;32m 85\u001b[0m [colors, visibility_probs, depth_nonreturn_probs],\n\u001b[1;32m 86\u001b[0m )\n\u001b[1;32m 88\u001b[0m k3a, k3b \u001b[38;5;241m=\u001b[39m split(k3)\n", + "File \u001b[0;32m~/b3d/src/b3d/chisight/gen3d/inference_moves.py:117\u001b[0m, in \u001b[0;36mpropose_all_pointlevel_attributes\u001b[0;34m(key, trace, inference_hyperparams)\u001b[0m\n\u001b[1;32m 107\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mpropose_all_pointlevel_attributes\u001b[39m(key, trace, inference_hyperparams):\n\u001b[1;32m 108\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 109\u001b[0m \u001b[38;5;124;03m Propose a new color, visibility probability, and depth non-return probability\u001b[39;00m\n\u001b[1;32m 110\u001b[0m \u001b[38;5;124;03m for every vertex, conditioned upon the other values in `trace`.\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 115\u001b[0m \u001b[38;5;124;03m the overall log proposal density, and metadata is a dict.\u001b[39;00m\n\u001b[1;32m 116\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 117\u001b[0m observed_rgbds_per_point \u001b[38;5;241m=\u001b[39m \u001b[43mPixelsPointsAssociation\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfrom_hyperparams_and_pose\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 118\u001b[0m \u001b[43m \u001b[49m\u001b[43mget_hypers\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrace\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mget_new_state\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrace\u001b[49m\u001b[43m)\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mpose\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\n\u001b[1;32m 119\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mget_point_rgbds(get_observed_rgbd(trace))\n\u001b[1;32m 121\u001b[0m colors, visibility_probs, depth_nonreturn_probs, log_qs, metadata \u001b[38;5;241m=\u001b[39m jax\u001b[38;5;241m.\u001b[39mvmap(\n\u001b[1;32m 122\u001b[0m propose_a_points_attributes, in_axes\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m0\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[1;32m 123\u001b[0m )(\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 130\u001b[0m inference_hyperparams,\n\u001b[1;32m 131\u001b[0m )\n\u001b[1;32m 133\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m colors, visibility_probs, depth_nonreturn_probs, log_qs\u001b[38;5;241m.\u001b[39msum(), metadata\n", + "File \u001b[0;32m~/b3d/src/b3d/chisight/gen3d/projection.py:30\u001b[0m, in \u001b[0;36mPixelsPointsAssociation.from_hyperparams_and_pose\u001b[0;34m(cls, hyperparams, pose_CO)\u001b[0m\n\u001b[1;32m 25\u001b[0m vertices_O \u001b[38;5;241m=\u001b[39m hyperparams[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvertices\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 26\u001b[0m vertices_C \u001b[38;5;241m=\u001b[39m pose_CO\u001b[38;5;241m.\u001b[39mapply(vertices_O)\n\u001b[1;32m 27\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39mfrom_points_and_intrinsics(\n\u001b[1;32m 28\u001b[0m vertices_C,\n\u001b[1;32m 29\u001b[0m hyperparams[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mintrinsics\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[0;32m---> 30\u001b[0m \u001b[43mhyperparams\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mimage_height\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241m.\u001b[39munwrap(),\n\u001b[1;32m 31\u001b[0m hyperparams[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mimage_width\u001b[39m\u001b[38;5;124m\"\u001b[39m]\u001b[38;5;241m.\u001b[39munwrap(),\n\u001b[1;32m 32\u001b[0m )\n", + "\u001b[0;31mKeyError\u001b[0m: 'image_height'" ] } ], "source": [ - "from b3d.chisight.dynamic_object_model.dynamic_object_inference import (\n", - " propose_depth_outlier_probability,\n", - " propose_pose,\n", - " propose_color_and_color_outlier_probability\n", + "trace, step_weight, metadata = i.inference_step(\n", + " jax.random.PRNGKey(26),\n", + " og_trace,\n", + " all_data[1][\"rgbd\"],\n", + " inference_hyperparams,\n", + " get_metadata=True,\n", + " gt_pose=gt_pose(1),\n", ")\n", - "sampled_values, q_score = propose_depth_outlier_probability(trace, key, jnp.linspace(0.0, 1.0, 128))\n", - "print(sampled_values.max(), sampled_values.mean())\n", - "propose_pose(trace, key, 0.2, 200.0)\n", - "(\n", - " sampled_colors,\n", - " sampled_color_outlier_probabilities,\n", - " log_q_color_color_outlier_probability,\n", - ") = propose_color_and_color_outlier_probability(trace, key, jnp.array([0.0,0.5,1.0]))\n", - "print(sampled_color_outlier_probabilities.max(), sampled_color_outlier_probabilities.mean())" + "step_weight" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 19, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Array(0., dtype=float32)" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "sampled_color_outlier_probabilities.max()" + "T = 1\n", + "b3d.chisight.gen3d.model.viz_trace(trace, T, ground_truth_vertices=meshes[OBJECT_INDEX].vertices, ground_truth_pose=all_data[T][\"camera_pose\"].inv() @ all_data[T][\"object_poses\"][OBJECT_INDEX])" ] }, { - "cell_type": "code", - "execution_count": 27, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Array([[0.8196078 , 0.57647055, 0.4823529 ],\n", - " [0.92549014, 0.6666666 , 0. ],\n", - " [0.93725485, 0.6823529 , 0.3843137 ],\n", - " ...,\n", - " [0.45490193, 0.3215686 , 0.02745098],\n", - " [0.46274507, 0.3333333 , 0.03921568],\n", - " [0.32941175, 0.16862744, 0. ]], dtype=float32)" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sampled_colors" - ] + "source": [] }, { - "cell_type": "code", - "execution_count": 17, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "scores = jax.random.uniform(key, (3,3,100))\n", - "unravled = scores.reshape(-1, scores.shape[-1])\n", - "best = jnp.argmax(unravled, axis=0)\n", - "ii, jj = jnp.unravel_index(best, scores.shape[:2])" + "## Run against video, using a pose proposal that is guaranteed to propose the ground truth pose at least once" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 20, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0 0\n", - "[[0.6255783 0.04360759 0.2878412 ]\n", - " [0.4993825 0.37611675 0.41839683]\n", - " [0.43196762 0.29529083 0.03898191]]\n" - ] - } - ], + "outputs": [], "source": [ - "T = 5\n", - "print(ii[T],jj[T])\n", - "print(scores[:,:,T])" + "b3d.rr_init(\"inference_given_gtpose_5\")" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 21, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Array([[0.39757645, 0.1685257 , 0.8618102 ],\n", - " [0.90870774, 0.84168696, 0.06542301],\n", - " [0.63861954, 0.7479279 , 0.56785166]], dtype=float32)" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "scores[:,:,0]" + "b3d.reload(i)" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 34, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(Array([1, 0, 1, 2, 0, 0, 0, 1, 0, 0, 1, 2, 2, 0, 0, 1, 2, 2, 1, 2, 2, 2,\n", - " 1, 0, 2, 2, 0, 2, 0, 0, 0, 1, 0, 1, 2, 0, 1, 0, 2, 2, 0, 0, 1, 2,\n", - " 1, 1, 2, 1, 1, 1, 2, 1, 2, 0, 0, 1, 2, 2, 1, 1, 2, 0, 2, 1, 0, 1,\n", - " 0, 1, 0, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 2, 1, 0, 0, 1,\n", - " 1, 1, 0, 2, 0, 1, 0, 0, 0, 2, 2, 2], dtype=int32),\n", - " Array([0, 0, 2, 2, 0, 0, 1, 2, 2, 0, 1, 1, 1, 1, 2, 1, 2, 2, 2, 2, 1, 1,\n", - " 1, 2, 0, 0, 0, 1, 0, 1, 2, 0, 1, 2, 1, 2, 2, 0, 1, 0, 2, 0, 0, 0,\n", - " 2, 1, 2, 0, 0, 2, 0, 1, 0, 0, 2, 0, 0, 2, 1, 1, 2, 2, 0, 2, 2, 2,\n", - " 0, 1, 0, 0, 2, 1, 2, 1, 2, 0, 0, 0, 2, 2, 2, 0, 1, 2, 1, 2, 0, 2,\n", - " 0, 2, 1, 2, 0, 1, 1, 0, 2, 0, 1, 0], dtype=int32))" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "jnp.unravel_index(best, scores.shape[:2])" + "inference_hyperparams = i.InferenceHyperparams(\n", + " n_poses=1500,\n", + " do_stochastic_color_proposals=True,\n", + " pose_proposal_std=0.04,\n", + " pose_proposal_conc=1000.,\n", + " prev_color_proposal_laplace_scale=.04,\n", + " obs_color_proposal_laplace_scale=.02,\n", + ")" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 35, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "Array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", - " [3, 0, 5, 8, 0, 0, 1, 5, 2, 0, 4, 7, 7, 1, 2, 4, 8, 8, 5, 8, 7, 7,\n", - " 4, 2, 6, 6, 0, 7, 0, 1, 2, 3, 1, 5, 7, 2, 5, 0, 7, 6, 2, 0, 3, 6,\n", - " 5, 4, 8, 3, 3, 5, 6, 4, 6, 0, 2, 3, 6, 8, 4, 4, 8, 2, 6, 5, 2, 5,\n", - " 0, 4, 0, 0, 5, 1, 8, 1, 5, 0, 0, 3, 5, 5, 2, 0, 1, 8, 4, 2, 0, 5,\n", - " 3, 5, 1, 8, 0, 4, 1, 0, 2, 6, 7, 6]], dtype=int32)" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "indices" - ] - }, - { - "cell_type": "code", - "execution_count": 99, - "metadata": {}, - "outputs": [ + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/30 [00:00()\",\n", - ")\n", - "f(0.1, 0.1, 0.1)" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "metadata": {}, - "outputs": [ + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/20 [00:00 1\u001b[0m \u001b[43moutlier_probability_transition_kernel\u001b[49m\u001b[38;5;241m.\u001b[39mlogpdf\n", - "\u001b[0;31mNameError\u001b[0m: name 'outlier_probability_transition_kernel' is not defined" + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/georgematheos/b3d/src/b3d/modeling_utils.py:86: UserWarning: RenormalizedLaplace sampling is currently not implemented perfectly.\n", + " warnings.warn(\n", + "/home/georgematheos/b3d/src/b3d/modeling_utils.py:86: UserWarning: RenormalizedLaplace sampling is currently not implemented perfectly.\n", + " warnings.warn(\n", + "100%|██████████| 20/20 [02:35<00:00, 7.75s/it]\n" ] } ], "source": [ + "key = jax.random.PRNGKey(123)\n", + "trace = og_trace\n", + "for T in tqdm(range(20)):\n", + " key = b3d.split_key(key)\n", + " trace = i.inference_step_c2f(\n", + " key,\n", + " 1, # number of sequential iterations of the parallel pose proposal to consider\n", + " 5000, # number of poses to propose in parallel\n", + " # So the total number of poses considered at each step of C2F is 5000 * 1\n", + " trace, all_data[T][\"rgbd\"],\n", + " prev_color_proposal_laplace_scale=inference_hyperparams.prev_color_proposal_laplace_scale,\n", + " obs_color_proposal_laplace_scale=inference_hyperparams.obs_color_proposal_laplace_scale,\n", + " do_stochastic_color_proposals=True\n", + " )\n", + " b3d.chisight.gen3d.model.viz_trace(\n", + " trace,\n", + " T,\n", + " ground_truth_vertices=meshes[OBJECT_INDEX].vertices,\n", + " ground_truth_pose=all_data[T][\"camera_pose\"].inv() @ all_data[T][\"object_poses\"][OBJECT_INDEX]\n", + " )\n", "\n", - "outlier_probability_transition_kernel.logpdf" + "trace_20 = trace" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - " 0%| | 0/49 [00:00 6\u001b[0m trace \u001b[38;5;241m=\u001b[39m \u001b[43mi\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minference_step_c2f\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 7\u001b[0m \u001b[43m \u001b[49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 8\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# number of sequential iterations of the parallel pose proposal to consider\u001b[39;49;00m\n\u001b[1;32m 9\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m5000\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# number of poses to propose in parallel\u001b[39;49;00m\n\u001b[1;32m 10\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m# So the total number of poses considered at each step of C2F is 5000 * 1\u001b[39;49;00m\n\u001b[1;32m 11\u001b[0m \u001b[43m \u001b[49m\u001b[43mtrace\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mall_data\u001b[49m\u001b[43m[\u001b[49m\u001b[43mT\u001b[49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mrgbd\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 12\u001b[0m \u001b[43m \u001b[49m\u001b[43mprev_color_proposal_laplace_scale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minference_hyperparams\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mprev_color_proposal_laplace_scale\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 13\u001b[0m \u001b[43m \u001b[49m\u001b[43mobs_color_proposal_laplace_scale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minference_hyperparams\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mobs_color_proposal_laplace_scale\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 14\u001b[0m \u001b[43m \u001b[49m\u001b[43mdo_stochastic_color_proposals\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\n\u001b[1;32m 15\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 16\u001b[0m b3d\u001b[38;5;241m.\u001b[39mchisight\u001b[38;5;241m.\u001b[39mgen3d\u001b[38;5;241m.\u001b[39mmodel\u001b[38;5;241m.\u001b[39mviz_trace(\n\u001b[1;32m 17\u001b[0m trace,\n\u001b[1;32m 18\u001b[0m T,\n\u001b[1;32m 19\u001b[0m ground_truth_vertices\u001b[38;5;241m=\u001b[39mmeshes[OBJECT_INDEX]\u001b[38;5;241m.\u001b[39mvertices,\n\u001b[1;32m 20\u001b[0m ground_truth_pose\u001b[38;5;241m=\u001b[39mall_data[T][\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcamera_pose\u001b[39m\u001b[38;5;124m\"\u001b[39m]\u001b[38;5;241m.\u001b[39minv() \u001b[38;5;241m@\u001b[39m all_data[T][\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mobject_poses\u001b[39m\u001b[38;5;124m\"\u001b[39m][OBJECT_INDEX]\n\u001b[1;32m 21\u001b[0m )\n", + "File \u001b[0;32m~/b3d/src/b3d/chisight/gen3d/inference.py:100\u001b[0m, in \u001b[0;36minference_step_c2f\u001b[0;34m(key, n_seq, n_poses_per_sequential_step, old_trace, observed_rgbd, *args, **kwargs)\u001b[0m\n\u001b[1;32m 98\u001b[0m k1, k2 \u001b[38;5;241m=\u001b[39m split(key)\n\u001b[1;32m 99\u001b[0m trace \u001b[38;5;241m=\u001b[39m advance_time(k1, old_trace, observed_rgbd)\n\u001b[0;32m--> 100\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43minfer_latents_c2f\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 101\u001b[0m \u001b[43m \u001b[49m\u001b[43mk2\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mn_seq\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mn_poses_per_sequential_step\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrace\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\n\u001b[1;32m 102\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/b3d/src/b3d/chisight/gen3d/inference.py:121\u001b[0m, in \u001b[0;36minfer_latents_c2f\u001b[0;34m(key, n_seq, n_poses_per_sequential_step, trace, pose_proposal_std_conc_seq, **inference_hyperparam_kwargs)\u001b[0m\n\u001b[1;32m 114\u001b[0m inference_hyperparams \u001b[38;5;241m=\u001b[39m InferenceHyperparams(\n\u001b[1;32m 115\u001b[0m n_poses\u001b[38;5;241m=\u001b[39mn_poses_per_sequential_step,\n\u001b[1;32m 116\u001b[0m pose_proposal_std\u001b[38;5;241m=\u001b[39mstd,\n\u001b[1;32m 117\u001b[0m pose_proposal_conc\u001b[38;5;241m=\u001b[39mconc,\n\u001b[1;32m 118\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39minference_hyperparam_kwargs,\n\u001b[1;32m 119\u001b[0m )\n\u001b[1;32m 120\u001b[0m key, _ \u001b[38;5;241m=\u001b[39m split(key)\n\u001b[0;32m--> 121\u001b[0m trace, _ \u001b[38;5;241m=\u001b[39m \u001b[43minfer_latents_using_sequential_proposals\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 122\u001b[0m \u001b[43m \u001b[49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mn_seq\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrace\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minference_hyperparams\u001b[49m\n\u001b[1;32m 123\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 125\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m trace\n", + "File \u001b[0;32m~/b3d/src/b3d/chisight/gen3d/inference.py:153\u001b[0m, in \u001b[0;36minfer_latents_using_sequential_proposals\u001b[0;34m(key, n_seq, trace, inference_hyperparams)\u001b[0m\n\u001b[1;32m 151\u001b[0m k1, k2 \u001b[38;5;241m=\u001b[39m split(key)\n\u001b[1;32m 152\u001b[0m ks \u001b[38;5;241m=\u001b[39m split(k1, n_seq)\n\u001b[0;32m--> 153\u001b[0m weights \u001b[38;5;241m=\u001b[39m [\u001b[43mget_weight\u001b[49m\u001b[43m(\u001b[49m\u001b[43mk\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m k \u001b[38;5;129;01min\u001b[39;00m ks]\n\u001b[1;32m 155\u001b[0m normalized_logps \u001b[38;5;241m=\u001b[39m jax\u001b[38;5;241m.\u001b[39mnn\u001b[38;5;241m.\u001b[39mlog_softmax(jnp\u001b[38;5;241m.\u001b[39marray(weights))\n\u001b[1;32m 156\u001b[0m chosen_idx \u001b[38;5;241m=\u001b[39m jax\u001b[38;5;241m.\u001b[39mrandom\u001b[38;5;241m.\u001b[39mcategorical(k2, normalized_logps)\n", + "File \u001b[0;32m~/b3d/src/b3d/chisight/gen3d/inference.py:149\u001b[0m, in \u001b[0;36minfer_latents_using_sequential_proposals..get_weight\u001b[0;34m(key)\u001b[0m\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mget_weight\u001b[39m(key):\n\u001b[0;32m--> 149\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43minfer_latents\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mshared_args\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mget_trace\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mget_metadata\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m[\u001b[38;5;241m0\u001b[39m]\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] } ], "source": [ - "color_sweep.shape" + "## Finish the run\n", + "key = jax.random.PRNGKey(1234)\n", + "trace = trace_20\n", + "for T in tqdm(range(20, len(all_data))):\n", + " key = b3d.split_key(key)\n", + " trace = i.inference_step_c2f(\n", + " key,\n", + " 1, # number of sequential iterations of the parallel pose proposal to consider\n", + " 5000, # number of poses to propose in parallel\n", + " # So the total number of poses considered at each step of C2F is 5000 * 1\n", + " trace, all_data[T][\"rgbd\"],\n", + " prev_color_proposal_laplace_scale=inference_hyperparams.prev_color_proposal_laplace_scale,\n", + " obs_color_proposal_laplace_scale=inference_hyperparams.obs_color_proposal_laplace_scale,\n", + " do_stochastic_color_proposals=True\n", + " )\n", + " b3d.chisight.gen3d.model.viz_trace(\n", + " trace,\n", + " T,\n", + " ground_truth_vertices=meshes[OBJECT_INDEX].vertices,\n", + " ground_truth_pose=all_data[T][\"camera_pose\"].inv() @ all_data[T][\"object_poses\"][OBJECT_INDEX]\n", + " )\n" ] }, { @@ -1048,7 +618,7 @@ ], "metadata": { "kernelspec": { - "display_name": "b3d", + "display_name": "gpu", "language": "python", "name": "python3" }, @@ -1062,7 +632,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.12.5" } }, "nbformat": 4, diff --git a/notebooks/bayes3d_paper/tester2.ipynb b/notebooks/bayes3d_paper/tester2.ipynb new file mode 100644 index 00000000..ac5486af --- /dev/null +++ b/notebooks/bayes3d_paper/tester2.ipynb @@ -0,0 +1,432 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import b3d\n", + "import jax.numpy as jnp\n", + "import os\n", + "from tqdm import tqdm\n", + "from b3d import Mesh, Pose\n", + "import matplotlib.pyplot as plt\n", + "import genjax\n", + "# genjax.pretty()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Scene 49\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 49/49 [00:03<00:00, 13.40it/s]\n", + "/home/georgematheos/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/torch/utils/cpp_extension.py:1967: UserWarning: TORCH_CUDA_ARCH_LIST is not set, all archs for visible cards are included for compilation. \n", + "If this is not desired, please set os.environ['TORCH_CUDA_ARCH_LIST'].\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scene_id = 49\n", + "FRAME_RATE = 50\n", + "ycb_dir = os.path.join(b3d.get_assets_path(), \"bop/ycbv\")\n", + "print(f\"Scene {scene_id}\")\n", + "b3d.reload(b3d.io.data_loader)\n", + "num_scenes = b3d.io.data_loader.get_ycbv_num_test_images(ycb_dir, scene_id)\n", + "\n", + "# image_ids = [image] if image is not None else range(1, num_scenes, FRAME_RATE)\n", + "image_ids = range(1, num_scenes + 1, FRAME_RATE)\n", + "all_data = b3d.io.data_loader.get_ycbv_test_images(ycb_dir, scene_id, image_ids)\n", + "\n", + "meshes = [\n", + " Mesh.from_obj_file(\n", + " os.path.join(ycb_dir, f'models/obj_{f\"{id + 1}\".rjust(6, \"0\")}.ply')\n", + " ).scale(0.001)\n", + " for id in all_data[0][\"object_types\"]\n", + "]\n", + "\n", + "image_height, image_width = all_data[0][\"rgbd\"].shape[:2]\n", + "fx,fy,cx,cy = all_data[0][\"camera_intrinsics\"]\n", + "scaling_factor = 1.0\n", + "renderer = b3d.renderer.renderer_original.RendererOriginal(\n", + " image_width * scaling_factor, image_height * scaling_factor, fx * scaling_factor, fy * scaling_factor, cx * scaling_factor, cy * scaling_factor, 0.01, 2.0\n", + ")\n", + "b3d.viz_rgb(all_data[0][\"rgbd\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import b3d\n", + "import b3d.chisight.gen3d.model\n", + "b3d.reload(b3d.chisight.gen3d.model)\n", + "import b3d.chisight.gen3d.transition_kernels as transition_kernels\n", + "b3d.reload(b3d.chisight.gen3d.transition_kernels)\n", + "import b3d.chisight.gen3d.image_kernel as image_kernel\n", + "b3d.reload(b3d.chisight.gen3d.image_kernel)\n", + "import b3d.io.data_loader\n", + "import jax\n", + "import jax.numpy as jnp\n", + "from b3d import Mesh, Pose\n", + "from b3d.chisight.gen3d.model import (\n", + " make_colors_choicemap,\n", + " make_depth_nonreturn_prob_choicemap,\n", + " make_visibility_prob_choicemap,\n", + ")\n", + "from b3d.chisight.gen3d.model import dynamic_object_generative_model\n", + "from genjax import ChoiceMapBuilder as C\n", + "from genjax import Pytree\n", + "import genjax" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "near, far = 0.001, 10." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "T = 0\n", + "b3d.rr_set_time(T)\n", + "\n", + "OBJECT_INDEX = 2\n", + "\n", + "template_pose = all_data[T][\"camera_pose\"].inv() @ all_data[T][\"object_poses\"][OBJECT_INDEX]\n", + "rendered_rgbd = renderer.render_rgbd_from_mesh(meshes[OBJECT_INDEX].transform(template_pose))\n", + "xyz_rendered = b3d.xyz_from_depth(rendered_rgbd[..., 3], fx, fy, cx, cy)\n", + "\n", + "fx, fy, cx, cy = all_data[T][\"camera_intrinsics\"]\n", + "xyz_observed = b3d.xyz_from_depth(all_data[T][\"rgbd\"][..., 3], fx, fy, cx, cy)\n", + "mask = all_data[T][\"masks\"][OBJECT_INDEX] * (xyz_observed[..., 2] > 0) * (jnp.linalg.norm(xyz_rendered - xyz_observed, axis=-1) < 0.01)\n", + "model_vertices = template_pose.inv().apply(xyz_rendered[mask])\n", + "model_colors = vertex_attributes=all_data[T][\"rgbd\"][..., :3][mask]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "img_model = image_kernel.NoOcclusionPerVertexImageKernel(\n", + " near, far, image_height, image_width\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "color_transiton_scale = 0.04\n", + "p_resample_color = 0.01\n", + "\n", + "# This parameter is needed for the inference hyperparameters.\n", + "# See the `InferenceHyperparams` docstring in `inference.py` for details.\n", + "effective_color_transition_scale = color_transiton_scale + p_resample_color * 1/2\n", + "\n", + "hyperparams = {\n", + " \"pose_kernel\": transition_kernels.UniformPoseDriftKernel(max_shift=0.1),\n", + " \"color_kernel\": transition_kernels.MixtureDriftKernel(\n", + " [\n", + " transition_kernels.LaplaceNotTruncatedColorDriftKernel(scale=color_transiton_scale),\n", + " transition_kernels.UniformDriftKernel(\n", + " max_shift=0.15, min_val=jnp.zeros(3), max_val=jnp.ones(3)\n", + " )\n", + " ],\n", + " jnp.array([1-p_resample_color, p_resample_color])\n", + " ),\n", + " \"visibility_prob_kernel\": transition_kernels.DiscreteFlipKernel(\n", + " p_change_to_different_value=0.05, support=jnp.array([0.0, 0.998])\n", + " ),\n", + " \"depth_nonreturn_prob_kernel\": transition_kernels.DiscreteFlipKernel(\n", + " p_change_to_different_value=0.2, support=jnp.array([0.002, 0.998])\n", + " ),\n", + " \"depth_scale_kernel\": transition_kernels.DiscreteFlipKernel(\n", + " p_change_to_different_value=0.05, support=jnp.array([0.0025, 0.01, 0.02, .1])#, .1, .4, 1.])\n", + " ),\n", + " \"color_scale_kernel\": transition_kernels.DiscreteFlipKernel(\n", + " p_change_to_different_value=0.05, support=jnp.array([0.01, 0.05, 0.1, .3])#, 0.15, .3, .8])\n", + " ),\n", + "\n", + " \"image_kernel\": img_model,\n", + "\n", + " \"intrinsics\": {\n", + " \"fx\": fx, \"fy\": fy, \"cx\": cx, \"cy\": cy\n", + " },\n", + " \"image_height\": Pytree.const(image_height),\n", + " \"image_width\": Pytree.const(image_width),\n", + " \n", + " \"vertices\": model_vertices\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "num_vertices = model_vertices.shape[0]\n", + "previous_state = {\n", + " \"pose\": template_pose,\n", + " \"colors\": model_colors,\n", + " \"visibility_prob\": jnp.ones(num_vertices)\n", + " * hyperparams[\"visibility_prob_kernel\"].support[-1],\n", + " \"depth_nonreturn_prob\": jnp.ones(num_vertices)\n", + " * hyperparams[\"depth_nonreturn_prob_kernel\"].support[0],\n", + " \"depth_scale\": hyperparams[\"depth_scale_kernel\"].support[0],\n", + " \"color_scale\": hyperparams[\"color_scale_kernel\"].support[0],\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "choicemap = (\n", + " genjax.ChoiceMap.d(\n", + " {\n", + " \"pose\": previous_state[\"pose\"],\n", + " \"color_scale\": previous_state[\"color_scale\"],\n", + " \"depth_scale\": previous_state[\"depth_scale\"],\n", + " \"rgbd\": all_data[T][\"rgbd\"],\n", + " }\n", + " ) ^ \n", + " make_visibility_prob_choicemap(previous_state[\"visibility_prob\"]) ^\n", + " make_colors_choicemap(previous_state[\"colors\"]) ^\n", + " make_depth_nonreturn_prob_choicemap(previous_state[\"depth_nonreturn_prob\"])\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array(67224.41, dtype=float32)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "key = jax.random.PRNGKey(0)\n", + "og_trace, weight = dynamic_object_generative_model.importance(key, choicemap, (hyperparams, previous_state))\n", + "trace = og_trace\n", + "weight" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "import b3d.chisight.gen3d.inference as i\n", + "\n", + "inference_hyperparams = i.InferenceHyperparams(\n", + " n_poses=1500,\n", + " do_stochastic_color_proposals=False,\n", + " pose_proposal_std=0.04,\n", + " pose_proposal_conc=1000.,\n", + " prev_color_proposal_laplace_scale=0.1,\n", + " obs_color_proposal_laplace_scale=0.1,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "b3d.rr_init(\"real_inference_7-2\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "b3d.reload(i)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/20 [00:00 (()=>{ if (customElements.get('treescope-container') === undefined) { class TreescopeContainer extends HTMLElement { constructor() { super(); this.attachShadow({mode: \"open\"}); this.defns = {}; this.state = {}; } } customElements.define(\"treescope-container\", TreescopeContainer); } if (customElements.get('treescope-run-here') === undefined) { class RunHere extends HTMLElement { constructor() { super() } connectedCallback() { const run = child => { const fn = new Function(child.textContent); child.textContent = \"\"; fn.call(this); this.remove(); }; const child = this.querySelector(\"script\"); if (child) { run(child); } else { new MutationObserver(()=>{ run(this.querySelector(\"script\")); }).observe(this, {childList: true}); } } } customElements.define(\"treescope-run-here\", RunHere); } })();
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2f3eed4f891d4d9ea0efcb84bd96073f", + "version_major": 2, + "version_minor": 0 + }, + "text/html": [ + "" + ], + "text/plain": [ + "interactive(children=(FloatSlider(value=0.0, description='Latent Value', max=1.0, step=0.01), FloatSlider(valu…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "prior = ud.Uniform(0.3, 0.7)\n", + "obsmodel = ud.NiceTruncatedCenteredUniform(.05, 0., 1.)\n", + "ud.create_interactive_posterior_viz(\n", + " prior,\n", + " obsmodel,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " lambda obs, lat: jnp.exp(\n", + " ud.get_posterior_for_uniform_prior_ntcu_obs(\n", + " prior, obsmodel, obs\n", + " ).logpdf(lat)\n", + " )\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "24c05690544a4af78ea9f554b9fdbe38", + "version_major": 2, + "version_minor": 0 + }, + "text/html": [ + "" + ], + "text/plain": [ + "interactive(children=(FloatSlider(value=0.0, description='Latent Value', max=1.0, step=0.01), FloatSlider(valu…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "prior = ud.MixtureOfUniforms(\n", + " jnp.array([0.7, 0.25, 0.05]),\n", + " ud.Uniform(\n", + " jnp.array([0.1, 0.4, 0.49]),\n", + " jnp.array([0.9, 0.6, 0.51])\n", + " )\n", + ")\n", + "obsmodel = ud.MixtureOfNiceTruncatedCenteredUniforms(\n", + " jnp.array([0.3, 0.7]),\n", + " ud.NiceTruncatedCenteredUniform(\n", + " jnp.array([0.1, 0.02]),\n", + " jnp.zeros(2),\n", + " jnp.ones(2)\n", + " )\n", + "\n", + ")\n", + "ud.create_interactive_posterior_viz(\n", + " prior,\n", + " obsmodel,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " lambda obs, lat: jnp.exp(\n", + " ud.get_posterior_from_mix_of_uniform_prior_and_mix_of_nctus_obs(\n", + " prior, obsmodel, obs\n", + " ).logpdf(lat)\n", + " )\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "0.39" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "obs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "gpu", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/gm/gen3d/debugging.ipynb b/notebooks/gm/gen3d/debugging.ipynb new file mode 100644 index 00000000..851ffe89 --- /dev/null +++ b/notebooks/gm/gen3d/debugging.ipynb @@ -0,0 +1,510 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import jax\n", + "import jax.numpy as jnp\n", + "import genjax\n", + "genjax.pretty()\n", + "import b3d\n", + "import b3d.chisight.gen3d as gen3d\n", + "import b3d.chisight.gen3d.inference.inference as inference\n", + "from tqdm import tqdm" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "problematic_scene_specs = [(2, 5), (3, 0), (3, 1), (3, 2), (4, 1), (4, 3), (5, 0)]\n", + "spec = problematic_scene_specs[2]\n", + "scene_id, object_idx = spec" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "all_data, meshes, renderer, intrinsics, initial_object_poses = gen3d.dataloading.load_scene(\n", + " scene_id, FRAME_RATE=50, subdir=\"train_real\"\n", + ")\n", + "b3d.viz_rgb(all_data[0][\"rgbd\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "template_pose, model_vertices, model_colors = gen3d.dataloading.load_object_given_scene(\n", + " all_data, meshes, renderer, object_idx\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "hyperparams = gen3d.settings.hyperparams\n", + "hyperparams[\"intrinsics\"] = intrinsics\n", + "hyperparams[\"vertices\"] = model_vertices\n", + "hyperparams" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "inference_hyperparams = gen3d.settings.inference_hyperparams\n", + "inference_hyperparams = gen3d.hyperparams.InferenceHyperparams(**{\n", + " **inference_hyperparams.attributes_dict(),\n", + " # \"pose_proposal_args\": [(0.04, 1000.0)]\n", + "})\n", + "inference_hyperparams" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def get_gt_pose(T):\n", + " return (\n", + " all_data[T][\"camera_pose\"].inv()\n", + " @ all_data[T][\"object_poses\"][object_idx]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "initial_state = gen3d.dataloading.get_initial_state(\n", + " template_pose, model_vertices, model_colors, hyperparams\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "key = jax.random.PRNGKey(156)\n", + "og_trace = inference.get_initial_trace(\n", + " key, hyperparams, initial_state, all_data[0][\"rgbd\"]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "b3d.rr_init(\"inference_debugging-3-1-2\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "b3d.reload(inference)\n", + "b3d.reload(b3d.chisight.gen3d.point_attribute_proposals)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "tracking_results = {}\n", + "maxT = 20\n", + "key = jax.random.PRNGKey(1)\n", + "trace = og_trace\n", + "for T in tqdm(range(maxT)):\n", + " key = b3d.split_key(key)\n", + " prev_trace = trace\n", + " trace, _, all_weights, all_poses, keys_to_regen = inference.inference_step(\n", + " key,\n", + " trace,\n", + " all_data[T][\"rgbd\"],\n", + " inference_hyperparams,\n", + " gt_pose=get_gt_pose(T),\n", + " use_gt_pose=True,\n", + " get_all_weights = True\n", + " )\n", + " tracking_results[T] = trace\n", + "\n", + " gt_pose, gt_key = all_poses[0], keys_to_regen[0]\n", + " gt_trace = gen3d.inference.get_trace_generated_during_inference(\n", + " gt_key, prev_trace, gt_pose, inference_hyperparams,\n", + " observed_rgbd=all_data[T][\"rgbd\"]\n", + " )\n", + "\n", + " gen3d.model.viz_trace(\n", + " trace,\n", + " T,\n", + " ground_truth_vertices=meshes[object_idx].vertices,\n", + " ground_truth_pose=get_gt_pose(T),\n", + " )\n", + "\n", + " if jnp.linalg.norm(gt_pose.position - gen3d.model.get_new_state(trace)[\"pose\"].position) > 0.02:\n", + " b3d.rr_init(\"gt_pose_trace-3-1\")\n", + " gen3d.model.viz_trace(gt_trace, T, ground_truth_vertices=meshes[object_idx].vertices, ground_truth_pose=get_gt_pose(T))\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "trace.get_score()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gt_trace.get_score()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gt_trace.subtraces[6]" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "observed_rgbd = all_data[6][\"rgbd\"]\n", + "state = gen3d.model.get_new_state(gt_trace)\n", + "intrinsics = hyperparams[\"intrinsics\"]\n", + "(\n", + " observed_rgbd_per_point,\n", + " latent_rgbd_per_point,\n", + " is_valid,\n", + " _,\n", + " point_indices_for_observed_rgbds,\n", + ") = gen3d.image_kernel.calculate_latent_and_observed_correspondences(\n", + " observed_rgbd, state, hyperparams\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "state[\"depth_nonreturn_prob\"][point_indices_for_observed_rgbds[0]]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "scores = jax.vmap(\n", + " hyperparams[\"image_kernel\"].get_rgbd_vertex_kernel().logpdf,\n", + " in_axes=(0, 0, None, None, 0, 0, None, None),\n", + ")(\n", + " observed_rgbd_per_point,\n", + " latent_rgbd_per_point,\n", + " state[\"color_scale\"],\n", + " state[\"depth_scale\"],\n", + " state[\"visibility_prob\"][point_indices_for_observed_rgbds],\n", + " state[\"depth_nonreturn_prob\"][point_indices_for_observed_rgbds],\n", + " hyperparams[\"intrinsics\"],\n", + " hyperparams[\"unexplained_depth_nonreturn_prob\"]\n", + ")\n", + "jnp.isinf(scores)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "observed_rgbd_per_point[-1]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "is_valid[42]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "latent_rgbd_per_point[42]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "observed_rgbd_per_point[42]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "state[\"visibility_prob\"][point_indices_for_observed_rgbds][42]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "state[\"depth_nonreturn_prob\"][point_indices_for_observed_rgbds][42]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "observed_rgbd = observed_rgbd_per_point[0]\n", + "latent_rgbd = latent_rgbd_per_point[0]\n", + "color_scale = state[\"color_scale\"]\n", + "depth_scale = state[\"depth_scale\"]\n", + "visibility_prob = state[\"visibility_prob\"][point_indices_for_observed_rgbds][0]\n", + "depth_nonreturn_prob = state[\"depth_nonreturn_prob\"][point_indices_for_observed_rgbds][0]\n", + "intrinsics = hyperparams[\"intrinsics\"]\n", + "\n", + "hyperparams[\"image_kernel\"].get_rgbd_vertex_kernel().logpdf(\n", + " observed_rgbd,\n", + " latent_rgbd,\n", + " color_scale,\n", + " depth_scale,\n", + " visibility_prob,\n", + " 0.,\n", + " intrinsics,\n", + " hyperparams[\"unexplained_depth_nonreturn_prob\"]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "_, _, metadata = get_trace_generated_during_inference(\n", + " gt_key, prev_trace, gt_pose, inference_hyperparams,\n", + " observed_rgbd=all_data[T][\"rgbd\"],\n", + " just_return_trace=False\n", + ")\n", + "jax.tree.map(lambda x: x[0], metadata[\"point_attribute_proposal_metadata\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "metadata[\"point_attribute_proposal_metadata\"]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "hyperparams[\"image_kernel\"].get_rgbd_vertex_kernel().outlier_color_distribution.logpdf(\n", + " observed_rgbd[:3], latent_rgbd[:3], color_scale\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "s = hyperparams[\"image_kernel\"].get_rgbd_vertex_kernel()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + ".outlier_depth_distribution.logpdf(\n", + " observed_rgbd[3], latent_rgbd[3], depth_scale, intrinsics[\"near\"], intrinsics[\"far\"]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [], + "source": [ + "total_log_prob = 0.0\n", + "is_depth_non_return = observed_rgbd[3] == 0.0\n", + "\n", + "# Is visible\n", + "total_visible_log_prob = 0.0\n", + "# color term\n", + "total_visible_log_prob += s.inlier_color_distribution.logpdf(\n", + " observed_rgbd[:3], latent_rgbd[:3], color_scale\n", + ")\n", + "# depth term\n", + "total_visible_log_prob += jnp.where(\n", + " is_depth_non_return,\n", + " jnp.log(depth_nonreturn_prob),\n", + " jnp.log(1 - depth_nonreturn_prob)\n", + " + s.inlier_depth_distribution.logpdf(\n", + " observed_rgbd[3],\n", + " latent_rgbd[3],\n", + " depth_scale,\n", + " intrinsics[\"near\"],\n", + " intrinsics[\"far\"],\n", + " ),\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "jnp.log(1 - depth_nonreturn_prob)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "total_not_visible_log_prob = 0.0\n", + "# color term\n", + "outlier_color_log_prob = s.outlier_color_distribution.logpdf(\n", + " observed_rgbd[:3],\n", + " latent_rgbd[:3],\n", + " color_scale,\n", + ")\n", + "outlier_depth_log_prob = s.outlier_depth_distribution.logpdf(\n", + " observed_rgbd[3],\n", + " latent_rgbd[3],\n", + " depth_scale,\n", + " intrinsics[\"near\"],\n", + " intrinsics[\"far\"],\n", + ")\n", + "outlier_depth_log_prob + outlier_color_log_prob" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "total_not_visible_log_prob += outlier_color_log_prob\n", + "# depth term\n", + "total_not_visible_log_prob += jnp.where(\n", + " is_depth_non_return,\n", + " jnp.log(depth_nonreturn_prob),\n", + " jnp.log(1 - depth_nonreturn_prob) + outlier_depth_log_prob,\n", + ")\n", + "total_not_visible_log_prob" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "gpu", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/integration.ipynb b/notebooks/integration.ipynb index a5d5344a..ec285ab3 100644 --- a/notebooks/integration.ipynb +++ b/notebooks/integration.ipynb @@ -534,7 +534,7 @@ "metadata": {}, "outputs": [], "source": [ - "scantr = ps.particle_system_state_step.scan(n=(num_timesteps.const - 1)).simulate(\n", + "scantr = ps.particle_system_state_step.scan(n=(num_timesteps.unwrap() - 1)).simulate(\n", " key, (state0, None)\n", ")" ] diff --git a/pixi.lock b/pixi.lock index a56e8dd2..4fc4e500 100644 --- a/pixi.lock +++ b/pixi.lock @@ -1,4 +1,4 @@ -version: 5 +version: 6 environments: cpu: channels: @@ -10,450 +10,459 @@ environments: linux-64: - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/_sysroot_linux-64_curr_repodata_hack-3-h69a702a_16.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/absl-py-2.1.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/alsa-lib-1.2.12-h4ab18f5_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/anyio-4.4.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/anywidget-0.9.13-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/absl-py-2.1.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/alsa-lib-1.2.13-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/anyio-4.7.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/anywidget-0.9.13-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/aom-3.9.1-hac33072_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/argon2-cffi-23.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/argon2-cffi-23.1.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/argon2-cffi-bindings-21.2.0-py312h66e93f0_5.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/arrow-1.3.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/asttokens-2.4.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/astunparse-1.6.3-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/async-lru-2.0.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-24.2.0-pyh71513ae_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-auth-0.7.27-hc36b679_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-cal-0.7.4-h2abdd08_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-common-0.9.27-h4bc722e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-compression-0.2.19-haa50ccc_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-event-stream-0.4.3-h570d160_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-http-0.8.8-h9b61739_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-io-0.14.18-h49c7fd3_7.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-mqtt-0.10.4-h5c8269d_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-s3-0.6.5-h9204347_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-sdkutils-0.1.19-h038f3f9_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-checksums-0.1.18-h038f3f9_10.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-crt-cpp-0.28.2-h6552c9e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-sdk-cpp-1.11.379-hc1bef60_8.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/arrow-1.3.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/asttokens-3.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/astunparse-1.6.3-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/async-lru-2.0.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-24.3.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-auth-0.7.31-he1a10d6_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-cal-0.7.4-hae4d56a_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-common-0.9.29-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-compression-0.2.19-h2bff981_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-event-stream-0.4.3-h19b0707_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-http-0.8.10-h14a7884_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-io-0.14.19-hc9e6898_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-mqtt-0.10.7-hb8d5873_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-s3-0.6.7-h666547d_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-sdkutils-0.1.19-h2bff981_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-checksums-0.1.20-h2bff981_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-crt-cpp-0.28.3-hbe26082_8.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-sdk-cpp-1.11.407-h25d6d5c_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-core-cpp-1.13.0-h935415a_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-identity-cpp-1.8.0-hd126650_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-blobs-cpp-12.12.0-hd2e3451_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-common-cpp-12.7.0-h10ac4d7_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-files-datalake-cpp-12.11.0-h325d260_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.14.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/beautifulsoup4-4.12.3-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.40-ha1999f0_7.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/bleach-6.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.16.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/beautifulsoup4-4.12.3-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/bleach-6.2.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-1.1.0-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-bin-1.1.0-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-python-1.1.0-py312h2ec8cdc_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-h4bc722e_7.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.33.1-heb4867d_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ca-certificates-2024.8.30-hbcca054_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.4-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ca-certificates-2024.12.14-hbcca054_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cached-property-1.5.2-hd8ed1ab_1.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/cached_property-1.5.2-pyha770c72_1.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/cairo-1.18.0-hebfffa5_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2024.8.30-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cairo-1.18.2-h3394656_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2024.12.14-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cffi-1.17.1-py312h06ac9bb_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.3.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/chex-0.1.86-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/comm-0.2.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/contourpy-1.3.0-py312h68727a3_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/chex-0.1.88-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/comm-0.2.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/contourpy-1.3.1-py312h68727a3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.12.8-py312hd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cyrus-sasl-2.1.27-h54b06d7_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.0.11-py312h8fd2918_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/dav1d-1.2.1-hd590300_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.13.6-h5008d03_3.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/debugpy-1.8.5-py312h2ec8cdc_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/decorator-5.1.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/debugpy-1.8.11-py312h2ec8cdc_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/decorator-5.1.1-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/defusedxml-0.7.1-pyhd8ed1ab_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/distinctipy-1.3.4-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/double-conversion-3.3.0-h59595ed_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/elfutils-0.191-h924a536_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/entrypoints-0.4-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/executing-2.1.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/expat-2.6.3-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ffmpeg-6.1.2-gpl_h226ea3b_102.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.15.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/elfutils-0.192-h7f4e02f_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/entrypoints-0.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/etils-1.10.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/executing-2.1.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/expat-2.6.4-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/fcl-0.7.0-h543440a_6.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ffmpeg-7.1.0-gpl_heed6883_705.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.16.1-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/fire-0.6.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/flann-1.9.2-h776a335_3.conda - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/fontconfig-2.14.2-h14ed4e7_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/fontconfig-2.15.0-h7e30c49_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-forge-1-0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/fonttools-4.53.1-py312h66e93f0_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/fqdn-1.5.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/fonttools-4.55.3-py312h178313f_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/fqdn-1.5.1-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/freeglut-3.2.2-ha6d2627_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/freetype-2.12.1-h267a509_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/fribidi-1.0.10-h36c2ea0_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/fsspec-2024.9.0-pyhff2d567_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-14.1.0-h6f9ffa1_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-14.1.0-h3c94d91_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/fsspec-2024.10.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gdk-pixbuf-2.42.12-hb9ae30d_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/gettext-0.22.5-he02047a_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/gettext-tools-0.22.5-he02047a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gflags-2.2.2-he1b5a44_1004.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/gflags-2.2.2-h5888daf_1005.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/glfw-3.4-hd590300_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/glog-0.7.1-hbabe93e_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/gmp-6.3.0-hac33072_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gmpy2-2.1.5-py312h7201bc8_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gnutls-3.8.7-h32866dd_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gmpy2-2.1.5-py312h7201bc8_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gnutls-3.8.8-h2d3e045_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/graphite2-1.3.13-h59595ed_1003.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/h11-0.14.0-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/h2-4.1.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/h11-0.14.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/h2-4.1.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/h5py-3.11.0-nompi_py312hedeef09_103.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/harfbuzz-9.0.0-hda332d3_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/hdf5-1.14.3-nompi_hdf9ad27_105.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/hpack-4.0.0-pyh9f0ad1d_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/httpcore-1.0.5-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/httpx-0.27.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/hyperframe-6.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/hdf5-1.14.3-nompi_h2d575fe_108.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hpack-4.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/httpcore-1.0.7-pyh29332c3_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/httpx-0.28.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hyperframe-6.0.1-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.8-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/imageio-2.35.1-pyh12aca89_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/imath-3.1.11-hfc55251_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.4.0-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_metadata-8.4.0-hd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.4.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.10-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/imageio-2.36.1-pyh12aca89_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/imath-3.1.12-h7955e40_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.5.0-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.4.5-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/ipykernel-6.29.5-pyh3099207_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipympl-0.9.5-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/ipython-8.26.0-pyh707e725_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ipywidgets-8.1.5-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/isoduration-20.11.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/ipython_genutils-0.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipywidgets-8.1.5-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/isoduration-20.11.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/jasper-4.2.4-h536e39c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jax-0.4.31-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jax-0.4.31-pyhd8ed1ab_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/jaxlib-0.4.31-cpu_py312h6b2a80f_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jedi-0.19.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/joblib-1.4.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/json5-0.9.25-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jedi-0.19.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/joblib-1.4.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/json5-0.10.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/jsonpointer-3.0.0-py312h7900ff3_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-4.23.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-specifications-2023.12.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-with-format-nongpl-4.23.0-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-4.23.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-specifications-2024.10.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-with-format-nongpl-4.23.0-hd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-1.0.0-pyhd8ed1ab_10.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-lsp-2.2.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-lsp-2.2.5-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-ui-poll-0.2.2-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.6.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_console-6.6.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/jupyter_core-5.7.2-py312h7900ff3_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_events-0.10.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_server-2.14.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_server_terminals-0.5.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab-4.2.5-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_pygments-0.3.0-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_server-2.27.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_widgets-3.0.13-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupytext-1.16.4-pyh80e38bb_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-3.10.0-h4a8ded7_16.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.6.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_console-6.6.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_core-5.7.2-pyh31011fe_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_events-0.11.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_server-2.14.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_server_terminals-0.5.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab-4.3.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_pygments-0.3.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_server-2.27.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_widgets-3.0.13-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupytext-1.16.5-pyhbbac1ac_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-3.10.0-he073ed8_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.1-h166bdaf_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/kiwisolver-1.4.7-py312h68727a3_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.3-h659f571_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/lame-3.100-h166bdaf_1003.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/lcms2-2.16-hb7c19ff_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.40-hf3520f5_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.43-h712a8e2_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/lerc-4.0.0-h27087fc_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20240116.2-cxx17_he02047a_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libaec-1.1.3-h59595ed_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libarchive-3.7.4-hfca40fe_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-17.0.0-h8d2e343_13_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-acero-17.0.0-h5888daf_13_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-dataset-17.0.0-h5888daf_13_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-substrait-17.0.0-hf54134d_13_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libarchive-3.7.7-hadbb8c3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-17.0.0-had3b6fe_16_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-acero-17.0.0-h5888daf_16_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-dataset-17.0.0-h5888daf_16_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-substrait-17.0.0-hf54134d_16_cpu.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libasprintf-0.22.5-he8f35ee_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libasprintf-devel-0.22.5-he8f35ee_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libass-0.17.3-h1dc1e6a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-23_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-26_linux64_openblas.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlicommon-1.1.0-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlidec-1.1.0-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlienc-1.1.0-hb9d3cd8_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-23_linux64_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp18.1-18.1.8-default_hf981a13_4.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang13-18.1.8-default_h9def88c_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-26_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libccd-double-2.1-h59595ed_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp19.1-19.1.6-default_hb5137d0_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang13-19.1.6-default_h9c6a7e4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcrc32c-1.1.2-h9c3ff4c_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/libcups-2.3.3-h4637d8d_4.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.9.1-hdb1bdb2_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.21-h4bc722e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libdrm-2.4.123-hb9d3cd8_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libdrm-cos7-x86_64-2.4.97-h9b0a68f_1105.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.11.1-h332b0f4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.23-h4ddbbb0_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libdrm-2.4.124-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libdrm-cos7-x86_64-2.4.97-ha675448_1106.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20191231-he28a2e2_2.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libegl-1.7.0-ha4b6fd6_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libegl-1.7.0-ha4b6fd6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libevent-2.1.12-hf998b51_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.6.3-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.6.4-h5888daf_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.2-h7f98852_5.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-14.1.0-h77fa898_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-14.1.0-h5d3d1c9_101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-14.1.0-h69a702a_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-14.2.0-h77fa898_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-14.2.0-h69a702a_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgettextpo-0.22.5-he02047a_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgettextpo-devel-0.22.5-he02047a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-14.1.0-h69a702a_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-14.1.0-h69a702a_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-14.1.0-hc5f4f2c_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.80.3-h315aac3_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libglu-9.0.0-ha6d2627_1004.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-core-devel-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-devel-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-egl-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-gles-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-glx-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-opengl-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-14.1.0-h77fa898_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-2.28.0-h26d7fe4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-storage-2.28.0-ha262f82_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-14.2.0-h69a702a_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-14.2.0-hd5240d6_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.82.2-h2ff4ddf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libglu-9.0.3-h03adeef_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-core-devel-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-devel-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-egl-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-gles-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-glx-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-opengl-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-14.2.0-h77fa898_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-2.29.0-h435de7b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-storage-2.29.0-h0121fbd_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgrpc-1.62.2-h15f2491_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libhwloc-2.11.1-default_hecaa2ac_1000.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libhwloc-2.11.2-default_h0d58e46_1001.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.17-hd590300_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libidn2-2.3.7-hd590300_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.0.0-hd590300_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-23_linux64_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapacke-3.9.0-23_linux64_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm18-18.1.8-h8b73ec9_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-26_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapacke-3.9.0-26_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm19-19.1.6-ha7bfdaf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.6.3-hb9d3cd8_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-devel-5.6.3-hb9d3cd8_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libmicrohttpd-1.0.1-hbc5bc17_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.58.0-h47da74e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.64.0-h161d5f1_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hd590300_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.27-pthreads_hac2b453_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopencv-4.10.0-qt6_py312h6ebf6f7_603.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-2024.3.0-h2da1b83_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-auto-batch-plugin-2024.3.0-hb045406_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-auto-plugin-2024.3.0-hb045406_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-hetero-plugin-2024.3.0-h5c03a75_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-cpu-plugin-2024.3.0-h2da1b83_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-gpu-plugin-2024.3.0-h2da1b83_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-npu-plugin-2024.3.0-h2da1b83_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-ir-frontend-2024.3.0-h5c03a75_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-onnx-frontend-2024.3.0-h07e8aee_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-paddle-frontend-2024.3.0-h07e8aee_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-pytorch-frontend-2024.3.0-he02047a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-tensorflow-frontend-2024.3.0-h39126c6_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-tensorflow-lite-frontend-2024.3.0-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libntlm-1.4-h7f98852_1002.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.28-pthreads_h94d23a6_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopencv-4.10.0-qt6_py312h01efb12_604.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopengl-1.7.0-ha4b6fd6_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-2024.4.0-hac27bb2_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-auto-batch-plugin-2024.4.0-h4d9b6c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-auto-plugin-2024.4.0-h4d9b6c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-hetero-plugin-2024.4.0-h3f63f65_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-cpu-plugin-2024.4.0-hac27bb2_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-gpu-plugin-2024.4.0-hac27bb2_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-npu-plugin-2024.4.0-hac27bb2_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-ir-frontend-2024.4.0-h3f63f65_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-onnx-frontend-2024.4.0-h56242b0_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-paddle-frontend-2024.4.0-h56242b0_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-pytorch-frontend-2024.4.0-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-tensorflow-frontend-2024.4.0-h358ae18_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-tensorflow-lite-frontend-2024.4.0-h5888daf_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libopus-1.3.1-h7f98852_1.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libparquet-17.0.0-h39682fd_13_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libparquet-17.0.0-h39682fd_16_cpu.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libpciaccess-0.18-hd590300_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.43-h2797004_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libpq-16.4-h2d7952a_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-4.25.3-h08a7969_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.44-hadc24fc_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpq-17.2-h3b95a9b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-4.25.3-hd5b35b9_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libre2-11-2023.09.01-h5a48ba9_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-14.1.0-hcba0ae0_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/librsvg-2.58.4-hc0ffecb_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsodium-1.0.20-h4ab18f5_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.46.1-hadc24fc_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.0-h0841786_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-14.1.0-hc0a3c3a_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-14.1.0-h4852527_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.47.2-hee588c1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-hf672d98_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-14.2.0-hc0a3c3a_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-14.2.0-h4852527_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libtasn1-4.19.0-h166bdaf_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/libthrift-0.20.0-h0e7cc3e_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.6.0-h46a8edc_4.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libtorch-2.3.0-cpu_generic_h970db74_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.0-hd9ff511_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libtorch-2.3.1-cpu_generic_h970db74_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libunistring-0.9.10-h7f98852_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libutf8proc-2.8.0-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libutf8proc-2.8.0-hf23e847_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.48.0-hd590300_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libva-2.22.0-hb711507_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.49.2-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libva-2.22.0-h8a09558_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libvpx-1.14.1-hac33072_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libwebp-base-1.4.0-hd590300_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.16-hb9d3cd8_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.17.0-h8a09558_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libxkbcommon-1.7.0-h2c5496b_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.12.7-he7c6b58_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.13.5-h8d12d68_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libxslt-1.1.39-h76b75d6_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-h4ab18f5_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/lz4-c-1.9.4-hcb278e6_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/lzo-2.10-hd590300_1001.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-3.0.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/markupsafe-2.1.5-py312h66e93f0_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-3.9.2-py312h7900ff3_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-base-3.9.2-py312h854627b_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/matplotlib-inline-0.1.7-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/mdit-py-plugins-0.4.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-khr-devel-cos7-x86_64-18.3.4-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libegl-cos7-x86_64-18.3.4-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libegl-devel-cos7-x86_64-18.3.4-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libgbm-cos7-x86_64-18.3.4-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libglapi-cos7-x86_64-18.3.4-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libglu-cos7-x86_64-9.0.0-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libglu-devel-cos7-x86_64-9.0.0-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/mesalib-24.2.2-h4e3793c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/mistune-3.0.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ml_dtypes-0.4.0-py312hf9745cd_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-3.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/markupsafe-3.0.2-py312h178313f_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-3.9.4-py312h7900ff3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-base-3.9.4-py312hd3ec401_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/matplotlib-inline-0.1.7-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mdit-py-plugins-0.4.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-khr-devel-cos7-x86_64-18.3.4-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libegl-cos7-x86_64-18.3.4-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libegl-devel-cos7-x86_64-18.3.4-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libgbm-cos7-x86_64-18.3.4-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libglapi-cos7-x86_64-18.3.4-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libglu-cos7-x86_64-9.0.0-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libglu-devel-cos7-x86_64-9.0.0-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/mesalib-24.3.1-h0b126fc_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mistune-3.0.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ml_dtypes-0.5.0-py312hf9745cd_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/mpc-1.3.1-h24ddda3_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/mpfr-4.2.1-h38ae2d0_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mpfr-4.2.1-h90cbb55_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/msgpack-numpy-0.4.8-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/msgpack-python-1.1.0-py312h68727a3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/munkres-1.1.4-pyh9f0ad1d_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/mysql-common-9.0.1-h70512c7_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/mysql-libs-9.0.1-ha479ceb_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/natsort-8.4.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nbclient-0.10.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-7.16.4-hd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-core-7.16.4-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-pandoc-7.16.4-hd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nbformat-5.10.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mysql-common-9.0.1-h266115a_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mysql-libs-9.0.1-he0572af_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/natsort-8.4.0-pyh29332c3_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbclient-0.10.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-7.16.4-hd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-core-7.16.4-pyhff2d567_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-pandoc-7.16.4-hd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbformat-5.10.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-he02047a_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nest-asyncio-1.6.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nest-asyncio-1.6.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/nettle-3.9.1-h7ab15ed_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/networkx-3.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/networkx-3.4.2-pyh267e887_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.12.1-h297d8ca_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/nodejs-22.8.0-hf235a45_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/nodejs-22.12.0-hf235a45_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/nomkl-1.0-h5ca1d4c_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/notebook-7.2.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/notebook-shim-0.2.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/notebook-7.3.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/notebook-shim-0.2.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-1.26.4-py312heda63a1_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ocl-icd-2.3.2-hd590300_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/openexr-3.2.2-haf962dd_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/openh264-2.4.1-h59595ed_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/openjpeg-2.5.2-h488ebb8_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.3.2-hb9d3cd8_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/opt-einsum-3.3.0-hd8ed1ab_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/opt_einsum-3.3.0-pyhc1e730c_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/optax-0.2.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ocl-icd-2.3.2-hb9d3cd8_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/octomap-1.10.0-h84d6215_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/opencl-headers-2024.10.24-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openexr-3.2.2-h04e0de5_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openh264-2.5.0-hf92e6e3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openjpeg-2.5.3-h5fbd93e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openldap-2.6.9-he970967_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.4.0-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/opt-einsum-3.4.0-hd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/opt_einsum-3.4.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/optax-0.2.3-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/orc-2.0.2-h669347b_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/overrides-7.7.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/p11-kit-0.24.1-hc5aa10d_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pandoc-3.3-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.2-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pandoc-3.6-ha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pandocfilters-1.5.0-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pango-1.54.0-h3a902e7_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.44-hba22ea6_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pdoc-14.4.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pickleshare-0.7.5-py_1003.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pickleshare-0.7.5-pyhd8ed1ab_1004.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/pillow-10.3.0-py312h287a98d_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pixman-0.43.2-h59595ed_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pkgutil-resolve-name-1.3.10-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.2.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pixman-0.44.2-h29eaf8c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pkgutil-resolve-name-1.3.10-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.3.6-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/polars-0.20.31-py312hd26010a_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/prometheus_client-0.20.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/prompt-toolkit-3.0.47-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/prompt_toolkit-3.0.47-hd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-6.0.0-py312h9a8786e_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/psygnal-0.11.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-h36c2ea0_1001.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/ptyprocess-0.7.0-pyhd3deb0d_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/prometheus_client-0.21.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/prompt-toolkit-3.0.48-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/prompt_toolkit-3.0.48-hd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-6.1.0-py312h66e93f0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/psygnal-0.11.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-hb9d3cd8_1002.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ptyprocess-0.7.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/pugixml-1.14-h59595ed_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pure_eval-0.2.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/py-opencv-4.10.0-qt6_py312h071dcc1_603.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pyarrow-17.0.0-py312h9cebb41_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pyarrow-core-17.0.0-py312h9cafe31_1_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.18.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.1.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pyright-1.1.379-py312h66e93f0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pyside6-6.7.2-py312hb5137db_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyha2e5f31_6.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.3.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.12.5-h2ad013b_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.20.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pure_eval-0.2.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/py-opencv-4.10.0-qt6_py312h071dcc1_604.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyarrow-17.0.0-py312h9cebb41_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyarrow-core-17.0.0-py312h01725c0_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pycocotools-2.0.8-py312hc0a28a1_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.18.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyright-1.1.390-py312h66e93f0_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyside6-6.7.3-py312h91f0f75_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyha55dd90_7.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.3.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.12.8-h9e4cc4f_1_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhff2d567_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.21.1-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python-json-logger-2.0.7-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/python-lzf-0.2.6-py312h41a817b_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-lzf-0.2.6-py312h318bf5b_4.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/python_abi-3.12-5_cp312.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pytorch-2.3.0-cpu_generic_py312h2f1fc2b_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pytz-2024.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pytorch-2.3.1-cpu_generic_py312h2f1fc2b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytz-2024.2-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/pyyaml-6.0.2-py312h66e93f0_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pyzmq-26.2.0-py312hbf22597_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyzmq-26.2.0-py312hbf22597_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/qhull-2020.2-h434a139_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/qt6-main-6.7.2-hb12f9c5_5.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/qtconsole-base-5.6.0-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/qtpy-2.4.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/qt6-main-6.7.3-h6e8976b_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/qtconsole-base-5.6.1-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/qtpy-2.4.2-pyhdecd6ff_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/re2-2023.09.01-h7f4b329_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8228510_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/referencing-0.35.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/referencing-0.35.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.3-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/rerun-sdk-0.17.0-py312hbe4c86d_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/rfc3339-validator-0.1.4-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/rfc3339-validator-0.1.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/rfc3986-validator-0.1.1-pyh9f0ad1d_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/rpds-py-0.20.0-py312h12e396e_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ruff-0.6.4-py312hd18ad41_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/s2n-1.5.1-h3400bea_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/scikit-learn-1.5.1-py312h775a589_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.14.1-py312h7d485d2_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/send2trash-1.8.3-pyh0d859eb_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-73.0.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.16.0-pyh6c4a22f_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/sleef-3.6.1-h1b44611_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/snappy-1.2.1-ha2e4443_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sniffio-1.3.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/rpds-py-0.22.3-py312h12e396e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ruff-0.8.3-py312h2156523_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/s2n-1.5.5-h3931f03_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/scikit-learn-1.5.2-py312h7a48858_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.14.1-py312h62794b6_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/send2trash-1.8.3-pyh0d859eb_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-75.6.0-pyhff2d567_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/sleef-3.7-h1b44611_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/snappy-1.2.1-h8bd8927_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sniffio-1.3.1-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/soupsieve-2.5-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/stack_data-0.6.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/svt-av1-2.2.1-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.13.2-pypyh2585a3b_103.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.17-h4a8ded7_16.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/tbb-2021.13.0-h84d6215_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/termcolor-2.4.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/stack_data-0.6.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/svt-av1-2.3.0-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.13.3-pyh2585a3b_104.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.17-h4a8ded7_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tbb-2022.0.0-hceb3a55_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/termcolor-2.5.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/terminado-0.18.1-pyh0d859eb_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/threadpoolctl-3.5.0-pyhc1e730c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tinycss2-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tinycss2-1.4.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h4845f30_101.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/toolz-0.12.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.2.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toolz-1.0.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/torchvision-0.18.0-cpu_py312h83765ac_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/tornado-6.4.1-py312h66e93f0_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tqdm-4.66.5-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.14.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tornado-6.4.2-py312h66e93f0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tqdm-4.67.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.14.3-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/trimesh-4.2.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/types-python-dateutil-2.9.0.20240906-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/typing_utils-0.1.0-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h8827d51_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/uri-template-1.3.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.2.2-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/watchfiles-0.24.0-py312h12e396e_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/types-python-dateutil-2.9.0.20241206-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_utils-0.1.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024b-hc8b5060_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/unicodedata2-15.1.0-py312h66e93f0_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/uri-template-1.3.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.2.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/watchfiles-1.0.3-py312h12e396e_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/wayland-1.23.1-h3e06ad9_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/wayland-protocols-1.37-hd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.2.13-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/webcolors-24.8.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/webencodings-0.5.1-pyhd8ed1ab_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/websocket-client-1.8.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/widgetsnbextension-4.0.13-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/wrapt-1.16.0-py312h66e93f0_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.2.13-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/webcolors-24.11.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/webencodings-0.5.1-pyhd8ed1ab_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/websocket-client-1.8.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/widgetsnbextension-4.0.13-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/wrapt-1.17.0-py312h66e93f0_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/x264-1!164.3095-h166bdaf_2.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/x265-3.5-h924138e_3.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-0.4.1-hb711507_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-cursor-0.1.4-h4ab18f5_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-cursor-0.1.5-hb9d3cd8_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-image-0.4.0-hb711507_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-keysyms-0.4.1-hb711507_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-renderutil-0.3.10-hb711507_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-wm-0.4.2-hb711507_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xkeyboard-config-2.42-h4ab18f5_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-damageproto-1.2.1-h7f98852_1002.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-fixesproto-5.0-h7f98852_1002.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-glproto-1.4.17-h7f98852_1002.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-inputproto-2.3.2-h7f98852_1002.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-kbproto-1.0.7-h7f98852_1002.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libice-1.1.1-hd590300_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libsm-1.2.4-h7391055_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libx11-1.8.9-hb711507_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.11-hd590300_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdamage-1.1.5-h7f98852_1.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.3-h7f98852_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxext-1.3.4-h0b41bf4_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxfixes-5.0.3-h7f98852_1004.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxi-1.7.10-h4bc722e_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxinerama-1.1.5-h27087fc_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrandr-1.5.2-h7f98852_1.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrender-0.9.11-hd590300_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxtst-1.2.5-h4bc722e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxxf86vm-1.1.5-h4bc722e_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-randrproto-1.5.0-h7f98852_1001.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-recordproto-1.14.2-h7f98852_1002.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-renderproto-0.11.1-h7f98852_1002.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-util-macros-1.19.3-h7f98852_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-xextproto-7.3.0-h0b41bf4_1003.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-xf86vidmodeproto-2.3.1-h7f98852_1002.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-xproto-7.0.31-h7f98852_1007.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-5.2.6-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/xkeyboard-config-2.43-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libice-1.1.2-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libsm-1.2.5-he73a12e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libx11-1.8.10-h4f16b4b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.12-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcomposite-0.4.6-hb9d3cd8_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcursor-1.2.3-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdamage-1.1.6-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.5-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxext-1.3.6-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxfixes-6.0.1-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxi-1.8.2-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxinerama-1.1.5-h5888daf_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrandr-1.5.4-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrender-0.9.12-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxshmfence-1.3.3-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxtst-1.2.5-hb9d3cd8_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxxf86vm-1.1.6-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-5.6.3-hbcc6ac9_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-gpl-tools-5.6.3-hbcc6ac9_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-tools-5.6.3-hb9d3cd8_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/yaml-0.2.5-h7f98852_2.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/zeromq-4.3.5-ha4adb4c_5.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.20.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/zlib-1.3.1-h4ab18f5_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zeromq-4.3.5-h3b0a872_7.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.21.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zlib-1.3.1-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/zstandard-0.23.0-py312hef9b889_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.6-ha6fb4c9_0.conda - pypi: https://files.pythonhosted.org/packages/a5/45/30bb92d442636f570cb5651bc661f52b610e2eec3f891a5dc3a4c3667db0/aiofiles-24.1.0-py3-none-any.whl @@ -461,160 +470,162 @@ environments: - pypi: https://files.pythonhosted.org/packages/64/43/7a1259741bd989723272ac7d381a43be932422abcff09a1d9f7ba212cb74/beartype-0.18.5-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/49/f5/f4bfff55de6ca82445584eead7fc22f29f3d2bd66a76b8cf4c8c4feb2f32/carvekit-4.1.2-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/00/2e/d53fa4befbf2cfa713304affc7ca780ce4fc1fd8710527771b58311a3229/click-8.1.7-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/96/43/dae06432d0c4b1dc9e9149ad37b4ca8384cf6eb7700cd9215b177b914f0a/cloudpickle-3.0.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/48/41/e1d85ca3cab0b674e277c8c4f678cf66a91cd2cecf93df94353a606fe0db/cloudpickle-3.1.0-py3-none-any.whl - pypi: https://us-west1-python.pkg.dev/probcomp-caliban/probcomp/datasync/datasync-0.0.2-py3-none-any.whl#sha256=ce28394757ba65fa1ff3a3010a1f67720f372c877f7d27bc23176a53e2cfa3a4 - - pypi: https://files.pythonhosted.org/packages/20/8d/778b7d51b981a96554f29136cd59ca7880bf58094338085bcf2a979a0e6a/Deprecated-1.2.14-py2.py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/1d/8f/c7f227eb42cfeaddce3eb0c96c60cbca37797fa7b34f8e1aeadf6c5c0983/Deprecated-1.2.15-py2.py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/c9/d4/8cbb857612ca69763ee4f4f97c7b91659df1d373d62237cb9c772e55ae97/dm_tree-0.1.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl - - pypi: https://files.pythonhosted.org/packages/08/0f/1d22866c1ff666766b2c207487bef3f06edae096df2f6b4176d5f7072a10/equinox-0.11.5-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/d0/80/17037f322c280efbc623e341358d38d0299c6ee899d619a879b3593aa6da/fastapi-0.114.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/3a/af/411e94c165229882eb2d0a329114826aa52c7c61ef3108d0d3d8ad7189ed/equinox-0.11.10-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/52/b3/7e4df40e585df024fac2f80d1a2d579c854ac37109675db2b0cc22c0bb9e/fastapi-0.115.6-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/a3/61/8001b38461d751cd1a0c3a6ae84346796a5758123f3ed97a1b121dfbf4f3/gast-0.6.0-py3-none-any.whl - - pypi: https://us-west1-python.pkg.dev/probcomp-caliban/probcomp/genjax/genjax-0.5.1-py3-none-any.whl#sha256=1ad4363ce44f64cc1e5d92f826f4c7c14e99370a8c86d39cbe6fa8c3b6a657ce - - pypi: https://files.pythonhosted.org/packages/56/ae/220537f80eb82ae43a299de31edb2a91a28b8c5fb8046e9ff853ec7763cd/jaxtyping-0.2.34-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/03/0a/4f6fed21aa246c6b49b561ca55facacc2a44b87d65b8b92362a8e99ba202/loguru-0.7.2-py3-none-any.whl + - pypi: https://us-west1-python.pkg.dev/probcomp-caliban/probcomp/genjax/genjax-0.6.1-py3-none-any.whl#sha256=7e6afa8ab867266a9fa66ccadab3823d2e93d41d19d671ced853407c8e16cf44 + - pypi: https://files.pythonhosted.org/packages/94/99/c83c6a97f4382caf1c9bfeeeca935d3eb1f479f711665aeadf4408048107/jaxtyping-0.2.36-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/33/55/af02708f230eb77084a299d7b08175cff006dea4f2721074b92cdb0296c0/ordered_set-4.1.0-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/40/10/79e52ef01dfeb1c1ca47a109a01a248754ebe990e159a844ece12914de83/pandas-2.2.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/38/f8/d8fddee9ed0d0c0f4a2132c1dfcf0e3e53265055da8df952a53e7eaf178c/pandas-2.2.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl - pypi: https://files.pythonhosted.org/packages/41/dc/d123e5815af021ba22f9321d6922b03b1c1351170f78c3ebb86c522f24aa/penzai-0.1.5-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/54/38/95bdb5dfcebad2c11c88f7aa2d635fe53a0b7405ef39a6850c8bced455d4/pydantic-2.9.0-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/ad/fc/6b4f95c64bbeadaa6f84cffb51f469f6fdd61215d97b4ec8d89d027e574b/pydantic_core-2.23.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/62/51/72c18c55cf2f46ff4f91ebcc8f75aa30f7305f3d726be3f4ebffb4ae972b/pydantic-2.10.3-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/8a/c6/8ae0831bf77f356bb73127ce5a95fe115b10f820ea480abbd72d3cc7ccf3/pydantic_core-2.27.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl - pypi: https://files.pythonhosted.org/packages/c3/7e/e2b71b9221ccb8503dce9673e3cb36edcdc314ec374f9e69e6d38ed1abde/pykitti-0.3.1-py2.py3-none-any.whl - - pypi: git+https://github.com/ydkhatri/pyliblzfse.git@a8c00b6bf866410e658a82f88caa04b2cf0a5fea - pypi: https://files.pythonhosted.org/packages/68/6b/a4cc6a28ac80d3bccef0bf869634ee21731e1a85e5ce508c41e1ba0c8437/pyransac3d-0.6.0-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/3d/47/444768600d9e0ebc82f8e347775d24aef8f6348cf00e9fa0e81910814e6d/python_multipart-0.0.9-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/69/13/fa916b69d7c21f80a9c5bde0445cbbbdb9542a9d8df73ea3d588aae55c26/starlette-0.38.4-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/c0/00/cdb2afde2d7700d26b2df90bc40d72d18585e4f9a5d63d49b210a8d6bad0/python_fcl-0.7.0.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/45/58/38b5afbc1a800eeea951b9285d3912613f2603bdf897a4ab0f4bd7f405fc/python_multipart-0.0.20-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/96/00/2b325970b3060c7cecebab6d295afe763365822b1306a12eeab198f74323/starlette-0.41.3-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/1e/90/4e8c686f2e691f48e40e16a539c61a6e9880743733d8c4dc3f275d12268e/tensorflow_probability-0.23.0-py2.py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/9a/bb/d43e5c75054e53efce310e79d63df0ac3f25e34c926be5dffb7d283fb2a8/typeguard-2.13.3-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/05/d9/6eebe19d46bd05360c9a9aae822e67a80f9242aabbfc58b641b957546607/typing-3.7.4.3.tar.gz - - pypi: https://files.pythonhosted.org/packages/65/58/f9c9e6be752e9fcb8b6a0ee9fb87e6e7a1f6bcab2cdc73f02bb7ba91ada0/tzdata-2024.1-py2.py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/f5/8e/cdc7d6263db313030e4c257dd5ba3909ebc4e4fb53ad62d5f09b1a2f5458/uvicorn-0.30.6-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/f2/5d/865e17349564eb1772688d8afc5e3081a5964c640d64d1d2880ebaed002d/typing-3.10.0.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/a6/ab/7e5f53c3b9d14972843a647d8d7a853969a58aecc7559cb3267302c94774/tzdata-2024.2-py2.py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/61/14/33a3a1352cfa71812a3a21e8c9bfb83f60b0011f5e36f2b1399d51928209/uvicorn-0.34.0-py3-none-any.whl - pypi: . osx-arm64: - - conda: https://conda.anaconda.org/conda-forge/noarch/absl-py-2.1.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/anyio-4.4.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/anywidget-0.9.13-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/absl-py-2.1.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/anyio-4.7.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/anywidget-0.9.13-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aom-3.9.1-h7bae524_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/appnope-0.1.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/argon2-cffi-23.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/appnope-0.1.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/argon2-cffi-23.1.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/argon2-cffi-bindings-21.2.0-py312h024a12e_5.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/arrow-1.3.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/asttokens-2.4.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/astunparse-1.6.3-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/async-lru-2.0.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-24.2.0-pyh71513ae_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-auth-0.7.27-h1e647a1_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-cal-0.7.4-h41e72e7_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-common-0.9.27-h99b78c6_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-compression-0.2.19-h41e72e7_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-event-stream-0.4.3-h79ff00d_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-http-0.8.8-h69517e7_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-io-0.14.18-h20e6805_7.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-mqtt-0.10.4-h3e8bf47_18.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-s3-0.6.5-h5e39592_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-sdkutils-0.1.19-h85401af_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-checksums-0.1.18-h85401af_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-crt-cpp-0.28.2-h6f2a9b6_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-sdk-cpp-1.11.379-h8d911dc_8.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/arrow-1.3.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/asttokens-3.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/astunparse-1.6.3-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/async-lru-2.0.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-24.3.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-auth-0.7.31-h14f56dd_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-cal-0.7.4-hd45b2be_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-common-0.9.29-h7ab814d_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-compression-0.2.19-hd45b2be_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-event-stream-0.4.3-hdf5079d_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-http-0.8.10-h4588aaf_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-io-0.14.19-h5ad5fc2_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-mqtt-0.10.7-hbe077eb_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-s3-0.6.7-h86d2b7d_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-sdkutils-0.1.19-hd45b2be_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-checksums-0.1.20-hd45b2be_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-crt-cpp-0.28.3-h4f9f7e0_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-sdk-cpp-1.11.407-h880863c_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-core-cpp-1.13.0-hd01fc5c_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-identity-cpp-1.8.0-h13ea094_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-storage-blobs-cpp-12.12.0-hfde595f_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-storage-common-cpp-12.7.0-hcf3b6fd_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-storage-files-datalake-cpp-12.11.0-h082e32e_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.14.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/beautifulsoup4-4.12.3-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/bleach-6.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.16.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/beautifulsoup4-4.12.3-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/bleach-6.2.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-1.1.0-hd74edd7_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-bin-1.1.0-hd74edd7_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-python-1.1.0-py312hde4cb15_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h99b78c6_7.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.33.1-hd74edd7_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ca-certificates-2024.8.30-hf0a4a13_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.4-h5505292_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ca-certificates-2024.12.14-hf0a4a13_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cached-property-1.5.2-hd8ed1ab_1.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/cached_property-1.5.2-pyha770c72_1.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cairo-1.18.0-hb4a6bf7_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2024.8.30-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cairo-1.18.2-h6a3b0d2_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2024.12.14-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cffi-1.17.1-py312h0fad829_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.3.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/chex-0.1.86-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/comm-0.2.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/contourpy-1.3.0-py312h6142ec9_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/chex-0.1.88-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/comm-0.2.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/contourpy-1.3.1-py312hb23fbb9_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.12.8-py312hd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cython-3.0.11-py312hde4cb15_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/dav1d-1.2.1-hb547adb_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/debugpy-1.8.5-py312hde4cb15_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/decorator-5.1.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/debugpy-1.8.11-py312hd8f9ff3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/decorator-5.1.1-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/defusedxml-0.7.1-pyhd8ed1ab_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/distinctipy-1.3.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/entrypoints-0.4-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/executing-2.1.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/expat-2.6.3-hf9b8971_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ffmpeg-6.1.2-gpl_h3ef3969_102.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.15.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/entrypoints-0.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/etils-1.10.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/executing-2.1.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/fcl-0.7.0-he078184_6.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ffmpeg-6.1.2-gpl_hbafc610_106.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.16.1-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/fire-0.6.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/flann-1.9.2-h4918f9b_3.conda - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/fontconfig-2.14.2-h82840c6_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/fontconfig-2.15.0-h1383a14_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-forge-1-0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/fonttools-4.53.1-py312h024a12e_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/fqdn-1.5.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/fonttools-4.55.3-py312h998013c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/fqdn-1.5.1-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/freetype-2.12.1-hadb7bae_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/fribidi-1.0.10-h27ca646_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/fsspec-2024.9.0-pyhff2d567_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gettext-0.22.5-h8414b35_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gettext-tools-0.22.5-h8414b35_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gflags-2.2.2-hc88da5d_1004.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/fsspec-2024.10.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gflags-2.2.2-hf9b8971_1005.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/glog-0.7.1-heb240a5_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmp-6.3.0-h7bae524_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmpy2-2.1.5-py312h87fada9_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gnutls-3.8.7-h9df781c_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmpy2-2.1.5-py312h524cf62_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/graphite2-1.3.13-hebf3989_1003.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/h11-0.14.0-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/h2-4.1.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/h11-0.14.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/h2-4.1.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/h5py-3.11.0-nompi_py312h3cd0824_103.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/harfbuzz-9.0.0-h997cde5_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/hdf5-1.14.3-nompi_hec07895_105.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/hpack-4.0.0-pyh9f0ad1d_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/httpcore-1.0.5-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/httpx-0.27.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/hyperframe-6.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/hdf5-1.14.3-nompi_ha698983_108.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hpack-4.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/httpcore-1.0.7-pyh29332c3_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/httpx-0.28.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hyperframe-6.0.1-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-75.1-hfee45f7_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.8-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/imageio-2.35.1-pyh12aca89_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/imath-3.1.11-h1059232_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.4.0-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_metadata-8.4.0-hd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.4.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.10-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/imageio-2.36.1-pyh12aca89_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/imath-3.1.12-h025cafa_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.5.0-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.4.5-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/ipykernel-6.29.5-pyh57ce528_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipympl-0.9.5-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/ipython-8.26.0-pyh707e725_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ipywidgets-8.1.5-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/isoduration-20.11.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/ipython_genutils-0.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipywidgets-8.1.5-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/isoduration-20.11.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/jasper-4.2.4-h6c4e4ef_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jax-0.4.31-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jax-0.4.31-pyhd8ed1ab_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/jaxlib-0.4.31-cpu_py312h47007b3_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jedi-0.19.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/joblib-1.4.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/json5-0.9.25-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jedi-0.19.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/joblib-1.4.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/json5-0.10.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/jsonpointer-3.0.0-py312h81bd7bf_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-4.23.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-specifications-2023.12.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-with-format-nongpl-4.23.0-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-4.23.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-specifications-2024.10.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-with-format-nongpl-4.23.0-hd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-1.0.0-pyhd8ed1ab_10.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-lsp-2.2.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-lsp-2.2.5-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-ui-poll-0.2.2-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.6.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_console-6.6.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/jupyter_core-5.7.2-py312h81bd7bf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_events-0.10.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_server-2.14.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_server_terminals-0.5.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab-4.2.5-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_pygments-0.3.0-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_server-2.27.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_widgets-3.0.13-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupytext-1.16.4-pyh80e38bb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.6.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_console-6.6.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_core-5.7.2-pyh31011fe_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_events-0.11.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_server-2.14.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_server_terminals-0.5.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab-4.3.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_pygments-0.3.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_server-2.27.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_widgets-3.0.13-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupytext-1.16.5-pyhbbac1ac_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/kiwisolver-1.4.7-py312h6142ec9_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.21.3-h237132a_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lame-3.100-h1a8c8d9_1003.tar.bz2 @@ -622,223 +633,225 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lerc-4.0.0-h9a09cb3_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libabseil-20240116.2-cxx17_h00cdb27_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libaec-1.1.3-hebf3989_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-17.0.0-h20538ec_13_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-acero-17.0.0-hf9b8971_13_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-dataset-17.0.0-hf9b8971_13_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-substrait-17.0.0-hbf8b706_13_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-17.0.0-hc6a7651_16_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-acero-17.0.0-hf9b8971_16_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-dataset-17.0.0-hf9b8971_16_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-substrait-17.0.0-hbf8b706_16_cpu.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libasprintf-0.22.5-h8414b35_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libasprintf-devel-0.22.5-h8414b35_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libass-0.17.3-hf20b609_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-23_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-26_osxarm64_openblas.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlicommon-1.1.0-hd74edd7_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlidec-1.1.0-hd74edd7_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlienc-1.1.0-hd74edd7_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-23_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-26_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libccd-double-2.1-h9a09cb3_2.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcrc32c-1.1.2-hbdafb3b_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.9.1-hfd8ffcc_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-18.1.8-h3ed4263_7.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libdeflate-1.21-h99b78c6_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.11.1-h73640d1_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-19.1.6-ha82da77_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libdeflate-1.23-hec38601_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20191231-hc8eb9b7_2.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libevent-2.1.12-h2757513_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.6.3-hf9b8971_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.6.4-h286801f_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.4.2-h3422bc3_5.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgettextpo-0.22.5-h8414b35_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgettextpo-devel-0.22.5-h8414b35_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-5.0.0-13_2_0_hd922786_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-13.2.0-hf226fd6_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.80.3-h59d46d9_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgoogle-cloud-2.28.0-hfe08963_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgoogle-cloud-storage-2.28.0-h1466eeb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.82.2-h07bd6cf_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgoogle-cloud-2.29.0-hfa33a2f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgoogle-cloud-storage-2.29.0-h90fd6fa_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgrpc-1.62.2-h9c18a4f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libhwloc-2.11.1-default_h7685b71_1000.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libhwloc-2.11.2-default_hbce5d74_1001.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.17-h0d3ecfb_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libidn2-2.3.7-h93a5062_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.22.5-h8414b35_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-devel-0.22.5-h8414b35_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libjpeg-turbo-3.0.0-hb547adb_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-23_osxarm64_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapacke-3.9.0-23_osxarm64_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.58.0-ha4dd798_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.27-openmp_h517c56d_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopencv-4.10.0-headless_py312h7bc6ef4_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-2024.3.0-h5c9529b_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-arm-cpu-plugin-2024.3.0-h5c9529b_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-auto-batch-plugin-2024.3.0-hcd65546_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-auto-plugin-2024.3.0-hcd65546_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-hetero-plugin-2024.3.0-h88cb26a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-ir-frontend-2024.3.0-h88cb26a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-onnx-frontend-2024.3.0-h32b5460_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-paddle-frontend-2024.3.0-h32b5460_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-pytorch-frontend-2024.3.0-h00cdb27_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-tensorflow-frontend-2024.3.0-h2741c3b_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-tensorflow-lite-frontend-2024.3.0-h00cdb27_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-26_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapacke-3.9.0-26_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.6.3-h39f12f2_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-devel-5.6.3-h39f12f2_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.64.0-h6d7220d_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.28-openmp_hf332438_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopencv-4.10.0-headless_py312haa779ad_6.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-2024.4.0-h49f535f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-arm-cpu-plugin-2024.4.0-h49f535f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-auto-batch-plugin-2024.4.0-h8a2fcec_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-auto-plugin-2024.4.0-h8a2fcec_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-hetero-plugin-2024.4.0-h868cbb4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-ir-frontend-2024.4.0-h868cbb4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-onnx-frontend-2024.4.0-hf4ed89a_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-paddle-frontend-2024.4.0-hf4ed89a_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-pytorch-frontend-2024.4.0-hf9b8971_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-tensorflow-frontend-2024.4.0-h94307f2_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-tensorflow-lite-frontend-2024.4.0-hf9b8971_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopus-1.3.1-h27ca646_1.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libparquet-17.0.0-hf0ba9ef_13_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpng-1.6.43-h091b4b1_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libprotobuf-4.25.3-hbfab5d5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libparquet-17.0.0-hf0ba9ef_16_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpng-1.6.44-hc14010f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libprotobuf-4.25.3-hc39d83c_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libre2-11-2023.09.01-h7b2c953_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.20-h99b78c6_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.46.1-hc14010f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.0-h7a5bd25_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtasn1-4.19.0-h1a8c8d9_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.47.2-h3f77e49_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.1-h9cc3647_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libthrift-0.20.0-h64651cc_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtiff-4.6.0-hf8409c0_4.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtorch-2.3.0-cpu_generic_h95df8ed_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libunistring-0.9.10-h3422bc3_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libutf8proc-2.8.0-h1a8c8d9_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.48.0-h93a5062_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtiff-4.7.0-h551f018_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtorch-2.3.1-cpu_generic_h95df8ed_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libutf8proc-2.8.0-hc098a78_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.49.2-h7ab814d_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libvpx-1.14.1-h7bae524_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libwebp-base-1.4.0-h93a5062_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxcb-1.16-hc9fafa5_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.12.7-h01dff8b_4.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-hfb2fe0b_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-18.1.8-hde57baf_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxcb-1.17.0-hdb1d25a_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.13.5-h178c5d8_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-h8359307_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-19.1.6-hdb05f8b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lz4-c-1.9.4-hb7217d7_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-3.0.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/markupsafe-2.1.5-py312h024a12e_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-3.9.2-py312h1f38498_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-base-3.9.2-py312h32d6e5a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/matplotlib-inline-0.1.7-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/mdit-py-plugins-0.4.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/mistune-3.0.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ml_dtypes-0.4.0-py312hcd31e36_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-3.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/markupsafe-3.0.2-py312h998013c_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-3.9.4-py312h1f38498_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-base-3.9.4-py312hdbc7e53_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/matplotlib-inline-0.1.7-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mdit-py-plugins-0.4.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mistune-3.0.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ml_dtypes-0.5.0-py312hcd31e36_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mpc-1.3.1-h8f1351a_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mpfr-4.2.1-h1cfca0a_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mpfr-4.2.1-hb693164_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/msgpack-numpy-0.4.8-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/msgpack-python-1.1.0-py312h6142ec9_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/munkres-1.1.4-pyh9f0ad1d_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/natsort-8.4.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nbclient-0.10.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-7.16.4-hd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-core-7.16.4-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-pandoc-7.16.4-hd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nbformat-5.10.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/natsort-8.4.0-pyh29332c3_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbclient-0.10.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-7.16.4-hd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-core-7.16.4-pyhff2d567_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-pandoc-7.16.4-hd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbformat-5.10.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-h7bae524_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nest-asyncio-1.6.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/nettle-3.9.1-h40ed0f5_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/networkx-3.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nest-asyncio-1.6.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/networkx-3.4.2-pyh267e887_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.12.1-h420ef59_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/nodejs-22.8.0-h08fde81_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/nodejs-22.12.0-h02a13b7_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/nomkl-1.0-h5ca1d4c_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/notebook-7.2.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/notebook-shim-0.2.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/notebook-7.3.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/notebook-shim-0.2.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-1.26.4-py312h8442bc7_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openexr-3.2.2-h2c51e1d_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/octomap-1.10.0-h7b3277c_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openexr-3.2.2-hab01212_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openh264-2.4.1-hebf3989_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openjpeg-2.5.2-h9f1df11_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.3.2-h8359307_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/opt-einsum-3.3.0-hd8ed1ab_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/opt_einsum-3.3.0-pyhc1e730c_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/optax-0.2.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openjpeg-2.5.3-h8a3d83b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.4.0-h39f12f2_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/opt-einsum-3.4.0-hd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/opt_einsum-3.4.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/optax-0.2.3-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/orc-2.0.2-h75dedd0_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/overrides-7.7.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/p11-kit-0.24.1-h29577a5_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pandoc-3.3-hce30654_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.2-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pandoc-3.6-hce30654_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pandocfilters-1.5.0-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.44-h297a79d_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pdoc-14.4.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pickleshare-0.7.5-py_1003.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pickleshare-0.7.5-pyhd8ed1ab_1004.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pillow-10.3.0-py312h39b1d8d_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pixman-0.43.4-hebf3989_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pkgutil-resolve-name-1.3.10-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.2.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pixman-0.44.2-h2f9eb0b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pkgutil-resolve-name-1.3.10-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.3.6-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/polars-0.20.31-py312h812d8f0_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/prometheus_client-0.20.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/prompt-toolkit-3.0.47-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/prompt_toolkit-3.0.47-hd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-6.0.0-py312h7e5086c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/psygnal-0.11.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pthread-stubs-0.4-h27ca646_1001.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/ptyprocess-0.7.0-pyhd3deb0d_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/prometheus_client-0.21.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/prompt-toolkit-3.0.48-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/prompt_toolkit-3.0.48-hd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-6.1.0-py312h0bf5046_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/psygnal-0.11.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pthread-stubs-0.4-hd74edd7_1002.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ptyprocess-0.7.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pugixml-1.14-h13dd4ca_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pure_eval-0.2.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/py-opencv-4.10.0-headless_py312hd31a7ba_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyarrow-17.0.0-py312ha814d7c_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyarrow-core-17.0.0-py312he20ac61_1_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.18.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyobjc-core-10.3.1-py312hbb55c70_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyobjc-framework-cocoa-10.3.1-py312hbb55c70_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.1.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyright-1.1.379-py312h024a12e_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyha2e5f31_6.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.3.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.12.5-h30c5eda_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.20.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pure_eval-0.2.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/py-opencv-4.10.0-headless_py312hd31a7ba_6.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyarrow-17.0.0-py312ha814d7c_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyarrow-core-17.0.0-py312hc40f475_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pycocotools-2.0.8-py312h755e627_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.18.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyobjc-core-10.3.2-py312hb9d441b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyobjc-framework-cocoa-10.3.2-py312hb9d441b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyright-1.1.390-py312hea69d52_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyha55dd90_7.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.3.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.12.8-hc22306f_1_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhff2d567_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.21.1-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python-json-logger-2.0.7-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python-lzf-0.2.6-pyh568cf5c_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python_abi-3.12-5_cp312.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pytorch-2.3.0-cpu_generic_py312h2aa0b4f_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pytz-2024.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pytorch-2.3.1-cpu_generic_py312h2aa0b4f_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytz-2024.2-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyyaml-6.0.2-py312h024a12e_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyzmq-26.2.0-py312hc6335d2_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyzmq-26.2.0-py312hf8a1cbd_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/qhull-2020.2-h420ef59_5.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/qtconsole-base-5.6.0-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/qtpy-2.4.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/qtconsole-base-5.6.1-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/qtpy-2.4.2-pyhdecd6ff_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/re2-2023.09.01-h4cba328_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.2-h92ec313_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/referencing-0.35.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/referencing-0.35.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.3-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rerun-sdk-0.17.0-py312h5c2e7bc_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/rfc3339-validator-0.1.4-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/rfc3339-validator-0.1.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/rfc3986-validator-0.1.1-pyh9f0ad1d_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rpds-py-0.20.0-py312he431725_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ruff-0.6.4-py312h42f095d_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/scikit-learn-1.5.1-py312h1b546db_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rpds-py-0.22.3-py312hcd83bfe_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ruff-0.8.3-py312h5d18b81_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/scikit-learn-1.5.2-py312h387f99c_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/scipy-1.14.0-py312h14ffa8f_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/send2trash-1.8.3-pyh31c8845_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-73.0.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.16.0-pyh6c4a22f_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/sleef-3.6.1-h7783ee8_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/snappy-1.2.1-hd02b534_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sniffio-1.3.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/send2trash-1.8.3-pyh31c8845_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-75.6.0-pyhff2d567_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/sleef-3.7-h8391f65_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/snappy-1.2.1-h98b9ce2_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sniffio-1.3.1-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/soupsieve-2.5-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/stack_data-0.6.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/svt-av1-2.2.1-ha39b806_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.13.2-pypyh2585a3b_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tbb-2021.13.0-h7b3277c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/termcolor-2.4.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/stack_data-0.6.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/svt-av1-2.3.0-hf24288c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.13.3-pyh2585a3b_104.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tbb-2022.0.0-h0cbf7ec_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/termcolor-2.5.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/terminado-0.18.1-pyh31c8845_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/threadpoolctl-3.5.0-pyhc1e730c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tinycss2-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tinycss2-1.4.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h5083fa2_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/toolz-0.12.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.2.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toolz-1.0.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/torchvision-0.18.0-cpu_py312ha63f1fc_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tornado-6.4.1-py312h024a12e_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tqdm-4.66.5-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.14.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tornado-6.4.2-py312hea69d52_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tqdm-4.67.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.14.3-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/trimesh-4.2.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/types-python-dateutil-2.9.0.20240906-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/typing_utils-0.1.0-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h8827d51_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/uri-template-1.3.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.2.2-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/watchfiles-0.24.0-py312he431725_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.2.13-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/webcolors-24.8.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/webencodings-0.5.1-pyhd8ed1ab_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/websocket-client-1.8.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/widgetsnbextension-4.0.13-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/wrapt-1.16.0-py312h024a12e_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/types-python-dateutil-2.9.0.20241206-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_utils-0.1.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024b-hc8b5060_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/unicodedata2-15.1.0-py312h0bf5046_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/uri-template-1.3.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.2.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/watchfiles-1.0.3-py312hcd83bfe_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.2.13-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/webcolors-24.11.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/webencodings-0.5.1-pyhd8ed1ab_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/websocket-client-1.8.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/widgetsnbextension-4.0.13-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/wrapt-1.17.0-py312hea69d52_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/x264-1!164.3095-h57fd34a_2.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/x265-3.5-hbc6ce65_3.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxau-1.0.11-hb547adb_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxdmcp-1.1.3-h27ca646_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xz-5.2.6-h57fd34a_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxau-1.0.12-h5505292_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxdmcp-1.1.5-hd74edd7_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xz-5.6.3-h9a6d368_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xz-gpl-tools-5.6.3-h9a6d368_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xz-tools-5.6.3-h39f12f2_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/yaml-0.2.5-h3422bc3_2.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zeromq-4.3.5-h64debc3_5.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.20.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zlib-1.3.1-hfb2fe0b_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zeromq-4.3.5-hc1bb282_7.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.21.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zlib-1.3.1-h8359307_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstandard-0.23.0-py312h15fbf35_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.6-hb46c0d2_0.conda - pypi: https://files.pythonhosted.org/packages/a5/45/30bb92d442636f570cb5651bc661f52b610e2eec3f891a5dc3a4c3667db0/aiofiles-24.1.0-py3-none-any.whl @@ -846,31 +859,30 @@ environments: - pypi: https://files.pythonhosted.org/packages/64/43/7a1259741bd989723272ac7d381a43be932422abcff09a1d9f7ba212cb74/beartype-0.18.5-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/49/f5/f4bfff55de6ca82445584eead7fc22f29f3d2bd66a76b8cf4c8c4feb2f32/carvekit-4.1.2-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/00/2e/d53fa4befbf2cfa713304affc7ca780ce4fc1fd8710527771b58311a3229/click-8.1.7-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/96/43/dae06432d0c4b1dc9e9149ad37b4ca8384cf6eb7700cd9215b177b914f0a/cloudpickle-3.0.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/48/41/e1d85ca3cab0b674e277c8c4f678cf66a91cd2cecf93df94353a606fe0db/cloudpickle-3.1.0-py3-none-any.whl - pypi: https://us-west1-python.pkg.dev/probcomp-caliban/probcomp/datasync/datasync-0.0.2-py3-none-any.whl#sha256=ce28394757ba65fa1ff3a3010a1f67720f372c877f7d27bc23176a53e2cfa3a4 - - pypi: https://files.pythonhosted.org/packages/20/8d/778b7d51b981a96554f29136cd59ca7880bf58094338085bcf2a979a0e6a/Deprecated-1.2.14-py2.py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/1d/8f/c7f227eb42cfeaddce3eb0c96c60cbca37797fa7b34f8e1aeadf6c5c0983/Deprecated-1.2.15-py2.py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/10/10/5f9eed00b1186921e447960443f03cda6374cba8cd5cf7aff2b42ecb8a0e/dm_tree-0.1.8-cp312-cp312-macosx_11_0_arm64.whl - - pypi: https://files.pythonhosted.org/packages/08/0f/1d22866c1ff666766b2c207487bef3f06edae096df2f6b4176d5f7072a10/equinox-0.11.5-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/d0/80/17037f322c280efbc623e341358d38d0299c6ee899d619a879b3593aa6da/fastapi-0.114.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/3a/af/411e94c165229882eb2d0a329114826aa52c7c61ef3108d0d3d8ad7189ed/equinox-0.11.10-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/52/b3/7e4df40e585df024fac2f80d1a2d579c854ac37109675db2b0cc22c0bb9e/fastapi-0.115.6-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/a3/61/8001b38461d751cd1a0c3a6ae84346796a5758123f3ed97a1b121dfbf4f3/gast-0.6.0-py3-none-any.whl - - pypi: https://us-west1-python.pkg.dev/probcomp-caliban/probcomp/genjax/genjax-0.5.1-py3-none-any.whl#sha256=1ad4363ce44f64cc1e5d92f826f4c7c14e99370a8c86d39cbe6fa8c3b6a657ce - - pypi: https://files.pythonhosted.org/packages/56/ae/220537f80eb82ae43a299de31edb2a91a28b8c5fb8046e9ff853ec7763cd/jaxtyping-0.2.34-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/03/0a/4f6fed21aa246c6b49b561ca55facacc2a44b87d65b8b92362a8e99ba202/loguru-0.7.2-py3-none-any.whl + - pypi: https://us-west1-python.pkg.dev/probcomp-caliban/probcomp/genjax/genjax-0.6.1-py3-none-any.whl#sha256=7e6afa8ab867266a9fa66ccadab3823d2e93d41d19d671ced853407c8e16cf44 + - pypi: https://files.pythonhosted.org/packages/94/99/c83c6a97f4382caf1c9bfeeeca935d3eb1f479f711665aeadf4408048107/jaxtyping-0.2.36-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/33/55/af02708f230eb77084a299d7b08175cff006dea4f2721074b92cdb0296c0/ordered_set-4.1.0-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/db/7c/9a60add21b96140e22465d9adf09832feade45235cd22f4cb1668a25e443/pandas-2.2.2-cp312-cp312-macosx_11_0_arm64.whl + - pypi: https://files.pythonhosted.org/packages/e1/0c/ad295fd74bfac85358fd579e271cded3ac969de81f62dd0142c426b9da91/pandas-2.2.3-cp312-cp312-macosx_11_0_arm64.whl - pypi: https://files.pythonhosted.org/packages/41/dc/d123e5815af021ba22f9321d6922b03b1c1351170f78c3ebb86c522f24aa/penzai-0.1.5-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/54/38/95bdb5dfcebad2c11c88f7aa2d635fe53a0b7405ef39a6850c8bced455d4/pydantic-2.9.0-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/9e/e3/5c29d8fa6dfabd7809fe623fd17959e1b672410681a8c3811eefa42b8051/pydantic_core-2.23.2-cp312-cp312-macosx_11_0_arm64.whl + - pypi: https://files.pythonhosted.org/packages/62/51/72c18c55cf2f46ff4f91ebcc8f75aa30f7305f3d726be3f4ebffb4ae972b/pydantic-2.10.3-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/7b/9e/f8063952e4a7d0127f5d1181addef9377505dcce3be224263b25c4f0bfd9/pydantic_core-2.27.1-cp312-cp312-macosx_11_0_arm64.whl - pypi: https://files.pythonhosted.org/packages/c3/7e/e2b71b9221ccb8503dce9673e3cb36edcdc314ec374f9e69e6d38ed1abde/pykitti-0.3.1-py2.py3-none-any.whl - - pypi: git+https://github.com/ydkhatri/pyliblzfse.git@a8c00b6bf866410e658a82f88caa04b2cf0a5fea - pypi: https://files.pythonhosted.org/packages/68/6b/a4cc6a28ac80d3bccef0bf869634ee21731e1a85e5ce508c41e1ba0c8437/pyransac3d-0.6.0-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/3d/47/444768600d9e0ebc82f8e347775d24aef8f6348cf00e9fa0e81910814e6d/python_multipart-0.0.9-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/69/13/fa916b69d7c21f80a9c5bde0445cbbbdb9542a9d8df73ea3d588aae55c26/starlette-0.38.4-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/08/be/4781f7da7dde661d32925c0a129d268e03e6bbe00aaa86e48af59c70da61/python_fcl-0.7.0.6-cp312-cp312-macosx_11_0_arm64.whl + - pypi: https://files.pythonhosted.org/packages/45/58/38b5afbc1a800eeea951b9285d3912613f2603bdf897a4ab0f4bd7f405fc/python_multipart-0.0.20-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/96/00/2b325970b3060c7cecebab6d295afe763365822b1306a12eeab198f74323/starlette-0.41.3-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/1e/90/4e8c686f2e691f48e40e16a539c61a6e9880743733d8c4dc3f275d12268e/tensorflow_probability-0.23.0-py2.py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/9a/bb/d43e5c75054e53efce310e79d63df0ac3f25e34c926be5dffb7d283fb2a8/typeguard-2.13.3-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/05/d9/6eebe19d46bd05360c9a9aae822e67a80f9242aabbfc58b641b957546607/typing-3.7.4.3.tar.gz - - pypi: https://files.pythonhosted.org/packages/65/58/f9c9e6be752e9fcb8b6a0ee9fb87e6e7a1f6bcab2cdc73f02bb7ba91ada0/tzdata-2024.1-py2.py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/f5/8e/cdc7d6263db313030e4c257dd5ba3909ebc4e4fb53ad62d5f09b1a2f5458/uvicorn-0.30.6-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/f2/5d/865e17349564eb1772688d8afc5e3081a5964c640d64d1d2880ebaed002d/typing-3.10.0.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/a6/ab/7e5f53c3b9d14972843a647d8d7a853969a58aecc7559cb3267302c94774/tzdata-2024.2-py2.py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/61/14/33a3a1352cfa71812a3a21e8c9bfb83f60b0011f5e36f2b1399d51928209/uvicorn-0.34.0-py3-none-any.whl - pypi: . default: channels: @@ -882,331 +894,406 @@ environments: linux-64: - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/_sysroot_linux-64_curr_repodata_hack-3-h69a702a_16.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/anyio-4.4.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/anywidget-0.9.13-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/asttokens-2.4.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-24.2.0-pyh71513ae_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-auth-0.7.27-hc36b679_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-cal-0.7.4-h2abdd08_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-common-0.9.27-h4bc722e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-compression-0.2.19-haa50ccc_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-event-stream-0.4.3-h570d160_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-http-0.8.8-h9b61739_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-io-0.14.18-h49c7fd3_7.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-mqtt-0.10.4-h5c8269d_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-s3-0.6.5-h9204347_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-sdkutils-0.1.19-h038f3f9_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-checksums-0.1.18-h038f3f9_10.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-crt-cpp-0.28.2-h6552c9e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-sdk-cpp-1.11.379-hc1bef60_8.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-core-cpp-1.13.0-h935415a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-identity-cpp-1.8.0-hd126650_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-blobs-cpp-12.12.0-hd2e3451_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-common-cpp-12.7.0-h10ac4d7_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-files-datalake-cpp-12.11.0-h325d260_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/anyio-4.7.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/anywidget-0.9.13-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/asttokens-3.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-24.3.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-auth-0.8.0-hb921021_15.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-cal-0.8.1-h1a47875_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-common-0.10.6-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-compression-0.3.0-h4e1184b_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-event-stream-0.5.0-h7959bf6_11.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-http-0.9.2-hefd7a92_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-io-0.15.3-h831e299_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-mqtt-0.11.0-h11f4f37_12.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-s3-0.7.7-hf454442_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-sdkutils-0.2.1-h4e1184b_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-checksums-0.2.2-h4e1184b_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-crt-cpp-0.29.7-hd92328a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-sdk-cpp-1.11.458-hc430e4a_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-core-cpp-1.14.0-h5cfcd09_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-identity-cpp-1.10.0-h113e628_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-blobs-cpp-12.13.0-h3cf044e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-common-cpp-12.8.0-h736e048_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-files-datalake-cpp-12.12.0-ha633028_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-1.1.0-hb9d3cd8_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-bin-1.1.0-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-h4bc722e_7.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.33.1-heb4867d_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ca-certificates-2024.8.30-hbcca054_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/comm-0.2.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/decorator-5.1.1-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/elfutils-0.191-h924a536_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/executing-2.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.4-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ca-certificates-2024.12.14-hbcca054_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cached-property-1.5.2-hd8ed1ab_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/cached_property-1.5.2-pyha770c72_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/comm-0.2.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/contourpy-1.3.1-py312h68727a3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.0.11-py312h8fd2918_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/debugpy-1.8.11-py312h2ec8cdc_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/decorator-5.1.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/elfutils-0.192-h7f4e02f_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/executing-2.1.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/fcl-0.7.0-h543440a_6.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/flann-1.9.2-h783367e_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/fonttools-4.55.3-py312h178313f_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/freetype-2.12.1-h267a509_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/gettext-0.22.5-he02047a_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/gettext-tools-0.22.5-he02047a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gflags-2.2.2-he1b5a44_1004.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/gflags-2.2.2-h5888daf_1005.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/glfw-3.4-hd590300_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/glog-0.7.1-hbabe93e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gnutls-3.8.7-h32866dd_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.8-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ipython-8.27.0-pyh707e725_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ipywidgets-8.1.5-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jedi-0.19.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gnutls-3.8.8-h2d3e045_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/h5py-3.12.1-nompi_py312hedeef09_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/hdf5-1.14.3-nompi_h2d575fe_108.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.10-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.5.0-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipykernel-6.29.5-pyh3099207_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipympl-0.9.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipython-8.30.0-pyh707e725_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipython_genutils-0.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipywidgets-8.1.5-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jedi-0.19.2-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-ui-poll-0.2.2-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_widgets-3.0.13-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-3.10.0-h4a8ded7_16.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.6.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_core-5.7.2-pyh31011fe_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_widgets-3.0.13-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-3.10.0-he073ed8_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.1-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/kiwisolver-1.4.7-py312h68727a3_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.3-h659f571_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/lcms2-2.16-hb7c19ff_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.40-hf3520f5_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.43-h712a8e2_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/lerc-4.0.0-h27087fc_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20240116.2-cxx17_he02047a_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libarchive-3.7.4-hfca40fe_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-17.0.0-h8d2e343_13_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-acero-17.0.0-h5888daf_13_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-dataset-17.0.0-h5888daf_13_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-substrait-17.0.0-hf54134d_13_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20240722.0-cxx17_h5888daf_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libaec-1.1.3-h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libarchive-3.7.7-h4585015_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-18.1.0-h44a453e_6_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-acero-18.1.0-hcb10f89_6_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-dataset-18.1.0-hcb10f89_6_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-substrait-18.1.0-h3ee7192_6_cpu.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libasprintf-0.22.5-he8f35ee_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libasprintf-devel-0.22.5-he8f35ee_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-23_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-26_linux64_openblas.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlicommon-1.1.0-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlidec-1.1.0-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlienc-1.1.0-hb9d3cd8_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-23_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-26_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libccd-double-2.1-h59595ed_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcrc32c-1.1.2-h9c3ff4c_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.9.1-hdb1bdb2_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.21-h4bc722e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libdrm-2.4.123-hb9d3cd8_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libdrm-cos7-x86_64-2.4.97-h9b0a68f_1105.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.11.1-h332b0f4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.23-h4ddbbb0_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libdrm-2.4.124-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libdrm-cos7-x86_64-2.4.97-ha675448_1106.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20191231-he28a2e2_2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libegl-1.7.0-ha4b6fd6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libevent-2.1.12-hf998b51_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.6.3-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.6.4-h5888daf_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.2-h7f98852_5.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-14.1.0-h77fa898_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-14.1.0-h69a702a_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-14.2.0-h77fa898_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-14.2.0-h69a702a_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgettextpo-0.22.5-he02047a_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgettextpo-devel-0.22.5-he02047a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-14.1.0-h69a702a_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-14.1.0-h69a702a_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-14.1.0-hc5f4f2c_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.80.3-h315aac3_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libglu-9.0.0-ha6d2627_1004.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-core-devel-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-devel-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-egl-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-gles-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-glx-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-opengl-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-14.1.0-h77fa898_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-2.28.0-h26d7fe4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-storage-2.28.0-ha262f82_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgrpc-1.62.2-h15f2491_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-14.2.0-h69a702a_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-14.2.0-hd5240d6_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.82.2-h2ff4ddf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libglu-9.0.3-h03adeef_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-core-devel-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-devel-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-egl-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-gles-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-glx-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-opengl-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-14.2.0-h77fa898_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-2.32.0-h804f50b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-storage-2.32.0-h0121fbd_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgrpc-1.67.1-hc2c308b_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.17-hd590300_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libidn2-2.3.7-hd590300_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.0.0-hd590300_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-23_linux64_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm18-18.1.8-h8b73ec9_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-26_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm19-19.1.6-ha7bfdaf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.6.3-hb9d3cd8_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libmicrohttpd-1.0.1-hbc5bc17_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.58.0-h47da74e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.64.0-h161d5f1_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hd590300_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.27-pthreads_hac2b453_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libparquet-17.0.0-h39682fd_13_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.28-pthreads_h94d23a6_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libparquet-18.1.0-h081d1f1_6_cpu.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libpciaccess-0.18-hd590300_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.43-h2797004_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-4.25.3-h08a7969_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libre2-11-2023.09.01-h5a48ba9_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.46.1-hadc24fc_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.0-h0841786_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-14.1.0-hc0a3c3a_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-14.1.0-h4852527_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.44-hadc24fc_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-5.28.2-h5b01275_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libre2-11-2024.07.02-hbbce691_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsodium-1.0.20-h4ab18f5_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.47.2-hee588c1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-hf672d98_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-14.2.0-hc0a3c3a_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-14.2.0-h4852527_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libtasn1-4.19.0-h166bdaf_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libthrift-0.20.0-h0e7cc3e_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.6.0-h46a8edc_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libthrift-0.21.0-h0e7cc3e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.0-hd9ff511_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libunistring-0.9.10-h7f98852_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libutf8proc-2.8.0-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libutf8proc-2.9.0-hb9d3cd8_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libwebp-base-1.4.0-hd590300_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.16-hb9d3cd8_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.17.0-h8a09558_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libxkbcommon-1.7.0-h2c5496b_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.12.7-he7c6b58_4.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-h4ab18f5_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/lz4-c-1.9.4-hcb278e6_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.13.5-h0d44e9d_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-hb9d3cd8_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/lz4-c-1.10.0-h5888daf_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/lzo-2.10-hd590300_1001.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/matplotlib-inline-0.1.7-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-khr-devel-cos7-x86_64-18.3.4-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libegl-cos7-x86_64-18.3.4-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libegl-devel-cos7-x86_64-18.3.4-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libgbm-cos7-x86_64-18.3.4-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libglapi-cos7-x86_64-18.3.4-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libglu-cos7-x86_64-9.0.0-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libglu-devel-cos7-x86_64-9.0.0-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/mesalib-24.2.2-h4e3793c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-base-3.10.0-py312hd3ec401_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/matplotlib-inline-0.1.7-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-khr-devel-cos7-x86_64-18.3.4-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libegl-cos7-x86_64-18.3.4-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libegl-devel-cos7-x86_64-18.3.4-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libgbm-cos7-x86_64-18.3.4-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libglapi-cos7-x86_64-18.3.4-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libglu-cos7-x86_64-9.0.0-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libglu-devel-cos7-x86_64-9.0.0-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/mesalib-24.3.1-h0b126fc_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/msgpack-numpy-0.4.8-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/msgpack-python-1.1.0-py312h68727a3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/munkres-1.1.4-pyh9f0ad1d_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-he02047a_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nest-asyncio-1.6.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/nettle-3.9.1-h7ab15ed_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.1.1-py312h58c1407_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/openjpeg-2.5.2-h488ebb8_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.3.2-hb9d3cd8_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/orc-2.0.2-h669347b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.2.0-py312h7e784f5_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/octomap-1.10.0-h84d6215_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openjpeg-2.5.3-h5fbd93e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.4.0-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/orc-2.0.3-h97ab989_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/p11-kit-0.24.1-hc5aa10d_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.2-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.44-hba22ea6_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pickleshare-0.7.5-py_1003.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/pillow-10.4.0-py312h287a98d_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/prompt-toolkit-3.0.47-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/psygnal-0.11.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-h36c2ea0_1001.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/ptyprocess-0.7.0-pyhd3deb0d_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/pure_eval-0.2.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pyarrow-17.0.0-py312h9cebb41_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pyarrow-core-17.0.0-py312h9cafe31_1_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.18.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.12.5-h2ad013b_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pickleshare-0.7.5-pyhd8ed1ab_1004.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pillow-11.0.0-py312h7b63e92_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.3.6-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/prompt-toolkit-3.0.48-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-6.1.0-py312h66e93f0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/psygnal-0.11.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-hb9d3cd8_1002.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ptyprocess-0.7.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pure_eval-0.2.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyarrow-18.1.0-py312h7900ff3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyarrow-core-18.1.0-py312h01725c0_0_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pycocotools-2.0.8-py312hc0a28a1_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.18.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.12.8-h9e4cc4f_1_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhff2d567_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/python_abi-3.12-5_cp312.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/re2-2023.09.01-h7f4b329_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyzmq-26.2.0-py312hbf22597_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/qhull-2020.2-h434a139_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/re2-2024.07.02-h77b4e00_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8228510_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/rerun-sdk-0.17.0-py312hbe4c86d_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/s2n-1.5.1-h3400bea_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.16.0-pyh6c4a22f_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/snappy-1.2.1-ha2e4443_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sniffio-1.3.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/stack_data-0.6.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.17-h4a8ded7_16.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/s2n-1.5.10-hb5b8611_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/snappy-1.2.1-h8bd8927_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sniffio-1.3.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/stack_data-0.6.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.17-h4a8ded7_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h4845f30_101.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.14.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h8827d51_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/watchfiles-0.24.0-py312h12e396e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tornado-6.4.2-py312h66e93f0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.14.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024b-hc8b5060_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/unicodedata2-15.1.0-py312h66e93f0_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/watchfiles-1.0.3-py312h12e396e_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/wayland-1.23.1-h3e06ad9_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.2.13-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/widgetsnbextension-4.0.13-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/wrapt-1.16.0-py312h66e93f0_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xkeyboard-config-2.42-h4ab18f5_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-damageproto-1.2.1-h7f98852_1002.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-fixesproto-5.0-h7f98852_1002.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-glproto-1.4.17-h7f98852_1002.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-kbproto-1.0.7-h7f98852_1002.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libx11-1.8.9-hb711507_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.11-hd590300_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdamage-1.1.5-h7f98852_1.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.3-h7f98852_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxext-1.3.4-h0b41bf4_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxfixes-5.0.3-h7f98852_1004.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxinerama-1.1.5-h27087fc_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrandr-1.5.2-h7f98852_1.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrender-0.9.11-hd590300_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxxf86vm-1.1.5-h4bc722e_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-randrproto-1.5.0-h7f98852_1001.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-renderproto-0.11.1-h7f98852_1002.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-util-macros-1.19.3-h7f98852_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-xextproto-7.3.0-h0b41bf4_1003.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-xf86vidmodeproto-2.3.1-h7f98852_1002.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-xproto-7.0.31-h7f98852_1007.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-5.2.6-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.2.13-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/widgetsnbextension-4.0.13-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/wrapt-1.17.0-py312h66e93f0_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xkeyboard-config-2.43-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libx11-1.8.10-h4f16b4b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.12-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdamage-1.1.6-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.5-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxext-1.3.6-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxfixes-6.0.1-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxinerama-1.1.5-h5888daf_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrandr-1.5.4-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrender-0.9.12-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxshmfence-1.3.3-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxxf86vm-1.1.6-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zeromq-4.3.5-h3b0a872_7.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.21.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.6-ha6fb4c9_0.conda - pypi: . osx-arm64: - - conda: https://conda.anaconda.org/conda-forge/noarch/anyio-4.4.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/anywidget-0.9.13-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/asttokens-2.4.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-24.2.0-pyh71513ae_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-auth-0.7.27-h1e647a1_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-cal-0.7.4-h41e72e7_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-common-0.9.27-h99b78c6_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-compression-0.2.19-h41e72e7_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-event-stream-0.4.3-h79ff00d_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-http-0.8.8-h69517e7_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-io-0.14.18-h20e6805_7.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-mqtt-0.10.4-h3e8bf47_18.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-s3-0.6.5-h5e39592_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-sdkutils-0.1.19-h85401af_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-checksums-0.1.18-h85401af_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-crt-cpp-0.28.2-h6f2a9b6_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-sdk-cpp-1.11.379-h8d911dc_8.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-core-cpp-1.13.0-hd01fc5c_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-identity-cpp-1.8.0-h13ea094_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-storage-blobs-cpp-12.12.0-hfde595f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-storage-common-cpp-12.7.0-hcf3b6fd_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-storage-files-datalake-cpp-12.11.0-h082e32e_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/anyio-4.7.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/anywidget-0.9.13-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/appnope-0.1.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/asttokens-3.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-24.3.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-auth-0.8.0-h8bc59a9_15.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-cal-0.8.1-hc8a0bd2_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-common-0.10.6-h5505292_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-compression-0.3.0-hc8a0bd2_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-event-stream-0.5.0-h54f970a_11.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-http-0.9.2-h96aa502_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-io-0.15.3-haba67d1_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-mqtt-0.11.0-h24f418c_12.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-s3-0.7.7-h1be5864_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-sdkutils-0.2.1-hc8a0bd2_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-checksums-0.2.2-hc8a0bd2_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-crt-cpp-0.29.7-h19a973c_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-sdk-cpp-1.11.458-he0ff2e4_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-core-cpp-1.14.0-hd50102c_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-identity-cpp-1.10.0-hc602bab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-storage-blobs-cpp-12.13.0-h7585a09_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-storage-common-cpp-12.8.0-h9ca1f76_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-storage-files-datalake-cpp-12.12.0-hcdd55da_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-1.1.0-hd74edd7_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-bin-1.1.0-hd74edd7_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h99b78c6_7.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.33.1-hd74edd7_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ca-certificates-2024.8.30-hf0a4a13_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/comm-0.2.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/decorator-5.1.1-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/executing-2.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.4-h5505292_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ca-certificates-2024.12.14-hf0a4a13_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cached-property-1.5.2-hd8ed1ab_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/cached_property-1.5.2-pyha770c72_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/comm-0.2.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/contourpy-1.3.1-py312hb23fbb9_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cython-3.0.11-py312hde4cb15_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/debugpy-1.8.11-py312hd8f9ff3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/decorator-5.1.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/executing-2.1.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/fcl-0.7.0-he078184_6.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/flann-1.9.2-h5d00db4_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/fonttools-4.55.3-py312h998013c_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/freetype-2.12.1-hadb7bae_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gflags-2.2.2-hc88da5d_1004.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gflags-2.2.2-hf9b8971_1005.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/glog-0.7.1-heb240a5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/h5py-3.12.1-nompi_py312h3cd0824_102.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/hdf5-1.14.3-nompi_ha698983_108.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-75.1-hfee45f7_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.8-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ipython-8.27.0-pyh707e725_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ipywidgets-8.1.5-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jedi-0.19.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.10-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.5.0-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipykernel-6.29.5-pyh57ce528_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipympl-0.9.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipython-8.30.0-pyh707e725_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipython_genutils-0.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipywidgets-8.1.5-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jedi-0.19.2-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-ui-poll-0.2.2-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_widgets-3.0.13-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.6.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_core-5.7.2-pyh31011fe_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_widgets-3.0.13-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/kiwisolver-1.4.7-py312h6142ec9_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.21.3-h237132a_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lcms2-2.16-ha0e7c42_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lerc-4.0.0-h9a09cb3_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libabseil-20240116.2-cxx17_h00cdb27_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-17.0.0-h20538ec_13_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-acero-17.0.0-hf9b8971_13_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-dataset-17.0.0-hf9b8971_13_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-substrait-17.0.0-hbf8b706_13_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-23_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libabseil-20240722.0-cxx17_hf9b8971_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libaec-1.1.3-hebf3989_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-18.1.0-h4a2f8bd_6_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-acero-18.1.0-hf07054f_6_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-dataset-18.1.0-hf07054f_6_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-substrait-18.1.0-h86344ea_6_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-26_osxarm64_openblas.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlicommon-1.1.0-hd74edd7_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlidec-1.1.0-hd74edd7_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlienc-1.1.0-hd74edd7_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-23_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-26_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libccd-double-2.1-h9a09cb3_2.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcrc32c-1.1.2-hbdafb3b_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.9.1-hfd8ffcc_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-18.1.8-h3ed4263_7.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libdeflate-1.21-h99b78c6_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.11.1-h73640d1_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-19.1.6-ha82da77_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libdeflate-1.23-hec38601_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20191231-hc8eb9b7_2.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libevent-2.1.12-h2757513_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.6.3-hf9b8971_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.6.4-h286801f_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.4.2-h3422bc3_5.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-5.0.0-13_2_0_hd922786_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-13.2.0-hf226fd6_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgoogle-cloud-2.28.0-hfe08963_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgoogle-cloud-storage-2.28.0-h1466eeb_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgrpc-1.62.2-h9c18a4f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgoogle-cloud-2.32.0-h8d8be31_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgoogle-cloud-storage-2.32.0-h7081f7f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgrpc-1.67.1-hc70892a_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.17-h0d3ecfb_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libjpeg-turbo-3.0.0-hb547adb_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-23_osxarm64_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.58.0-ha4dd798_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.27-openmp_h517c56d_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libparquet-17.0.0-hf0ba9ef_13_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpng-1.6.43-h091b4b1_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libprotobuf-4.25.3-hbfab5d5_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libre2-11-2023.09.01-h7b2c953_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.46.1-hc14010f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.0-h7a5bd25_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libthrift-0.20.0-h64651cc_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtiff-4.6.0-hf8409c0_4.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libutf8proc-2.8.0-h1a8c8d9_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-26_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.6.3-h39f12f2_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.64.0-h6d7220d_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.28-openmp_hf332438_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libparquet-18.1.0-h636d7b7_6_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpng-1.6.44-hc14010f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libprotobuf-5.28.2-h8f0b736_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libre2-11-2024.07.02-h2348fd5_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.20-h99b78c6_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.47.2-h3f77e49_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.1-h9cc3647_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libthrift-0.21.0-h64651cc_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtiff-4.7.0-h551f018_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libutf8proc-2.9.0-h5505292_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libwebp-base-1.4.0-h93a5062_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxcb-1.16-hc9fafa5_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.12.7-h01dff8b_4.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-hfb2fe0b_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-18.1.8-hde57baf_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lz4-c-1.9.4-hb7217d7_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/matplotlib-inline-0.1.7-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxcb-1.17.0-hdb1d25a_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.13.5-h178c5d8_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-h8359307_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-19.1.6-hdb05f8b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lz4-c-1.10.0-h286801f_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-base-3.10.0-py312hdbc7e53_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/matplotlib-inline-0.1.7-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/msgpack-numpy-0.4.8-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/msgpack-python-1.1.0-py312h6142ec9_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/munkres-1.1.4-pyh9f0ad1d_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-h7bae524_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nest-asyncio-1.6.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-1.26.4-py312h8442bc7_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openjpeg-2.5.2-h9f1df11_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.3.2-h8359307_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/orc-2.0.2-h75dedd0_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pickleshare-0.7.5-py_1003.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pillow-10.4.0-py312h39b1d8d_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/prompt-toolkit-3.0.47-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/psygnal-0.11.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pthread-stubs-0.4-h27ca646_1001.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/ptyprocess-0.7.0-pyhd3deb0d_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/pure_eval-0.2.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyarrow-17.0.0-py312ha814d7c_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyarrow-core-17.0.0-py312he20ac61_1_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.18.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.12.5-h30c5eda_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/octomap-1.10.0-h7b3277c_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openjpeg-2.5.3-h8a3d83b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.4.0-h39f12f2_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/orc-2.0.3-hbcee414_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.2-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pickleshare-0.7.5-pyhd8ed1ab_1004.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pillow-11.0.0-py312haf37ca6_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.3.6-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/prompt-toolkit-3.0.48-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-6.1.0-py312h0bf5046_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/psygnal-0.11.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pthread-stubs-0.4-hd74edd7_1002.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ptyprocess-0.7.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pure_eval-0.2.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyarrow-18.1.0-py312h1f38498_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyarrow-core-18.1.0-py312hc40f475_0_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pycocotools-2.0.8-py312h755e627_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.18.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.12.8-hc22306f_1_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhff2d567_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python_abi-3.12-5_cp312.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/re2-2023.09.01-h4cba328_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyzmq-26.2.0-py312hf8a1cbd_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/qhull-2020.2-h420ef59_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/re2-2024.07.02-hcd0e937_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.2-h92ec313_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rerun-sdk-0.17.0-py312h5c2e7bc_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/scipy-1.14.0-py312h14ffa8f_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.16.0-pyh6c4a22f_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/snappy-1.2.1-hd02b534_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sniffio-1.3.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/stack_data-0.6.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/snappy-1.2.1-h98b9ce2_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sniffio-1.3.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/stack_data-0.6.3-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h5083fa2_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.14.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h8827d51_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/watchfiles-0.24.0-py312he431725_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.2.13-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/widgetsnbextension-4.0.13-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/wrapt-1.16.0-py312h024a12e_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxau-1.0.11-hb547adb_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxdmcp-1.1.3-h27ca646_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xz-5.2.6-h57fd34a_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tornado-6.4.2-py312hea69d52_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.14.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024b-hc8b5060_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/unicodedata2-15.1.0-py312h0bf5046_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/watchfiles-1.0.3-py312hcd83bfe_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.2.13-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/widgetsnbextension-4.0.13-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/wrapt-1.17.0-py312hea69d52_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxau-1.0.12-h5505292_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxdmcp-1.1.5-hd74edd7_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zeromq-4.3.5-hc1bb282_7.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.21.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.6-hb46c0d2_0.conda - pypi: . gpu: @@ -1219,697 +1306,761 @@ environments: linux-64: - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_kmp_llvm.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/_sysroot_linux-64_curr_repodata_hack-3-h69a702a_16.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/absl-py-2.1.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/alsa-lib-1.2.12-h4ab18f5_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/anyio-4.4.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/anywidget-0.9.13-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/absl-py-2.1.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/aiohappyeyeballs-2.4.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aiohttp-3.11.10-py312h178313f_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/aiosignal-1.3.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/alsa-lib-1.2.13-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/anyio-4.7.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/anywidget-0.9.13-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/aom-3.9.1-hac33072_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/argon2-cffi-23.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/argon2-cffi-23.1.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/argon2-cffi-bindings-21.2.0-py312h66e93f0_5.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/arrow-1.3.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/asttokens-2.4.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/astunparse-1.6.3-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/async-lru-2.0.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-24.2.0-pyh71513ae_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-auth-0.7.27-hc36b679_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-cal-0.7.4-h2abdd08_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-common-0.9.27-h4bc722e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-compression-0.2.19-haa50ccc_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-event-stream-0.4.3-h570d160_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-http-0.8.8-h9b61739_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-io-0.14.18-h49c7fd3_7.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-mqtt-0.10.4-h5c8269d_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-s3-0.6.5-h9204347_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-sdkutils-0.1.19-h038f3f9_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-checksums-0.1.18-h038f3f9_10.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-crt-cpp-0.28.2-h6552c9e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-sdk-cpp-1.11.379-hc1bef60_8.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/arrow-1.3.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/assimp-5.4.2-he2e0bbc_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/asttokens-3.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/astunparse-1.6.3-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/async-lru-2.0.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-24.3.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-auth-0.7.31-he1a10d6_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-cal-0.7.4-hae4d56a_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-common-0.9.29-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-compression-0.2.19-h2bff981_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-event-stream-0.4.3-h19b0707_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-http-0.8.10-h14a7884_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-io-0.14.19-hc9e6898_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-mqtt-0.10.7-hb8d5873_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-s3-0.6.7-h666547d_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-sdkutils-0.1.19-h2bff981_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-checksums-0.1.20-h2bff981_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-crt-cpp-0.28.3-hbe26082_8.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-sdk-cpp-1.11.407-h25d6d5c_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-core-cpp-1.13.0-h935415a_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-identity-cpp-1.8.0-hd126650_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-blobs-cpp-12.12.0-hd2e3451_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-common-cpp-12.7.0-h10ac4d7_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-files-datalake-cpp-12.11.0-h325d260_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.14.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/beautifulsoup4-4.12.3-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.40-h4852527_7.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.40-ha1999f0_7.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.40-hb3c18ed_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/bleach-6.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.16.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/beautifulsoup4-4.12.3-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.43-h4852527_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.43-h4bf12b8_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.43-h4852527_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/bleach-6.2.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/blinker-1.9.0-pyhff2d567_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/blosc-1.21.6-hef167b5_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-1.1.0-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-bin-1.1.0-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-python-1.1.0-py312h2ec8cdc_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-h4bc722e_7.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.33.1-heb4867d_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.4-hb9d3cd8_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.7.0-hd590300_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ca-certificates-2024.8.30-hbcca054_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ca-certificates-2024.12.14-hbcca054_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cached-property-1.5.2-hd8ed1ab_1.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/cached_property-1.5.2-pyha770c72_1.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/cairo-1.18.0-hebfffa5_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2024.8.30-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cairo-1.18.0-h3faef2a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cccl-2.4.0-h7ab4013_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2024.12.14-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cffi-1.17.1-py312h06ac9bb_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.3.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/chex-0.1.86-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/comm-0.2.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/contourpy-1.3.0-py312h68727a3_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-64-12.6.37-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-command-line-tools-12.6.1-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-compiler-12.6.1-hbad6d8a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-64-12.6.68-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-crt-tools-12.6.68-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-12.6.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-dev-12.6.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-64-12.6.68-h3f2d84a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-static-12.6.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-64-12.6.68-h3f2d84a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-64-12.6.68-h3f2d84a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cuobjdump-12.6.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cupti-12.6.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cupti-dev-12.6.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cuxxfilt-12.6.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-driver-dev-12.6.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-driver-dev_linux-64-12.6.68-h3f2d84a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-gdb-12.6.68-hf8b0789_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-libraries-12.6.1-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-libraries-dev-12.6.1-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nsight-12.6.68-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvcc-12.6.68-hcdd1206_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvcc-dev_linux-64-12.6.68-he91c749_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvcc-impl-12.6.68-h85509e4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvcc-tools-12.6.68-he02047a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvcc_linux-64-12.6.68-h8a487aa_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvdisasm-12.6.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvml-dev-12.6.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvprof-12.6.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvprune-12.6.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-12.6.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-dev-12.6.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvtx-12.6.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-64-12.6.68-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-12.6.68-he02047a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-tools-12.6.68-he02047a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvp-12.6.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-opencl-12.6.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-opencl-dev-12.6.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-profiler-api-12.6.68-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-sanitizer-api-12.6.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-toolkit-12.6.1-ha804496_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-tools-12.6.1-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-12.6-h7480c83_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-visual-tools-12.6.1-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/chex-0.1.88-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-unix_pyh707e725_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/comm-0.2.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/contourpy-1.3.1-py312h68727a3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.12.8-py312hd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cccl-12.5.39-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-64-12.5.39-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-command-line-tools-12.5.0-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-compiler-12.5.0-hbad6d8a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-64-12.5.40-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-crt-tools-12.5.40-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-12.5.39-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-dev-12.5.39-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-64-12.5.39-h85509e4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-static-12.5.39-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-64-12.5.39-h85509e4_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-64-12.5.39-h85509e4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cuobjdump-12.5.39-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cupti-12.5.39-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cupti-dev-12.5.39-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cuxxfilt-12.5.39-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-driver-dev-12.5.39-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-driver-dev_linux-64-12.5.82-h85509e4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-gdb-12.5.39-hda18ab6_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-libraries-12.5.0-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-libraries-dev-12.5.0-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nsight-12.5.39-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvcc-12.5.40-hcdd1206_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvcc-dev_linux-64-12.5.40-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvcc-impl-12.5.40-hd3aeb46_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvcc-tools-12.5.40-hd3aeb46_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvcc_linux-64-12.5.40-h8a487aa_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvdisasm-12.5.39-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvml-dev-12.5.39-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvprof-12.5.39-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvprune-12.5.39-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-12.5.40-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-dev-12.5.40-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvtx-12.5.39-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-64-12.5.40-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-12.5.40-h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-tools-12.5.40-h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvp-12.5.39-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-opencl-12.5.39-he02047a_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-opencl-dev-12.5.39-he02047a_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-profiler-api-12.5.39-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-sanitizer-api-12.5.39-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-toolkit-12.5.0-ha804496_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-tools-12.5.0-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-12.5-hd4f0392_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-visual-tools-12.5.0-ha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cudnn-8.9.7.29-h092f7fd_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.7.0-h00ab1b0_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.0.11-py312h8fd2918_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/dash-2.18.2-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/dav1d-1.2.1-hd590300_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.13.6-h5008d03_3.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/debugpy-1.8.5-py312h2ec8cdc_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/decorator-5.1.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/debugpy-1.8.11-py312h2ec8cdc_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/decorator-5.1.1-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/defusedxml-0.7.1-pyhd8ed1ab_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/distinctipy-1.3.4-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/double-conversion-3.3.0-h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/eigen-3.4.0-h00ab1b0_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/elfutils-0.191-h924a536_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/entrypoints-0.4-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/executing-2.1.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/expat-2.6.3-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ffmpeg-6.1.2-gpl_h226ea3b_102.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.15.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/embree-3.13.0-habf647b_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/entrypoints-0.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/etils-1.10.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/executing-2.1.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/expat-2.6.4-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/fcl-0.7.0-h543440a_6.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ffmpeg-6.1.1-gpl_h853fe30_113.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.16.1-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/fire-0.6.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/flann-1.9.2-h776a335_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/flask-3.1.0-pyhff2d567_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/fmt-9.1.0-h924138e_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/fontconfig-2.14.2-h14ed4e7_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/fontconfig-2.15.0-h7e30c49_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-forge-1-0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/fonttools-4.53.1-py312h66e93f0_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/fqdn-1.5.1-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/freeglut-3.2.2-ha6d2627_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/fonttools-4.55.3-py312h178313f_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/fqdn-1.5.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/freeglut-3.2.2-hac7e632_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/freetype-2.12.1-h267a509_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/fribidi-1.0.10-h36c2ea0_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/fsspec-2024.9.0-pyhff2d567_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/frozenlist-1.5.0-py312h66e93f0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/fsspec-2024.10.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-12.4.0-h236703b_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-12.4.0-hb2e57f8_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-12.4.0-h6b7512a_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gds-tools-1.11.1.6-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-12.4.0-h6b7512a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gds-tools-1.10.0.4-he02047a_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/gettext-0.22.5-he02047a_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/gettext-tools-0.22.5-he02047a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gflags-2.2.2-he1b5a44_1004.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/gflags-2.2.2-h5888daf_1005.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gl2ps-1.4.2-hae5d5c5_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/glew-2.1.0-h9c3ff4c_2.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/glfw-3.4-hd590300_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/glog-0.7.1-hbabe93e_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/gmp-6.3.0-hac33072_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gmpy2-2.1.5-py312h7201bc8_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gnutls-3.8.7-h32866dd_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gmpy2-2.1.5-py312h7201bc8_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gnutls-3.7.9-hb077bed_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/graphite2-1.3.13-h59595ed_1003.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-12.4.0-h236703b_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-12.4.0-h613a52c_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-12.4.0-h8489865_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/h11-0.14.0-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/h2-4.1.0-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/harfbuzz-9.0.0-hda332d3_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/hdf5-1.14.3-nompi_hdf9ad27_105.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/hpack-4.0.0-pyh9f0ad1d_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/httpcore-1.0.5-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/httpx-0.27.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/hyperframe-6.0.1-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.8-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/imageio-2.35.1-pyh12aca89_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/imath-3.1.11-hfc55251_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.4.0-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_metadata-8.4.0-hd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.4.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-12.4.0-h8489865_7.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/h11-0.14.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/h2-4.1.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/h5py-3.11.0-nompi_py312hedeef09_103.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/harfbuzz-8.5.0-hfac3d4d_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/hdf4-4.2.15-h2a13503_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/hdf5-1.14.3-nompi_h2d575fe_108.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hpack-4.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/httpcore-1.0.7-pyh29332c3_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/httpx-0.28.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hyperframe-6.0.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-73.2-h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.10-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/imageio-2.36.1-pyh12aca89_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/imath-3.1.12-h7955e40_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.5.0-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_metadata-8.5.0-hd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.4.5-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/ipykernel-6.29.5-pyh3099207_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipympl-0.9.5-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/ipython-8.26.0-pyh707e725_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ipywidgets-8.1.5-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/isoduration-20.11.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/ipython_genutils-0.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipywidgets-8.1.5-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/isoduration-20.11.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/itsdangerous-2.2.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/jasper-4.2.4-h536e39c_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/jax-0.4.28-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/jaxlib-0.4.28-cuda120py312h4008524_200.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jedi-0.19.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/joblib-1.4.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/json5-0.9.25-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jedi-0.19.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/joblib-1.4.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/json5-0.10.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/jsoncpp-1.9.5-h4bd325d_1.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/jsonpointer-3.0.0-py312h7900ff3_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-4.23.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-specifications-2023.12.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-with-format-nongpl-4.23.0-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-4.23.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-specifications-2024.10.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-with-format-nongpl-4.23.0-hd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-1.0.0-pyhd8ed1ab_10.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-lsp-2.2.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-lsp-2.2.5-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-ui-poll-0.2.2-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.6.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_console-6.6.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/jupyter_core-5.7.2-py312h7900ff3_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_events-0.10.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_server-2.14.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_server_terminals-0.5.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab-4.2.5-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_pygments-0.3.0-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_server-2.27.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_widgets-3.0.13-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupytext-1.16.4-pyh80e38bb_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-3.10.0-h4a8ded7_16.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.6.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_console-6.6.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_core-5.7.2-pyh31011fe_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_events-0.11.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_server-2.14.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_server_terminals-0.5.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab-4.3.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_pygments-0.3.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_server-2.27.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_widgets-3.0.13-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupytext-1.16.5-pyhbbac1ac_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-3.10.0-he073ed8_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.1-h166bdaf_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/kiwisolver-1.4.7-py312h68727a3_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.3-h659f571_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/lame-3.100-h166bdaf_1003.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/lcms2-2.16-hb7c19ff_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.40-hf3520f5_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.43-h712a8e2_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/lerc-4.0.0-h27087fc_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20240116.2-cxx17_he02047a_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libaec-1.1.3-h59595ed_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libarchive-3.7.4-hfca40fe_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-17.0.0-h8d2e343_13_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-acero-17.0.0-h5888daf_13_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-dataset-17.0.0-h5888daf_13_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-substrait-17.0.0-hf54134d_13_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-17.0.0-had3b6fe_16_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-acero-17.0.0-h5888daf_16_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-dataset-17.0.0-h5888daf_16_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-substrait-17.0.0-hf54134d_16_cpu.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libasprintf-0.22.5-he8f35ee_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libasprintf-devel-0.22.5-he8f35ee_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libass-0.17.3-h1dc1e6a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-23_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libass-0.17.1-h8fe9dca_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-26_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.86.0-hf299e74_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlicommon-1.1.0-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlidec-1.1.0-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlienc-1.1.0-hb9d3cd8_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-23_linux64_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp18.1-18.1.8-default_hf981a13_4.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang13-18.1.8-default_h9def88c_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-26_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libccd-double-2.1-h59595ed_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp18.1-18.1.8-default_hf981a13_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang13-19.1.2-default_h9c6a7e4_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcrc32c-1.1.2-h9c3ff4c_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcublas-12.6.1.4-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcublas-dev-12.6.1.4-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufft-11.2.6.59-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufft-dev-11.2.6.59-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-1.11.1.6-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-dev-1.11.1.6-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcublas-12.5.2.13-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcublas-dev-12.5.2.13-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufft-11.2.3.18-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufft-dev-11.2.3.18-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-1.10.0.4-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-dev-1.10.0.4-he02047a_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcups-2.3.3-h4637d8d_4.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurand-10.3.7.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurand-dev-10.3.7.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.9.1-hdb1bdb2_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcusolver-11.6.4.69-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcusolver-dev-11.6.4.69-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcusparse-12.5.3.3-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcusparse-dev-12.5.3.3-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.21-h4bc722e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libdrm-2.4.123-hb9d3cd8_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libdrm-cos7-x86_64-2.4.97-h9b0a68f_1105.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurand-10.3.6.39-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurand-dev-10.3.6.39-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.11.1-h332b0f4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcusolver-11.6.2.40-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcusolver-dev-11.6.2.40-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcusparse-12.4.1.24-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcusparse-dev-12.4.1.24-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.23-h4ddbbb0_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libdrm-2.4.124-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libdrm-cos7-x86_64-2.4.97-ha675448_1106.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20191231-he28a2e2_2.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/libegl-1.7.0-ha4b6fd6_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libevent-2.1.12-hf998b51_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.6.3-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.6.4-h5888daf_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.2-h7f98852_5.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-14.1.0-h77fa898_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-14.2.0-h77fa898_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-12.4.0-ha4f9413_101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-14.1.0-h69a702a_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-14.2.0-h69a702a_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgettextpo-0.22.5-he02047a_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgettextpo-devel-0.22.5-he02047a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-14.1.0-h69a702a_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-14.1.0-h69a702a_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-14.1.0-hc5f4f2c_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-14.2.0-h69a702a_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-14.2.0-hd5240d6_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.80.3-h315aac3_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libglu-9.0.0-ha6d2627_1004.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.80.2-hf974151_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libglu-9.0.0-hac7e632_1003.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-core-devel-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-devel-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-egl-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-gles-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-glx-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-opengl-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-core-devel-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-devel-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-egl-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-gles-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-glx-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-opengl-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-14.1.0-h77fa898_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-2.28.0-h26d7fe4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-storage-2.28.0-ha262f82_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-14.2.0-h77fa898_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-2.29.0-h435de7b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-storage-2.29.0-h0121fbd_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgrpc-1.62.2-h15f2491_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libhwloc-2.11.1-default_hecaa2ac_1000.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libhwloc-2.11.2-default_he43201b_1000.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.17-hd590300_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libidn2-2.3.7-hd590300_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.0.0-hd590300_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-23_linux64_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapacke-3.9.0-23_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-26_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapacke-3.9.0-26_linux64_openblas.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm18-18.1.8-h8b73ec9_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm19-19.1.2-ha7bfdaf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzf-3.6-hb9d3cd8_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.6.3-hb9d3cd8_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-devel-5.6.3-hb9d3cd8_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libmagma-2.7.2-h173bb3b_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libmagma_sparse-2.7.2-h173bb3b_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libmicrohttpd-1.0.1-hbc5bc17_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.58.0-h47da74e_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnpp-12.3.1.54-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnpp-dev-12.3.1.54-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libmicrohttpd-1.0.1-h97afed2_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnetcdf-4.9.2-nompi_h135f659_114.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.64.0-h161d5f1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnpp-12.3.0.116-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnpp-dev-12.3.0.116-he02047a_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hd590300_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvfatbin-12.6.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvfatbin-dev-12.6.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvjitlink-12.6.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvjitlink-dev-12.6.68-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvjpeg-12.3.3.54-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvjpeg-dev-12.3.3.54-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.27-pthreads_hac2b453_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopencv-4.10.0-qt6_py312h6ebf6f7_603.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-2024.3.0-h2da1b83_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-auto-batch-plugin-2024.3.0-hb045406_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-auto-plugin-2024.3.0-hb045406_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-hetero-plugin-2024.3.0-h5c03a75_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-cpu-plugin-2024.3.0-h2da1b83_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-gpu-plugin-2024.3.0-h2da1b83_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-npu-plugin-2024.3.0-h2da1b83_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-ir-frontend-2024.3.0-h5c03a75_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-onnx-frontend-2024.3.0-h07e8aee_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-paddle-frontend-2024.3.0-h07e8aee_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-pytorch-frontend-2024.3.0-he02047a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-tensorflow-frontend-2024.3.0-h39126c6_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-tensorflow-lite-frontend-2024.3.0-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvfatbin-12.5.39-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvfatbin-dev-12.5.39-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvjitlink-12.5.40-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvjitlink-dev-12.5.40-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvjpeg-12.3.2.38-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvjpeg-dev-12.3.2.38-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libogg-1.3.5-h4ab18f5_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.28-pthreads_h94d23a6_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopencv-4.10.0-qt6_py312h131ea51_601.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopengl-1.7.0-ha4b6fd6_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-2024.2.0-h2da1b83_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-auto-batch-plugin-2024.2.0-hb045406_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-auto-plugin-2024.2.0-hb045406_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-hetero-plugin-2024.2.0-h5c03a75_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-cpu-plugin-2024.2.0-h2da1b83_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-gpu-plugin-2024.2.0-h2da1b83_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-npu-plugin-2024.2.0-he02047a_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-ir-frontend-2024.2.0-h5c03a75_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-onnx-frontend-2024.2.0-h07e8aee_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-paddle-frontend-2024.2.0-h07e8aee_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-pytorch-frontend-2024.2.0-he02047a_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-tensorflow-frontend-2024.2.0-h39126c6_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-tensorflow-lite-frontend-2024.2.0-he02047a_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libopus-1.3.1-h7f98852_1.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libparquet-17.0.0-h39682fd_13_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libparquet-17.0.0-h39682fd_16_cpu.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libpciaccess-0.18-hd590300_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.43-h2797004_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libpq-16.4-h2d7952a_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-4.25.3-h08a7969_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.44-hadc24fc_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpq-16.6-h035377e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-4.25.3-hd5b35b9_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libre2-11-2023.09.01-h5a48ba9_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-12.4.0-h46f95d5_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsodium-1.0.20-h4ab18f5_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.46.1-hadc24fc_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.0-h0841786_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-14.1.0-hc0a3c3a_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.47.2-hee588c1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-hf672d98_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-14.2.0-hc0a3c3a_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-12.4.0-ha4f9413_101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-14.1.0-h4852527_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-14.2.0-h4852527_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libtasn1-4.19.0-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libtheora-1.1.1-h4ab18f5_1006.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libthrift-0.20.0-h0e7cc3e_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.6.0-h46a8edc_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.0-hd9ff511_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libtorch-2.3.0-cuda120_h2b0da52_301.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libunistring-0.9.10-h7f98852_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libutf8proc-2.8.0-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libutf8proc-2.8.0-hf23e847_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.48.0-hd590300_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libva-2.22.0-hb711507_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.49.2-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libva-2.21.0-h4ab18f5_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libvorbis-1.3.7-h9c3ff4c_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/libvpx-1.14.1-hac33072_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libwebp-base-1.4.0-hd590300_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.16-hb9d3cd8_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.15-h0b41bf4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libxkbcommon-1.7.0-h2c5496b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxkbcommon-1.7.0-h662e7e4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libxkbfile-1.1.0-h166bdaf_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.12.7-he7c6b58_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.12.7-h4c95cb1_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libxslt-1.1.39-h76b75d6_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-h4ab18f5_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/llvm-openmp-18.1.8-hf5423f3_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzip-1.11.2-h6991a6a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-hb9d3cd8_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/llvm-openmp-19.1.6-h024ca30_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/loguru-0.7.2-py312h7900ff3_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/lz4-c-1.9.4-hcb278e6_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/lzo-2.10-hd590300_1001.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-3.0.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/markupsafe-2.1.5-py312h66e93f0_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-3.9.2-py312h7900ff3_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-base-3.9.2-py312h854627b_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/matplotlib-inline-0.1.7-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/mdit-py-plugins-0.4.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-khr-devel-cos7-x86_64-18.3.4-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libegl-cos7-x86_64-18.3.4-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libegl-devel-cos7-x86_64-18.3.4-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libgbm-cos7-x86_64-18.3.4-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libglapi-cos7-x86_64-18.3.4-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libglu-cos7-x86_64-9.0.0-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libglu-devel-cos7-x86_64-9.0.0-h9b0a68f_1105.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/mesalib-24.2.2-h4e3793c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/mistune-3.0.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-3.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/markupsafe-3.0.2-py312h178313f_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-3.9.4-py312h7900ff3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-base-3.9.4-py312hd3ec401_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/matplotlib-inline-0.1.7-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mdit-py-plugins-0.4.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-khr-devel-cos7-x86_64-18.3.4-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libegl-cos7-x86_64-18.3.4-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libegl-devel-cos7-x86_64-18.3.4-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libgbm-cos7-x86_64-18.3.4-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libglapi-cos7-x86_64-18.3.4-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libglu-cos7-x86_64-9.0.0-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libglu-devel-cos7-x86_64-9.0.0-ha675448_1106.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/mesalib-24.1.0-hfa94a56_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mistune-3.0.2-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/mkl-2023.2.0-h84fe81f_50496.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ml_dtypes-0.4.0-py312hf9745cd_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ml_dtypes-0.5.0-py312hf9745cd_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/mpc-1.3.1-h24ddda3_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/mpfr-4.2.1-h38ae2d0_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mpfr-4.2.1-h90cbb55_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/msgpack-numpy-0.4.8-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/msgpack-python-1.1.0-py312h68727a3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/multidict-6.1.0-py312h178313f_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/munkres-1.1.4-pyh9f0ad1d_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/mysql-common-9.0.1-h70512c7_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/mysql-libs-9.0.1-ha479ceb_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/natsort-8.4.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nbclient-0.10.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-7.16.4-hd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-core-7.16.4-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-pandoc-7.16.4-hd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nbformat-5.10.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/nccl-2.22.3.1-hbc370b7_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mysql-common-8.3.0-h70512c7_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mysql-libs-8.3.0-ha479ceb_5.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/natsort-8.4.0-pyh29332c3_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbclient-0.10.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-7.16.4-hd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-core-7.16.4-pyhff2d567_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-pandoc-7.16.4-hd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbformat-5.10.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/nccl-2.23.4.1-h2b5d15b_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-he02047a_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nest-asyncio-1.6.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nest-asyncio-1.6.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/nettle-3.9.1-h7ab15ed_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/networkx-3.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/networkx-3.4.2-pyh267e887_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.12.1-h297d8ca_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/nodejs-22.8.0-hf235a45_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/notebook-7.2.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/notebook-shim-0.2.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/nsight-compute-2024.3.1.2-hce307c1_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/nspr-4.35-h27087fc_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/nss-3.104-hd34e28f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/nlohmann_json-3.11.3-he02047a_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/nodejs-22.6.0-h6d9b948_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/notebook-7.3.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/notebook-shim-0.2.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/nsight-compute-2024.2.0.16-h54680a5_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/nspr-4.36-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/nss-3.107-hdf54f9c_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-1.26.4-py312heda63a1_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ocl-icd-2.3.2-hd590300_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/openexr-3.2.2-haf962dd_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ocl-icd-2.3.2-hb9d3cd8_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/octomap-1.10.0-h84d6215_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/open3d-0.18.0-py312he431d9b_6.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/opencl-headers-2024.10.24-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openexr-3.2.2-h04e0de5_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/openh264-2.4.1-h59595ed_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/openjpeg-2.5.2-h488ebb8_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.3.2-hb9d3cd8_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/opt-einsum-3.3.0-hd8ed1ab_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/opt_einsum-3.3.0-pyhc1e730c_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/optax-0.2.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openjpeg-2.5.3-h5fbd93e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.4.0-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/opt-einsum-3.4.0-hd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/opt_einsum-3.4.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/optax-0.2.3-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/orc-2.0.2-h669347b_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/overrides-7.7.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/p11-kit-0.24.1-hc5aa10d_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pandoc-3.3-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.2-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pandoc-3.6-ha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pandocfilters-1.5.0-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.44-hba22ea6_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.43-hcad00b1_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pdoc-14.4.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pickleshare-0.7.5-py_1003.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/pillow-10.3.0-py312h287a98d_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pixman-0.43.2-h59595ed_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pkgutil-resolve-name-1.3.10-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.2.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pickleshare-0.7.5-pyhd8ed1ab_1004.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pillow-10.3.0-py312hdcec9eb_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pixman-0.44.2-h29eaf8c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pkgutil-resolve-name-1.3.10-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.3.6-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/plotly-5.24.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/polars-0.20.31-py312hd26010a_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/prometheus_client-0.20.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/prompt-toolkit-3.0.47-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/prompt_toolkit-3.0.47-hd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-6.0.0-py312h9a8786e_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/psygnal-0.11.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-h36c2ea0_1001.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/ptyprocess-0.7.0-pyhd3deb0d_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/proj-9.3.1-h1d62c97_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/prometheus_client-0.21.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/prompt-toolkit-3.0.48-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/prompt_toolkit-3.0.48-hd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/propcache-0.2.1-py312h66e93f0_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-6.1.0-py312h66e93f0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/psygnal-0.11.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-hb9d3cd8_1002.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ptyprocess-0.7.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/pugixml-1.14-h59595ed_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pure_eval-0.2.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/py-opencv-4.10.0-qt6_py312h071dcc1_603.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pyarrow-17.0.0-py312h9cebb41_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pyarrow-core-17.0.0-py312h9cafe31_1_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.18.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.1.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pyright-1.1.379-py312h66e93f0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pyside6-6.7.2-py312hb5137db_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyha2e5f31_6.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.3.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.12.5-h2ad013b_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.20.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pure_eval-0.2.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/py-opencv-4.10.0-qt6_py312h071dcc1_601.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyarrow-17.0.0-py312h9cebb41_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyarrow-core-17.0.0-py312h01725c0_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pycocotools-2.0.8-py312hc0a28a1_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.18.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyright-1.1.390-py312h66e93f0_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyside6-6.7.2-py312h91f0f75_4.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyha55dd90_7.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.3.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.12.8-h9e4cc4f_1_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhff2d567_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.21.1-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python-json-logger-2.0.7-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/python-lzf-0.2.6-py312h41a817b_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-lzf-0.2.6-py312h318bf5b_4.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/python_abi-3.12-5_cp312.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/pytorch-2.3.0-cuda120_py312h26b3cf7_301.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pytz-2024.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytz-2024.2-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/pyyaml-6.0.2-py312h66e93f0_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pyzmq-26.2.0-py312hbf22597_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyzmq-26.2.0-py312hbf22597_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/qhull-2020.2-h434a139_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/qt6-main-6.7.2-hb12f9c5_5.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/qtconsole-base-5.6.0-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/qtpy-2.4.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/qt6-main-6.7.2-h402ef58_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/qtconsole-base-5.6.1-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/qtpy-2.4.2-pyhdecd6ff_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/re2-2023.09.01-h7f4b329_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8228510_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/referencing-0.35.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/referencing-0.35.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.3-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/rerun-sdk-0.17.0-py312hbe4c86d_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/rfc3339-validator-0.1.4-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/retrying-1.3.3-pyhd8ed1ab_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/rfc3339-validator-0.1.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/rfc3986-validator-0.1.1-pyh9f0ad1d_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/rpds-py-0.20.0-py312h12e396e_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ruff-0.6.4-py312hd18ad41_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/s2n-1.5.1-h3400bea_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/scikit-learn-1.5.1-py312h775a589_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.14.1-py312h7d485d2_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/send2trash-1.8.3-pyh0d859eb_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-73.0.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.16.0-pyh6c4a22f_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/sleef-3.6.1-h1b44611_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/snappy-1.2.1-ha2e4443_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sniffio-1.3.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/rpds-py-0.22.3-py312h12e396e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ruff-0.8.3-py312h2156523_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/s2n-1.5.5-h3931f03_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/scikit-learn-1.5.2-py312h7a48858_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.14.1-py312h62794b6_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/send2trash-1.8.3-pyh0d859eb_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-75.6.0-pyhff2d567_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/sleef-3.7-h1b44611_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/snappy-1.2.1-h8bd8927_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sniffio-1.3.1-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/soupsieve-2.5-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/stack_data-0.6.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/svt-av1-2.2.1-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.13.2-pypyh2585a3b_103.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.17-h4a8ded7_16.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/tbb-2021.13.0-h84d6215_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/termcolor-2.4.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/sqlite-3.47.2-h9eae976_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/stack_data-0.6.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/svt-av1-2.1.0-hac33072_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.13.3-pyh2585a3b_104.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.17-h4a8ded7_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tbb-2021.13.0-hceb3a55_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tbb-devel-2021.13.0-h1f99690_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tenacity-9.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/termcolor-2.5.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/terminado-0.18.1-pyh0d859eb_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/threadpoolctl-3.5.0-pyhc1e730c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tinycss2-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tinycss2-1.4.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tinyobjloader-1.0.7-h59595ed_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h4845f30_101.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/toolz-0.12.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.2.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toolz-1.0.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/torchvision-0.18.0-cuda120py312h85ee0b7_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/tornado-6.4.1-py312h66e93f0_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tqdm-4.66.5-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.14.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tornado-6.4.2-py312h66e93f0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tqdm-4.67.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.14.3-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/trimesh-4.2.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/types-python-dateutil-2.9.0.20240906-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/typing_utils-0.1.0-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h8827d51_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/uri-template-1.3.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.2.2-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/watchfiles-0.24.0-py312h12e396e_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/types-python-dateutil-2.9.0.20241206-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_utils-0.1.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024b-hc8b5060_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/unicodedata2-15.1.0-py312h66e93f0_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/uri-template-1.3.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.2.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/utfcpp-4.0.6-h005c6e1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/vtk-9.3.0-qt_py312h1234567_200.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/vtk-base-9.3.0-qt_py312h1234567_200.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/vtk-io-ffmpeg-9.3.0-qt_py312h1234567_200.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/watchfiles-1.0.3-py312h12e396e_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/wayland-1.23.1-h3e06ad9_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/wayland-protocols-1.37-hd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.2.13-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/webcolors-24.8.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/webencodings-0.5.1-pyhd8ed1ab_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/websocket-client-1.8.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/widgetsnbextension-4.0.13-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/wrapt-1.16.0-py312h66e93f0_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.2.13-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/webcolors-24.11.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/webencodings-0.5.1-pyhd8ed1ab_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/websocket-client-1.8.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/werkzeug-3.1.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/widgetsnbextension-4.0.13-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/wrapt-1.17.0-py312h66e93f0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wslink-2.2.1-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/x264-1!164.3095-h166bdaf_2.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/x265-3.5-h924138e_3.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-0.4.1-hb711507_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-cursor-0.1.4-h4ab18f5_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-image-0.4.0-hb711507_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-keysyms-0.4.1-hb711507_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-renderutil-0.3.10-hb711507_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-wm-0.4.2-hb711507_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-0.4.0-hd590300_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-cursor-0.1.4-hd590300_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-image-0.4.0-h8ee46fc_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-keysyms-0.4.0-h8ee46fc_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-renderutil-0.3.9-hd590300_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-wm-0.4.1-h8ee46fc_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/xkeyboard-config-2.42-h4ab18f5_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-compositeproto-0.4.2-h7f98852_1001.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-damageproto-1.2.1-h7f98852_1002.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-fixesproto-5.0-h7f98852_1002.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-glproto-1.4.17-h7f98852_1002.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-inputproto-2.3.2-h7f98852_1002.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-kbproto-1.0.7-h7f98852_1002.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libice-1.1.1-hd590300_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libsm-1.2.4-h7391055_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libx11-1.8.9-hb711507_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.11-hd590300_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-compositeproto-0.4.2-hb9d3cd8_1002.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-damageproto-1.2.1-hb9d3cd8_1003.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-fixesproto-5.0-hb9d3cd8_1003.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-glproto-1.4.17-hb9d3cd8_1003.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-inputproto-2.3.2-hb9d3cd8_1003.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-kbproto-1.0.7-hb9d3cd8_1003.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libice-1.1.2-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libsm-1.2.5-he73a12e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libx11-1.8.9-h8ee46fc_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.12-hb9d3cd8_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcomposite-0.4.6-h0b41bf4_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdamage-1.1.5-h7f98852_1.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.3-h7f98852_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.5-hb9d3cd8_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxext-1.3.4-h0b41bf4_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxfixes-5.0.3-h7f98852_1004.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxi-1.7.10-h4bc722e_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxinerama-1.1.5-h27087fc_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrandr-1.5.2-h7f98852_1.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrender-0.9.11-hd590300_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxt-1.3.0-hd590300_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxtst-1.2.5-h4bc722e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxxf86vm-1.1.5-h4bc722e_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-randrproto-1.5.0-h7f98852_1001.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-recordproto-1.14.2-h7f98852_1002.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-renderproto-0.11.1-h7f98852_1002.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-util-macros-1.19.3-h7f98852_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-xextproto-7.3.0-h0b41bf4_1003.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-xf86vidmodeproto-2.3.1-h7f98852_1002.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-xproto-7.0.31-h7f98852_1007.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-5.2.6-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-randrproto-1.5.0-hb9d3cd8_1002.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-recordproto-1.14.2-hb9d3cd8_1003.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-renderproto-0.11.1-hb9d3cd8_1003.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-util-macros-1.20.2-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-xextproto-7.3.0-hb9d3cd8_1004.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-xf86vidmodeproto-2.3.1-hb9d3cd8_1005.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-xproto-7.0.31-hb9d3cd8_1008.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-5.6.3-hbcc6ac9_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-gpl-tools-5.6.3-hbcc6ac9_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-tools-5.6.3-hb9d3cd8_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/yaml-0.2.5-h7f98852_2.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/zeromq-4.3.5-ha4adb4c_5.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.20.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/zlib-1.3.1-h4ab18f5_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/yarl-1.18.3-py312h66e93f0_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zeromq-4.3.5-h3b0a872_7.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.21.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zlib-1.3.1-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/zstandard-0.23.0-py312hef9b889_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.6-ha6fb4c9_0.conda - pypi: https://files.pythonhosted.org/packages/a5/45/30bb92d442636f570cb5651bc661f52b610e2eec3f891a5dc3a4c3667db0/aiofiles-24.1.0-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/64/43/7a1259741bd989723272ac7d381a43be932422abcff09a1d9f7ba212cb74/beartype-0.18.5-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/49/f5/f4bfff55de6ca82445584eead7fc22f29f3d2bd66a76b8cf4c8c4feb2f32/carvekit-4.1.2-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/00/2e/d53fa4befbf2cfa713304affc7ca780ce4fc1fd8710527771b58311a3229/click-8.1.7-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/96/43/dae06432d0c4b1dc9e9149ad37b4ca8384cf6eb7700cd9215b177b914f0a/cloudpickle-3.0.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/48/41/e1d85ca3cab0b674e277c8c4f678cf66a91cd2cecf93df94353a606fe0db/cloudpickle-3.1.0-py3-none-any.whl - pypi: https://us-west1-python.pkg.dev/probcomp-caliban/probcomp/datasync/datasync-0.0.2-py3-none-any.whl#sha256=ce28394757ba65fa1ff3a3010a1f67720f372c877f7d27bc23176a53e2cfa3a4 - - pypi: https://files.pythonhosted.org/packages/20/8d/778b7d51b981a96554f29136cd59ca7880bf58094338085bcf2a979a0e6a/Deprecated-1.2.14-py2.py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/1d/8f/c7f227eb42cfeaddce3eb0c96c60cbca37797fa7b34f8e1aeadf6c5c0983/Deprecated-1.2.15-py2.py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/c9/d4/8cbb857612ca69763ee4f4f97c7b91659df1d373d62237cb9c772e55ae97/dm_tree-0.1.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl - - pypi: https://files.pythonhosted.org/packages/08/0f/1d22866c1ff666766b2c207487bef3f06edae096df2f6b4176d5f7072a10/equinox-0.11.5-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/d0/80/17037f322c280efbc623e341358d38d0299c6ee899d619a879b3593aa6da/fastapi-0.114.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/3a/af/411e94c165229882eb2d0a329114826aa52c7c61ef3108d0d3d8ad7189ed/equinox-0.11.10-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/52/b3/7e4df40e585df024fac2f80d1a2d579c854ac37109675db2b0cc22c0bb9e/fastapi-0.115.6-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/a3/61/8001b38461d751cd1a0c3a6ae84346796a5758123f3ed97a1b121dfbf4f3/gast-0.6.0-py3-none-any.whl - - pypi: https://us-west1-python.pkg.dev/probcomp-caliban/probcomp/genjax/genjax-0.5.1-py3-none-any.whl#sha256=1ad4363ce44f64cc1e5d92f826f4c7c14e99370a8c86d39cbe6fa8c3b6a657ce - - pypi: https://files.pythonhosted.org/packages/56/ae/220537f80eb82ae43a299de31edb2a91a28b8c5fb8046e9ff853ec7763cd/jaxtyping-0.2.34-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/03/0a/4f6fed21aa246c6b49b561ca55facacc2a44b87d65b8b92362a8e99ba202/loguru-0.7.2-py3-none-any.whl + - pypi: https://us-west1-python.pkg.dev/probcomp-caliban/probcomp/genjax/genjax-0.6.1-py3-none-any.whl#sha256=7e6afa8ab867266a9fa66ccadab3823d2e93d41d19d671ced853407c8e16cf44 + - pypi: https://files.pythonhosted.org/packages/94/99/c83c6a97f4382caf1c9bfeeeca935d3eb1f479f711665aeadf4408048107/jaxtyping-0.2.36-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/33/55/af02708f230eb77084a299d7b08175cff006dea4f2721074b92cdb0296c0/ordered_set-4.1.0-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/40/10/79e52ef01dfeb1c1ca47a109a01a248754ebe990e159a844ece12914de83/pandas-2.2.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/38/f8/d8fddee9ed0d0c0f4a2132c1dfcf0e3e53265055da8df952a53e7eaf178c/pandas-2.2.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl - pypi: https://files.pythonhosted.org/packages/41/dc/d123e5815af021ba22f9321d6922b03b1c1351170f78c3ebb86c522f24aa/penzai-0.1.5-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/54/38/95bdb5dfcebad2c11c88f7aa2d635fe53a0b7405ef39a6850c8bced455d4/pydantic-2.9.0-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/ad/fc/6b4f95c64bbeadaa6f84cffb51f469f6fdd61215d97b4ec8d89d027e574b/pydantic_core-2.23.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/62/51/72c18c55cf2f46ff4f91ebcc8f75aa30f7305f3d726be3f4ebffb4ae972b/pydantic-2.10.3-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/8a/c6/8ae0831bf77f356bb73127ce5a95fe115b10f820ea480abbd72d3cc7ccf3/pydantic_core-2.27.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl - pypi: https://files.pythonhosted.org/packages/c3/7e/e2b71b9221ccb8503dce9673e3cb36edcdc314ec374f9e69e6d38ed1abde/pykitti-0.3.1-py2.py3-none-any.whl - - pypi: git+https://github.com/ydkhatri/pyliblzfse.git@a8c00b6bf866410e658a82f88caa04b2cf0a5fea - pypi: https://files.pythonhosted.org/packages/68/6b/a4cc6a28ac80d3bccef0bf869634ee21731e1a85e5ce508c41e1ba0c8437/pyransac3d-0.6.0-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/3d/47/444768600d9e0ebc82f8e347775d24aef8f6348cf00e9fa0e81910814e6d/python_multipart-0.0.9-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/69/13/fa916b69d7c21f80a9c5bde0445cbbbdb9542a9d8df73ea3d588aae55c26/starlette-0.38.4-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/c0/00/cdb2afde2d7700d26b2df90bc40d72d18585e4f9a5d63d49b210a8d6bad0/python_fcl-0.7.0.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/45/58/38b5afbc1a800eeea951b9285d3912613f2603bdf897a4ab0f4bd7f405fc/python_multipart-0.0.20-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/96/00/2b325970b3060c7cecebab6d295afe763365822b1306a12eeab198f74323/starlette-0.41.3-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/1e/90/4e8c686f2e691f48e40e16a539c61a6e9880743733d8c4dc3f275d12268e/tensorflow_probability-0.23.0-py2.py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/9a/bb/d43e5c75054e53efce310e79d63df0ac3f25e34c926be5dffb7d283fb2a8/typeguard-2.13.3-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/05/d9/6eebe19d46bd05360c9a9aae822e67a80f9242aabbfc58b641b957546607/typing-3.7.4.3.tar.gz - - pypi: https://files.pythonhosted.org/packages/65/58/f9c9e6be752e9fcb8b6a0ee9fb87e6e7a1f6bcab2cdc73f02bb7ba91ada0/tzdata-2024.1-py2.py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/f5/8e/cdc7d6263db313030e4c257dd5ba3909ebc4e4fb53ad62d5f09b1a2f5458/uvicorn-0.30.6-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/f2/5d/865e17349564eb1772688d8afc5e3081a5964c640d64d1d2880ebaed002d/typing-3.10.0.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/a6/ab/7e5f53c3b9d14972843a647d8d7a853969a58aecc7559cb3267302c94774/tzdata-2024.2-py2.py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/61/14/33a3a1352cfa71812a3a21e8c9bfb83f60b0011f5e36f2b1399d51928209/uvicorn-0.34.0-py3-none-any.whl - pypi: . osx-arm64: - - conda: https://conda.anaconda.org/conda-forge/noarch/absl-py-2.1.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/anyio-4.4.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/anywidget-0.9.13-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/absl-py-2.1.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/anyio-4.7.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/anywidget-0.9.13-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aom-3.9.1-h7bae524_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/appnope-0.1.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/argon2-cffi-23.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/appnope-0.1.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/argon2-cffi-23.1.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/argon2-cffi-bindings-21.2.0-py312h024a12e_5.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/arrow-1.3.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/asttokens-2.4.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/astunparse-1.6.3-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/async-lru-2.0.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-24.2.0-pyh71513ae_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-auth-0.7.27-h1e647a1_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-cal-0.7.4-h41e72e7_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-common-0.9.27-h99b78c6_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-compression-0.2.19-h41e72e7_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-event-stream-0.4.3-h79ff00d_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-http-0.8.8-h69517e7_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-io-0.14.18-h20e6805_7.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-mqtt-0.10.4-h3e8bf47_18.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-s3-0.6.5-h5e39592_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-sdkutils-0.1.19-h85401af_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-checksums-0.1.18-h85401af_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-crt-cpp-0.28.2-h6f2a9b6_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-sdk-cpp-1.11.379-h8d911dc_8.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/arrow-1.3.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/asttokens-3.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/astunparse-1.6.3-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/async-lru-2.0.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-24.3.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-auth-0.7.31-h14f56dd_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-cal-0.7.4-hd45b2be_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-common-0.9.29-h7ab814d_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-compression-0.2.19-hd45b2be_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-event-stream-0.4.3-hdf5079d_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-http-0.8.10-h4588aaf_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-io-0.14.19-h5ad5fc2_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-mqtt-0.10.7-hbe077eb_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-s3-0.6.7-h86d2b7d_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-sdkutils-0.1.19-hd45b2be_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-checksums-0.1.20-hd45b2be_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-crt-cpp-0.28.3-h4f9f7e0_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-sdk-cpp-1.11.407-h880863c_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-core-cpp-1.13.0-hd01fc5c_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-identity-cpp-1.8.0-h13ea094_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-storage-blobs-cpp-12.12.0-hfde595f_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-storage-common-cpp-12.7.0-hcf3b6fd_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-storage-files-datalake-cpp-12.11.0-h082e32e_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.14.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/beautifulsoup4-4.12.3-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/bleach-6.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.16.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/beautifulsoup4-4.12.3-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/bleach-6.2.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-1.1.0-hd74edd7_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-bin-1.1.0-hd74edd7_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-python-1.1.0-py312hde4cb15_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h99b78c6_7.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.33.1-hd74edd7_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ca-certificates-2024.8.30-hf0a4a13_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.4-h5505292_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ca-certificates-2024.12.14-hf0a4a13_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cached-property-1.5.2-hd8ed1ab_1.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/cached_property-1.5.2-pyha770c72_1.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cairo-1.18.0-hb4a6bf7_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2024.8.30-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cairo-1.18.2-h6a3b0d2_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2024.12.14-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cffi-1.17.1-py312h0fad829_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.3.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/chex-0.1.86-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/comm-0.2.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/contourpy-1.3.0-py312h6142ec9_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/chex-0.1.88-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/comm-0.2.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/contourpy-1.3.1-py312hb23fbb9_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.12.8-py312hd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cython-3.0.11-py312hde4cb15_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/dav1d-1.2.1-hb547adb_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/debugpy-1.8.5-py312hde4cb15_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/decorator-5.1.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/debugpy-1.8.11-py312hd8f9ff3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/decorator-5.1.1-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/defusedxml-0.7.1-pyhd8ed1ab_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/distinctipy-1.3.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/entrypoints-0.4-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/executing-2.1.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/expat-2.6.3-hf9b8971_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ffmpeg-6.1.2-gpl_h3ef3969_102.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.15.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/entrypoints-0.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/etils-1.10.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/executing-2.1.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/fcl-0.7.0-he078184_6.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ffmpeg-6.1.2-gpl_hbafc610_106.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.16.1-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/fire-0.6.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/flann-1.9.2-h4918f9b_3.conda - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/fontconfig-2.14.2-h82840c6_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/fontconfig-2.15.0-h1383a14_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-forge-1-0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/fonttools-4.53.1-py312h024a12e_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/fqdn-1.5.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/fonttools-4.55.3-py312h998013c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/fqdn-1.5.1-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/freetype-2.12.1-hadb7bae_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/fribidi-1.0.10-h27ca646_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/fsspec-2024.9.0-pyhff2d567_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gettext-0.22.5-h8414b35_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gettext-tools-0.22.5-h8414b35_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gflags-2.2.2-hc88da5d_1004.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/fsspec-2024.10.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gflags-2.2.2-hf9b8971_1005.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/glog-0.7.1-heb240a5_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmp-6.3.0-h7bae524_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmpy2-2.1.5-py312h87fada9_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gnutls-3.8.7-h9df781c_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmpy2-2.1.5-py312h524cf62_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/graphite2-1.3.13-hebf3989_1003.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/h11-0.14.0-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/h2-4.1.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/h11-0.14.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/h2-4.1.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/h5py-3.11.0-nompi_py312h3cd0824_103.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/harfbuzz-9.0.0-h997cde5_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/hdf5-1.14.3-nompi_hec07895_105.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/hpack-4.0.0-pyh9f0ad1d_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/httpcore-1.0.5-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/httpx-0.27.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/hyperframe-6.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/hdf5-1.14.3-nompi_ha698983_108.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hpack-4.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/httpcore-1.0.7-pyh29332c3_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/httpx-0.28.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hyperframe-6.0.1-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-75.1-hfee45f7_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.8-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/imageio-2.35.1-pyh12aca89_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/imath-3.1.11-h1059232_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.4.0-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_metadata-8.4.0-hd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.4.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.10-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/imageio-2.36.1-pyh12aca89_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/imath-3.1.12-h025cafa_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.5.0-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.4.5-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/ipykernel-6.29.5-pyh57ce528_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipympl-0.9.5-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/ipython-8.26.0-pyh707e725_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ipywidgets-8.1.5-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/isoduration-20.11.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/ipython_genutils-0.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipywidgets-8.1.5-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/isoduration-20.11.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/jasper-4.2.4-h6c4e4ef_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jax-0.4.31-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jax-0.4.31-pyhd8ed1ab_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/jaxlib-0.4.31-cpu_py312h47007b3_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jedi-0.19.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/joblib-1.4.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/json5-0.9.25-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jedi-0.19.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/joblib-1.4.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/json5-0.10.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/jsonpointer-3.0.0-py312h81bd7bf_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-4.23.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-specifications-2023.12.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-with-format-nongpl-4.23.0-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-4.23.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-specifications-2024.10.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-with-format-nongpl-4.23.0-hd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-1.0.0-pyhd8ed1ab_10.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-lsp-2.2.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-lsp-2.2.5-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-ui-poll-0.2.2-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.6.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_console-6.6.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/jupyter_core-5.7.2-py312h81bd7bf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_events-0.10.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_server-2.14.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_server_terminals-0.5.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab-4.2.5-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_pygments-0.3.0-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_server-2.27.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_widgets-3.0.13-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/jupytext-1.16.4-pyh80e38bb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.6.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_console-6.6.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_core-5.7.2-pyh31011fe_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_events-0.11.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_server-2.14.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_server_terminals-0.5.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab-4.3.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_pygments-0.3.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_server-2.27.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_widgets-3.0.13-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupytext-1.16.5-pyhbbac1ac_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/kiwisolver-1.4.7-py312h6142ec9_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.21.3-h237132a_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lame-3.100-h1a8c8d9_1003.tar.bz2 @@ -1917,223 +2068,225 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lerc-4.0.0-h9a09cb3_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libabseil-20240116.2-cxx17_h00cdb27_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libaec-1.1.3-hebf3989_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-17.0.0-h20538ec_13_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-acero-17.0.0-hf9b8971_13_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-dataset-17.0.0-hf9b8971_13_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-substrait-17.0.0-hbf8b706_13_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-17.0.0-hc6a7651_16_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-acero-17.0.0-hf9b8971_16_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-dataset-17.0.0-hf9b8971_16_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-substrait-17.0.0-hbf8b706_16_cpu.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libasprintf-0.22.5-h8414b35_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libasprintf-devel-0.22.5-h8414b35_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libass-0.17.3-hf20b609_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-23_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-26_osxarm64_openblas.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlicommon-1.1.0-hd74edd7_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlidec-1.1.0-hd74edd7_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlienc-1.1.0-hd74edd7_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-23_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-26_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libccd-double-2.1-h9a09cb3_2.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcrc32c-1.1.2-hbdafb3b_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.9.1-hfd8ffcc_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-18.1.8-h3ed4263_7.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libdeflate-1.21-h99b78c6_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.11.1-h73640d1_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-19.1.6-ha82da77_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libdeflate-1.23-hec38601_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20191231-hc8eb9b7_2.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libevent-2.1.12-h2757513_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.6.3-hf9b8971_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.6.4-h286801f_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.4.2-h3422bc3_5.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgettextpo-0.22.5-h8414b35_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgettextpo-devel-0.22.5-h8414b35_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-5.0.0-13_2_0_hd922786_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-13.2.0-hf226fd6_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.80.3-h59d46d9_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgoogle-cloud-2.28.0-hfe08963_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgoogle-cloud-storage-2.28.0-h1466eeb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.82.2-h07bd6cf_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgoogle-cloud-2.29.0-hfa33a2f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgoogle-cloud-storage-2.29.0-h90fd6fa_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgrpc-1.62.2-h9c18a4f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libhwloc-2.11.1-default_h7685b71_1000.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libhwloc-2.11.2-default_hbce5d74_1001.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.17-h0d3ecfb_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libidn2-2.3.7-h93a5062_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.22.5-h8414b35_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-devel-0.22.5-h8414b35_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libjpeg-turbo-3.0.0-hb547adb_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-23_osxarm64_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapacke-3.9.0-23_osxarm64_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.58.0-ha4dd798_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.27-openmp_h517c56d_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopencv-4.10.0-headless_py312h7bc6ef4_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-2024.3.0-h5c9529b_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-arm-cpu-plugin-2024.3.0-h5c9529b_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-auto-batch-plugin-2024.3.0-hcd65546_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-auto-plugin-2024.3.0-hcd65546_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-hetero-plugin-2024.3.0-h88cb26a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-ir-frontend-2024.3.0-h88cb26a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-onnx-frontend-2024.3.0-h32b5460_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-paddle-frontend-2024.3.0-h32b5460_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-pytorch-frontend-2024.3.0-h00cdb27_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-tensorflow-frontend-2024.3.0-h2741c3b_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-tensorflow-lite-frontend-2024.3.0-h00cdb27_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-26_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapacke-3.9.0-26_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.6.3-h39f12f2_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-devel-5.6.3-h39f12f2_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.64.0-h6d7220d_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.28-openmp_hf332438_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopencv-4.10.0-headless_py312haa779ad_6.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-2024.4.0-h49f535f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-arm-cpu-plugin-2024.4.0-h49f535f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-auto-batch-plugin-2024.4.0-h8a2fcec_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-auto-plugin-2024.4.0-h8a2fcec_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-hetero-plugin-2024.4.0-h868cbb4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-ir-frontend-2024.4.0-h868cbb4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-onnx-frontend-2024.4.0-hf4ed89a_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-paddle-frontend-2024.4.0-hf4ed89a_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-pytorch-frontend-2024.4.0-hf9b8971_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-tensorflow-frontend-2024.4.0-h94307f2_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-tensorflow-lite-frontend-2024.4.0-hf9b8971_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopus-1.3.1-h27ca646_1.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libparquet-17.0.0-hf0ba9ef_13_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpng-1.6.43-h091b4b1_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libprotobuf-4.25.3-hbfab5d5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libparquet-17.0.0-hf0ba9ef_16_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpng-1.6.44-hc14010f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libprotobuf-4.25.3-hc39d83c_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libre2-11-2023.09.01-h7b2c953_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.20-h99b78c6_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.46.1-hc14010f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.0-h7a5bd25_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtasn1-4.19.0-h1a8c8d9_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.47.2-h3f77e49_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.1-h9cc3647_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libthrift-0.20.0-h64651cc_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtiff-4.6.0-hf8409c0_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtiff-4.7.0-h551f018_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtorch-2.3.1-cpu_generic_h95df8ed_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libunistring-0.9.10-h3422bc3_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libutf8proc-2.8.0-h1a8c8d9_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.48.0-h93a5062_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libutf8proc-2.8.0-hc098a78_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.49.2-h7ab814d_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libvpx-1.14.1-h7bae524_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libwebp-base-1.4.0-h93a5062_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxcb-1.16-hc9fafa5_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.12.7-h01dff8b_4.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-hfb2fe0b_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-18.1.8-hde57baf_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxcb-1.17.0-hdb1d25a_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.13.5-h178c5d8_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-h8359307_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-19.1.6-hdb05f8b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lz4-c-1.9.4-hb7217d7_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-3.0.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/markupsafe-2.1.5-py312h024a12e_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-3.9.2-py312h1f38498_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-base-3.9.2-py312h32d6e5a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/matplotlib-inline-0.1.7-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/mdit-py-plugins-0.4.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/mistune-3.0.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ml_dtypes-0.4.0-py312hcd31e36_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-3.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/markupsafe-3.0.2-py312h998013c_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-3.9.4-py312h1f38498_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-base-3.9.4-py312hdbc7e53_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/matplotlib-inline-0.1.7-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mdit-py-plugins-0.4.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mistune-3.0.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ml_dtypes-0.5.0-py312hcd31e36_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mpc-1.3.1-h8f1351a_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mpfr-4.2.1-h1cfca0a_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mpfr-4.2.1-hb693164_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/msgpack-numpy-0.4.8-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/msgpack-python-1.1.0-py312h6142ec9_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/munkres-1.1.4-pyh9f0ad1d_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/natsort-8.4.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nbclient-0.10.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-7.16.4-hd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-core-7.16.4-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-pandoc-7.16.4-hd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nbformat-5.10.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/natsort-8.4.0-pyh29332c3_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbclient-0.10.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-7.16.4-hd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-core-7.16.4-pyhff2d567_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-pandoc-7.16.4-hd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbformat-5.10.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-h7bae524_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nest-asyncio-1.6.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/nettle-3.9.1-h40ed0f5_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/networkx-3.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nest-asyncio-1.6.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/networkx-3.4.2-pyh267e887_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.12.1-h420ef59_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/nodejs-22.8.0-h08fde81_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/nodejs-22.12.0-h02a13b7_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/nomkl-1.0-h5ca1d4c_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/notebook-7.2.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/notebook-shim-0.2.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/notebook-7.3.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/notebook-shim-0.2.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-1.26.4-py312h8442bc7_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openexr-3.2.2-h2c51e1d_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/octomap-1.10.0-h7b3277c_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openexr-3.2.2-hab01212_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openh264-2.4.1-hebf3989_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openjpeg-2.5.2-h9f1df11_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.3.2-h8359307_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/opt-einsum-3.3.0-hd8ed1ab_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/opt_einsum-3.3.0-pyhc1e730c_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/optax-0.2.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openjpeg-2.5.3-h8a3d83b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.4.0-h39f12f2_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/opt-einsum-3.4.0-hd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/opt_einsum-3.4.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/optax-0.2.3-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/orc-2.0.2-h75dedd0_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/overrides-7.7.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/p11-kit-0.24.1-h29577a5_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pandoc-3.3-hce30654_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.2-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pandoc-3.6-hce30654_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pandocfilters-1.5.0-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.44-h297a79d_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pdoc-14.4.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pickleshare-0.7.5-py_1003.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pickleshare-0.7.5-pyhd8ed1ab_1004.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pillow-10.3.0-py312h39b1d8d_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pixman-0.43.4-hebf3989_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pkgutil-resolve-name-1.3.10-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.2.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pixman-0.44.2-h2f9eb0b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pkgutil-resolve-name-1.3.10-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.3.6-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/polars-0.20.31-py312h812d8f0_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/prometheus_client-0.20.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/prompt-toolkit-3.0.47-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/prompt_toolkit-3.0.47-hd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-6.0.0-py312h7e5086c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/psygnal-0.11.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pthread-stubs-0.4-h27ca646_1001.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/ptyprocess-0.7.0-pyhd3deb0d_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/prometheus_client-0.21.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/prompt-toolkit-3.0.48-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/prompt_toolkit-3.0.48-hd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-6.1.0-py312h0bf5046_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/psygnal-0.11.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pthread-stubs-0.4-hd74edd7_1002.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ptyprocess-0.7.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pugixml-1.14-h13dd4ca_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pure_eval-0.2.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/py-opencv-4.10.0-headless_py312hd31a7ba_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyarrow-17.0.0-py312ha814d7c_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyarrow-core-17.0.0-py312he20ac61_1_cpu.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.18.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyobjc-core-10.3.1-py312hbb55c70_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyobjc-framework-cocoa-10.3.1-py312hbb55c70_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.1.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyright-1.1.379-py312h024a12e_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyha2e5f31_6.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.3.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.12.5-h30c5eda_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.20.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pure_eval-0.2.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/py-opencv-4.10.0-headless_py312hd31a7ba_6.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyarrow-17.0.0-py312ha814d7c_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyarrow-core-17.0.0-py312hc40f475_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pycocotools-2.0.8-py312h755e627_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.18.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyobjc-core-10.3.2-py312hb9d441b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyobjc-framework-cocoa-10.3.2-py312hb9d441b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyright-1.1.390-py312hea69d52_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyha55dd90_7.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.3.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.12.8-hc22306f_1_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhff2d567_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.21.1-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python-json-logger-2.0.7-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python-lzf-0.2.6-pyh568cf5c_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python_abi-3.12-5_cp312.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pytorch-2.3.1-cpu_generic_py312h2aa0b4f_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pytz-2024.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytz-2024.2-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyyaml-6.0.2-py312h024a12e_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyzmq-26.2.0-py312hc6335d2_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyzmq-26.2.0-py312hf8a1cbd_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/qhull-2020.2-h420ef59_5.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/qtconsole-base-5.6.0-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/qtpy-2.4.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/qtconsole-base-5.6.1-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/qtpy-2.4.2-pyhdecd6ff_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/re2-2023.09.01-h4cba328_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.2-h92ec313_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/referencing-0.35.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/referencing-0.35.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.3-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rerun-sdk-0.17.0-py312h5c2e7bc_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/rfc3339-validator-0.1.4-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/rfc3339-validator-0.1.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/rfc3986-validator-0.1.1-pyh9f0ad1d_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rpds-py-0.20.0-py312he431725_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ruff-0.6.4-py312h42f095d_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/scikit-learn-1.5.1-py312h1b546db_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rpds-py-0.22.3-py312hcd83bfe_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ruff-0.8.3-py312h5d18b81_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/scikit-learn-1.5.2-py312h387f99c_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/scipy-1.14.0-py312h14ffa8f_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/send2trash-1.8.3-pyh31c8845_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-73.0.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.16.0-pyh6c4a22f_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/sleef-3.6.1-h7783ee8_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/snappy-1.2.1-hd02b534_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sniffio-1.3.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/send2trash-1.8.3-pyh31c8845_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-75.6.0-pyhff2d567_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/sleef-3.7-h8391f65_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/snappy-1.2.1-h98b9ce2_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sniffio-1.3.1-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/soupsieve-2.5-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/stack_data-0.6.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/svt-av1-2.2.1-ha39b806_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.13.2-pypyh2585a3b_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tbb-2021.13.0-h7b3277c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/termcolor-2.4.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/stack_data-0.6.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/svt-av1-2.3.0-hf24288c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.13.3-pyh2585a3b_104.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tbb-2022.0.0-h0cbf7ec_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/termcolor-2.5.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/terminado-0.18.1-pyh31c8845_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/threadpoolctl-3.5.0-pyhc1e730c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tinycss2-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tinycss2-1.4.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h5083fa2_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/toolz-0.12.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.2.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toolz-1.0.0-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/torchvision-0.18.0-cpu_py312ha63f1fc_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tornado-6.4.1-py312h024a12e_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tqdm-4.66.5-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.14.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tornado-6.4.2-py312hea69d52_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tqdm-4.67.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.14.3-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/trimesh-4.2.4-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/types-python-dateutil-2.9.0.20240906-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/typing_utils-0.1.0-pyhd8ed1ab_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h8827d51_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/uri-template-1.3.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.2.2-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/watchfiles-0.24.0-py312he431725_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.2.13-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/webcolors-24.8.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/webencodings-0.5.1-pyhd8ed1ab_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/websocket-client-1.8.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/widgetsnbextension-4.0.13-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/wrapt-1.16.0-py312h024a12e_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/types-python-dateutil-2.9.0.20241206-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_utils-0.1.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024b-hc8b5060_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/unicodedata2-15.1.0-py312h0bf5046_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/uri-template-1.3.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.2.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/watchfiles-1.0.3-py312hcd83bfe_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.2.13-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/webcolors-24.11.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/webencodings-0.5.1-pyhd8ed1ab_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/websocket-client-1.8.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/widgetsnbextension-4.0.13-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/wrapt-1.17.0-py312hea69d52_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/x264-1!164.3095-h57fd34a_2.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/x265-3.5-hbc6ce65_3.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxau-1.0.11-hb547adb_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxdmcp-1.1.3-h27ca646_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xz-5.2.6-h57fd34a_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxau-1.0.12-h5505292_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxdmcp-1.1.5-hd74edd7_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xz-5.6.3-h9a6d368_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xz-gpl-tools-5.6.3-h9a6d368_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xz-tools-5.6.3-h39f12f2_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/yaml-0.2.5-h3422bc3_2.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zeromq-4.3.5-h64debc3_5.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.20.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zlib-1.3.1-hfb2fe0b_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zeromq-4.3.5-hc1bb282_7.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.21.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zlib-1.3.1-h8359307_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstandard-0.23.0-py312h15fbf35_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.6-hb46c0d2_0.conda - pypi: https://files.pythonhosted.org/packages/a5/45/30bb92d442636f570cb5651bc661f52b610e2eec3f891a5dc3a4c3667db0/aiofiles-24.1.0-py3-none-any.whl @@ -2141,52 +2294,41 @@ environments: - pypi: https://files.pythonhosted.org/packages/64/43/7a1259741bd989723272ac7d381a43be932422abcff09a1d9f7ba212cb74/beartype-0.18.5-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/49/f5/f4bfff55de6ca82445584eead7fc22f29f3d2bd66a76b8cf4c8c4feb2f32/carvekit-4.1.2-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/00/2e/d53fa4befbf2cfa713304affc7ca780ce4fc1fd8710527771b58311a3229/click-8.1.7-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/96/43/dae06432d0c4b1dc9e9149ad37b4ca8384cf6eb7700cd9215b177b914f0a/cloudpickle-3.0.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/48/41/e1d85ca3cab0b674e277c8c4f678cf66a91cd2cecf93df94353a606fe0db/cloudpickle-3.1.0-py3-none-any.whl - pypi: https://us-west1-python.pkg.dev/probcomp-caliban/probcomp/datasync/datasync-0.0.2-py3-none-any.whl#sha256=ce28394757ba65fa1ff3a3010a1f67720f372c877f7d27bc23176a53e2cfa3a4 - - pypi: https://files.pythonhosted.org/packages/20/8d/778b7d51b981a96554f29136cd59ca7880bf58094338085bcf2a979a0e6a/Deprecated-1.2.14-py2.py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/1d/8f/c7f227eb42cfeaddce3eb0c96c60cbca37797fa7b34f8e1aeadf6c5c0983/Deprecated-1.2.15-py2.py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/10/10/5f9eed00b1186921e447960443f03cda6374cba8cd5cf7aff2b42ecb8a0e/dm_tree-0.1.8-cp312-cp312-macosx_11_0_arm64.whl - - pypi: https://files.pythonhosted.org/packages/08/0f/1d22866c1ff666766b2c207487bef3f06edae096df2f6b4176d5f7072a10/equinox-0.11.5-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/d0/80/17037f322c280efbc623e341358d38d0299c6ee899d619a879b3593aa6da/fastapi-0.114.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/3a/af/411e94c165229882eb2d0a329114826aa52c7c61ef3108d0d3d8ad7189ed/equinox-0.11.10-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/52/b3/7e4df40e585df024fac2f80d1a2d579c854ac37109675db2b0cc22c0bb9e/fastapi-0.115.6-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/a3/61/8001b38461d751cd1a0c3a6ae84346796a5758123f3ed97a1b121dfbf4f3/gast-0.6.0-py3-none-any.whl - - pypi: https://us-west1-python.pkg.dev/probcomp-caliban/probcomp/genjax/genjax-0.5.1-py3-none-any.whl#sha256=1ad4363ce44f64cc1e5d92f826f4c7c14e99370a8c86d39cbe6fa8c3b6a657ce - - pypi: https://files.pythonhosted.org/packages/56/ae/220537f80eb82ae43a299de31edb2a91a28b8c5fb8046e9ff853ec7763cd/jaxtyping-0.2.34-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/03/0a/4f6fed21aa246c6b49b561ca55facacc2a44b87d65b8b92362a8e99ba202/loguru-0.7.2-py3-none-any.whl + - pypi: https://us-west1-python.pkg.dev/probcomp-caliban/probcomp/genjax/genjax-0.6.1-py3-none-any.whl#sha256=7e6afa8ab867266a9fa66ccadab3823d2e93d41d19d671ced853407c8e16cf44 + - pypi: https://files.pythonhosted.org/packages/94/99/c83c6a97f4382caf1c9bfeeeca935d3eb1f479f711665aeadf4408048107/jaxtyping-0.2.36-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/33/55/af02708f230eb77084a299d7b08175cff006dea4f2721074b92cdb0296c0/ordered_set-4.1.0-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/db/7c/9a60add21b96140e22465d9adf09832feade45235cd22f4cb1668a25e443/pandas-2.2.2-cp312-cp312-macosx_11_0_arm64.whl + - pypi: https://files.pythonhosted.org/packages/e1/0c/ad295fd74bfac85358fd579e271cded3ac969de81f62dd0142c426b9da91/pandas-2.2.3-cp312-cp312-macosx_11_0_arm64.whl - pypi: https://files.pythonhosted.org/packages/41/dc/d123e5815af021ba22f9321d6922b03b1c1351170f78c3ebb86c522f24aa/penzai-0.1.5-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/54/38/95bdb5dfcebad2c11c88f7aa2d635fe53a0b7405ef39a6850c8bced455d4/pydantic-2.9.0-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/9e/e3/5c29d8fa6dfabd7809fe623fd17959e1b672410681a8c3811eefa42b8051/pydantic_core-2.23.2-cp312-cp312-macosx_11_0_arm64.whl + - pypi: https://files.pythonhosted.org/packages/62/51/72c18c55cf2f46ff4f91ebcc8f75aa30f7305f3d726be3f4ebffb4ae972b/pydantic-2.10.3-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/7b/9e/f8063952e4a7d0127f5d1181addef9377505dcce3be224263b25c4f0bfd9/pydantic_core-2.27.1-cp312-cp312-macosx_11_0_arm64.whl - pypi: https://files.pythonhosted.org/packages/c3/7e/e2b71b9221ccb8503dce9673e3cb36edcdc314ec374f9e69e6d38ed1abde/pykitti-0.3.1-py2.py3-none-any.whl - - pypi: git+https://github.com/ydkhatri/pyliblzfse.git@a8c00b6bf866410e658a82f88caa04b2cf0a5fea - pypi: https://files.pythonhosted.org/packages/68/6b/a4cc6a28ac80d3bccef0bf869634ee21731e1a85e5ce508c41e1ba0c8437/pyransac3d-0.6.0-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/3d/47/444768600d9e0ebc82f8e347775d24aef8f6348cf00e9fa0e81910814e6d/python_multipart-0.0.9-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/69/13/fa916b69d7c21f80a9c5bde0445cbbbdb9542a9d8df73ea3d588aae55c26/starlette-0.38.4-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/08/be/4781f7da7dde661d32925c0a129d268e03e6bbe00aaa86e48af59c70da61/python_fcl-0.7.0.6-cp312-cp312-macosx_11_0_arm64.whl + - pypi: https://files.pythonhosted.org/packages/45/58/38b5afbc1a800eeea951b9285d3912613f2603bdf897a4ab0f4bd7f405fc/python_multipart-0.0.20-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/96/00/2b325970b3060c7cecebab6d295afe763365822b1306a12eeab198f74323/starlette-0.41.3-py3-none-any.whl - pypi: https://files.pythonhosted.org/packages/1e/90/4e8c686f2e691f48e40e16a539c61a6e9880743733d8c4dc3f275d12268e/tensorflow_probability-0.23.0-py2.py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/9a/bb/d43e5c75054e53efce310e79d63df0ac3f25e34c926be5dffb7d283fb2a8/typeguard-2.13.3-py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/05/d9/6eebe19d46bd05360c9a9aae822e67a80f9242aabbfc58b641b957546607/typing-3.7.4.3.tar.gz - - pypi: https://files.pythonhosted.org/packages/65/58/f9c9e6be752e9fcb8b6a0ee9fb87e6e7a1f6bcab2cdc73f02bb7ba91ada0/tzdata-2024.1-py2.py3-none-any.whl - - pypi: https://files.pythonhosted.org/packages/f5/8e/cdc7d6263db313030e4c257dd5ba3909ebc4e4fb53ad62d5f09b1a2f5458/uvicorn-0.30.6-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/f2/5d/865e17349564eb1772688d8afc5e3081a5964c640d64d1d2880ebaed002d/typing-3.10.0.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/a6/ab/7e5f53c3b9d14972843a647d8d7a853969a58aecc7559cb3267302c94774/tzdata-2024.2-py2.py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/61/14/33a3a1352cfa71812a3a21e8c9bfb83f60b0011f5e36f2b1399d51928209/uvicorn-0.34.0-py3-none-any.whl - pypi: . packages: -- kind: conda - name: _libgcc_mutex - version: '0.1' - build: conda_forge - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 +- conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 sha256: fe51de6107f9edc7aa4f786a70f4a883943bc9d39b3bb7307c04c41410990726 md5: d7c89558ba9fa0495403155b64376d81 license: None purls: [] size: 2562 timestamp: 1578324546067 -- kind: conda - name: _openmp_mutex - version: '4.5' - build: 2_gnu +- conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 build_number: 16 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 sha256: fbe2c5e56a653bebb982eda4876a9178aedfc2b545f25d0ce9c4c0b508253d22 md5: 73aaf86a425cc6e73fcf236a5a46396d depends: @@ -2199,13 +2341,8 @@ packages: purls: [] size: 23621 timestamp: 1650670423406 -- kind: conda - name: _openmp_mutex - version: '4.5' - build: 2_kmp_llvm +- conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_kmp_llvm.tar.bz2 build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_kmp_llvm.tar.bz2 sha256: 84a66275da3a66e3f3e70e9d8f10496d807d01a9e4ec16cd2274cc5e28c478fc md5: 562b26ba2e19059551a811e72ab7f793 depends: @@ -2216,134 +2353,118 @@ packages: purls: [] size: 5744 timestamp: 1650742457817 -- kind: conda - name: _sysroot_linux-64_curr_repodata_hack - version: '3' - build: h69a702a_16 - build_number: 16 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/_sysroot_linux-64_curr_repodata_hack-3-h69a702a_16.conda - sha256: 6ac30acdbfd3136ee7a1de28af4355165291627e905715611726e674499b0786 - md5: 1c005af0c6ff22814b7c52ee448d4bea - license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later AND MPL-2.0 - license_family: GPL - purls: [] - size: 20798 - timestamp: 1720621358501 -- kind: conda - name: absl-py - version: 2.1.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/absl-py-2.1.0-pyhd8ed1ab_0.conda - sha256: 6c84575fe0c3a860c7b6a52cb36dc548c838503c8da0f950a63a64c29b443937 - md5: 035d1d58677c13ec93122d9eb6b8803b +- conda: https://conda.anaconda.org/conda-forge/noarch/absl-py-2.1.0-pyhd8ed1ab_1.conda + sha256: 4625b42d9e91067f90a66574ffd8f8e029ecb86a7fd1bda617372aff2a526c08 + md5: 45b7bffac387dc2bfc6e7144344cae37 depends: - - python >=3.7 + - python >=3.9 license: Apache-2.0 license_family: Apache purls: - pkg:pypi/absl-py?source=project-defined-mapping - size: 107266 - timestamp: 1705494755555 -- kind: pypi + size: 107138 + timestamp: 1733730665177 +- pypi: https://files.pythonhosted.org/packages/a5/45/30bb92d442636f570cb5651bc661f52b610e2eec3f891a5dc3a4c3667db0/aiofiles-24.1.0-py3-none-any.whl name: aiofiles version: 24.1.0 - url: https://files.pythonhosted.org/packages/a5/45/30bb92d442636f570cb5651bc661f52b610e2eec3f891a5dc3a4c3667db0/aiofiles-24.1.0-py3-none-any.whl sha256: b4ec55f4195e3eb5d7abd1bf7e061763e864dd4954231fb8539a0ef8bb8260e5 requires_python: '>=3.8' -- kind: conda - name: alsa-lib - version: 1.2.12 - build: h4ab18f5_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/alsa-lib-1.2.12-h4ab18f5_0.conda - sha256: 64b95dd06d7ca6b54cea03b02da8f1657b9899ca376d0ca7b47823064f55fb16 - md5: 7ed427f0871fd41cb1d9c17727c17589 +- conda: https://conda.anaconda.org/conda-forge/noarch/aiohappyeyeballs-2.4.4-pyhd8ed1ab_1.conda + sha256: 95d4713e49ea92ae50cf42393683ede706b7875af5f7cb14c253438180afa732 + md5: 296b403617bafa89df4971567af79013 depends: - - libgcc-ng >=12 + - python >=3.9 + license: PSF-2.0 + license_family: PSF + purls: + - pkg:pypi/aiohappyeyeballs?source=project-defined-mapping + size: 19351 + timestamp: 1733332029649 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aiohttp-3.11.10-py312h178313f_0.conda + sha256: dc8ebdd99e9d7a07454a7063a295cdc7a86264648647fec10b2ceae97478e200 + md5: 3e92784b8e32ab7d0b95ee296ba79a99 + depends: + - __glibc >=2.17,<3.0.a0 + - aiohappyeyeballs >=2.3.0 + - aiosignal >=1.1.2 + - attrs >=17.3.0 + - frozenlist >=1.1.1 + - libgcc >=13 + - multidict >=4.5,<7.0 + - propcache >=0.2.0 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - yarl >=1.17.0,<2.0 + license: MIT AND Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/aiohttp?source=project-defined-mapping + size: 914378 + timestamp: 1733839626367 +- conda: https://conda.anaconda.org/conda-forge/noarch/aiosignal-1.3.2-pyhd8ed1ab_0.conda + sha256: 7de8ced1918bbdadecf8e1c1c68237fe5709c097bd9e0d254f4cad118f4345d0 + md5: 1a3981115a398535dbe3f6d5faae3d36 + depends: + - frozenlist >=1.1.0 + - python >=3.9 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/aiosignal?source=project-defined-mapping + size: 13229 + timestamp: 1734342253061 +- conda: https://conda.anaconda.org/conda-forge/linux-64/alsa-lib-1.2.13-hb9d3cd8_0.conda + sha256: f507b58f77eabc0cc133723cb7fc45c053d551f234df85e70fb3ede082b0cd53 + md5: ae1370588aa6a5157c34c73e9bbb36a0 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 license: LGPL-2.1-or-later license_family: GPL purls: [] - size: 555868 - timestamp: 1718118368236 -- kind: pypi + size: 560238 + timestamp: 1731489643707 +- pypi: https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl name: annotated-types version: 0.7.0 - url: https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl sha256: 1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53 requires_dist: - typing-extensions>=4.0.0 ; python_full_version < '3.9' requires_python: '>=3.8' -- kind: conda - name: anyio - version: 4.4.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/anyio-4.4.0-pyhd8ed1ab_0.conda - sha256: 84ac9429812495f12939ab4994f2634f7cacd254f6234a0c2c0243daed15a7ee - md5: 1fa97c6e8db1f82c64ff17a5efc4ae8e +- conda: https://conda.anaconda.org/conda-forge/noarch/anyio-4.7.0-pyhd8ed1ab_0.conda + sha256: 687537ee3af30f8784986bf40cac30e88138770b16e51ca9850c9c23c09aeba1 + md5: c88107912954a983c2caf25f7fd55158 depends: - exceptiongroup >=1.0.2 - idna >=2.8 - - python >=3.8 + - python >=3.9 - sniffio >=1.1 - - typing_extensions >=4.1 + - typing_extensions >=4.5 constrains: - - uvloop >=0.17 - - trio >=0.23 + - trio >=0.26.1 + - uvloop >=0.21 license: MIT license_family: MIT purls: - pkg:pypi/anyio?source=project-defined-mapping - size: 104255 - timestamp: 1717693144467 -- kind: conda - name: anywidget - version: 0.9.13 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/anywidget-0.9.13-pyhd8ed1ab_0.conda - sha256: dbe8cd33de4c1eb1edd3578866d54497a6f51b8ee232bc522a2e497e7926bac0 - md5: 5163983551f7a4361b0a6bcc85334e0c + size: 112730 + timestamp: 1733532678437 +- conda: https://conda.anaconda.org/conda-forge/noarch/anywidget-0.9.13-pyhd8ed1ab_1.conda + sha256: 6cb29520b860d1035477fa1ec4a1543dc3bd55e7579761c2a6640f202e95cb10 + md5: dda6db47029be7cb6e0551d5f3a6df26 depends: - ipywidgets - psygnal - - python >=3.7 + - python >=3.9 - typing_extensions - watchfiles license: MIT license_family: MIT purls: - pkg:pypi/anywidget?source=project-defined-mapping - size: 66391 - timestamp: 1719028676289 -- kind: conda - name: aom - version: 3.9.1 - build: h7bae524_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/aom-3.9.1-h7bae524_0.conda - sha256: ec238f18ce8140485645252351a0eca9ef4f7a1c568a420f240a585229bc12ef - md5: 7adba36492a1bb22d98ffffe4f6fc6de - depends: - - __osx >=11.0 - - libcxx >=16 - license: BSD-2-Clause - license_family: BSD - purls: [] - size: 2235747 - timestamp: 1718551382432 -- kind: conda - name: aom - version: 3.9.1 - build: hac33072_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/aom-3.9.1-hac33072_0.conda + size: 65719 + timestamp: 1734094215637 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aom-3.9.1-hac33072_0.conda sha256: b08ef033817b5f9f76ce62dfcac7694e7b6b4006420372de22494503decac855 md5: 346722a0be40f6edc53f12640d301338 depends: @@ -2354,35 +2475,34 @@ packages: purls: [] size: 2706396 timestamp: 1718551242397 -- kind: conda - name: appnope - version: 0.1.4 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/appnope-0.1.4-pyhd8ed1ab_0.conda - sha256: 45ae2d41f4a4dcf8707633d3d7ae376fc62f0c09b1d063c3049c3f6f8c911670 - md5: cc4834a9ee7cc49ce8d25177c47b10d8 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aom-3.9.1-h7bae524_0.conda + sha256: ec238f18ce8140485645252351a0eca9ef4f7a1c568a420f240a585229bc12ef + md5: 7adba36492a1bb22d98ffffe4f6fc6de depends: - - python >=3.7 + - __osx >=11.0 + - libcxx >=16 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 2235747 + timestamp: 1718551382432 +- conda: https://conda.anaconda.org/conda-forge/noarch/appnope-0.1.4-pyhd8ed1ab_1.conda + sha256: 8f032b140ea4159806e4969a68b4a3c0a7cab1ad936eb958a2b5ffe5335e19bf + md5: 54898d0f524c9dee622d44bbb081a8ab + depends: + - python >=3.9 license: BSD-2-Clause license_family: BSD purls: - pkg:pypi/appnope?source=project-defined-mapping - size: 10241 - timestamp: 1707233195627 -- kind: conda - name: argon2-cffi - version: 23.1.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/argon2-cffi-23.1.0-pyhd8ed1ab_0.conda - sha256: 130766446f5507bd44df957b6b5c898a8bd98f024bb426ed6cb9ff1ad67fc677 - md5: 3afef1f55a1366b4d3b6a0d92e2235e4 + size: 10076 + timestamp: 1733332433806 +- conda: https://conda.anaconda.org/conda-forge/noarch/argon2-cffi-23.1.0-pyhd8ed1ab_1.conda + sha256: 7af62339394986bc470a7a231c7f37ad0173ffb41f6bc0e8e31b0be9e3b9d20f + md5: a7ee488b71c30ada51c48468337b85ba depends: - argon2-cffi-bindings - - python >=3.7 + - python >=3.9 - typing-extensions constrains: - argon2_cffi ==999 @@ -2390,658 +2510,852 @@ packages: license_family: MIT purls: - pkg:pypi/argon2-cffi?source=project-defined-mapping - size: 18602 - timestamp: 1692818472638 -- kind: conda - name: argon2-cffi-bindings - version: 21.2.0 - build: py312h024a12e_5 - build_number: 5 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/argon2-cffi-bindings-21.2.0-py312h024a12e_5.conda - sha256: 0e32ddd41f273f505956254d81ffadaf982ed1cb7dfd70d9251a8c5b705c7267 - md5: 6ccaeafe1a52b0d0e7ebfbf53a374649 + size: 18594 + timestamp: 1733311166338 +- conda: https://conda.anaconda.org/conda-forge/linux-64/argon2-cffi-bindings-21.2.0-py312h66e93f0_5.conda + sha256: 3cbc3b026f5c3f26de696ead10607db8d80cbb003d87669ac3b02e884f711978 + md5: 1505fc57c305c0a3174ea7aae0a0db25 depends: - - __osx >=11.0 + - __glibc >=2.17,<3.0.a0 - cffi >=1.0.1 + - libgcc >=13 - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 license: MIT license_family: MIT purls: - pkg:pypi/argon2-cffi-bindings?source=project-defined-mapping - size: 32838 - timestamp: 1725356954187 -- kind: conda - name: argon2-cffi-bindings - version: 21.2.0 - build: py312h66e93f0_5 - build_number: 5 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/argon2-cffi-bindings-21.2.0-py312h66e93f0_5.conda - sha256: 3cbc3b026f5c3f26de696ead10607db8d80cbb003d87669ac3b02e884f711978 - md5: 1505fc57c305c0a3174ea7aae0a0db25 + size: 34847 + timestamp: 1725356749774 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/argon2-cffi-bindings-21.2.0-py312h024a12e_5.conda + sha256: 0e32ddd41f273f505956254d81ffadaf982ed1cb7dfd70d9251a8c5b705c7267 + md5: 6ccaeafe1a52b0d0e7ebfbf53a374649 depends: - - __glibc >=2.17,<3.0.a0 + - __osx >=11.0 - cffi >=1.0.1 - - libgcc >=13 - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 license: MIT license_family: MIT purls: - pkg:pypi/argon2-cffi-bindings?source=project-defined-mapping - size: 34847 - timestamp: 1725356749774 -- kind: conda - name: arrow - version: 1.3.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/arrow-1.3.0-pyhd8ed1ab_0.conda - sha256: ff49825c7f9e29e09afa6284300810e7a8640d621740efb47c4541f4dc4969db - md5: b77d8c2313158e6e461ca0efb1c2c508 + size: 32838 + timestamp: 1725356954187 +- conda: https://conda.anaconda.org/conda-forge/noarch/arrow-1.3.0-pyhd8ed1ab_1.conda + sha256: c4b0bdb3d5dee50b60db92f99da3e4c524d5240aafc0a5fcc15e45ae2d1a3cd1 + md5: 46b53236fdd990271b03c3978d4218a9 depends: - - python >=3.8 + - python >=3.9 - python-dateutil >=2.7.0 - types-python-dateutil >=2.8.10 license: Apache-2.0 license_family: Apache purls: - pkg:pypi/arrow?source=project-defined-mapping - size: 100096 - timestamp: 1696129131844 -- kind: conda - name: asttokens - version: 2.4.1 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/asttokens-2.4.1-pyhd8ed1ab_0.conda - sha256: 708168f026df19a0344983754d27d1f7b28bb21afc7b97a82f02c4798a3d2111 - md5: 5f25798dcefd8252ce5f9dc494d5f571 + size: 99951 + timestamp: 1733584345583 +- conda: https://conda.anaconda.org/conda-forge/linux-64/assimp-5.4.2-he2e0bbc_1.conda + sha256: d1ae4f1b1806cce0fe8127d747115e8fa895f8ed8469f12a9fe22a75a67a7d54 + md5: c2f1a7890c9bc21bd79c0563579398b4 depends: - - python >=3.5 - - six >=1.12.0 + - __glibc >=2.17,<3.0.a0 + - libboost >=1.86.0,<1.87.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - libzlib >=1.3.1,<2.0a0 + - zlib + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 3473704 + timestamp: 1724011632214 +- conda: https://conda.anaconda.org/conda-forge/noarch/asttokens-3.0.0-pyhd8ed1ab_1.conda + sha256: 93b14414b3b3ed91e286e1cbe4e7a60c4e1b1c730b0814d1e452a8ac4b9af593 + md5: 8f587de4bcf981e26228f268df374a9b + depends: + - python >=3.9 + constrains: + - astroid >=2,<4 license: Apache-2.0 license_family: Apache purls: - pkg:pypi/asttokens?source=project-defined-mapping - size: 28922 - timestamp: 1698341257884 -- kind: conda - name: astunparse - version: 1.6.3 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/astunparse-1.6.3-pyhd8ed1ab_0.tar.bz2 - sha256: e5173d1ed038038e24c0623f0219dc587ee8663cf7efa737e7075128edbc6c60 - md5: 000b6f68a0bfaba800ced7500c11780f + size: 28206 + timestamp: 1733250564754 +- conda: https://conda.anaconda.org/conda-forge/noarch/astunparse-1.6.3-pyhd8ed1ab_2.conda + sha256: f2c00eb43d8f331c0987bdcfc44a1c244f438b5a088f5871a522524ab593954d + md5: 78d205ed5af12a89068386a6e2ca6ee2 depends: - python >=3.6 - six >=1.6.1,<2.0 license: BSD-3-Clause AND PSF-2.0 purls: - pkg:pypi/astunparse?source=project-defined-mapping - size: 15539 - timestamp: 1610696401707 -- kind: conda - name: async-lru - version: 2.0.4 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/async-lru-2.0.4-pyhd8ed1ab_0.conda - sha256: 7ed83731979fe5b046c157730e50af0e24454468bbba1ed8fc1a3107db5d7518 - md5: 3d081de3a6ea9f894bbb585e8e3a4dcb + size: 18008 + timestamp: 1728923265449 +- conda: https://conda.anaconda.org/conda-forge/noarch/async-lru-2.0.4-pyhd8ed1ab_1.conda + sha256: 344157f396dfdc929d1dff8fe010abe173cd168d22a56648583e616495f2929e + md5: 40c673c7d585623b8f1ee650c8734eb6 depends: - - python >=3.8 + - python >=3.9 - typing_extensions >=4.0.0 license: MIT license_family: MIT purls: - pkg:pypi/async-lru?source=project-defined-mapping - size: 15342 - timestamp: 1690563152778 -- kind: conda - name: attrs - version: 24.2.0 - build: pyh71513ae_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/attrs-24.2.0-pyh71513ae_0.conda - sha256: 28dba85a7e0f7fb57d7315e13f603d1e41b83c5b88aa2a602596b52c833a2ff8 - md5: 6732fa52eb8e66e5afeb32db8701a791 + size: 15318 + timestamp: 1733584388228 +- conda: https://conda.anaconda.org/conda-forge/noarch/attrs-24.3.0-pyh71513ae_0.conda + sha256: 750186af694a7130eaf7119fbb56db0d2326d8995ad5b8eae23c622b85fea29a + md5: 356927ace43302bf6f5926e2a58dae6a depends: - - python >=3.7 + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/attrs?source=project-defined-mapping - size: 56048 - timestamp: 1722977241383 -- kind: conda - name: aws-c-auth - version: 0.7.27 - build: h1e647a1_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-auth-0.7.27-h1e647a1_0.conda - sha256: 4ee5792c6046f663193ae3abcc5c9cb9ca7a95302d7d2218924215ac1dc54b78 - md5: 6ff566709ae96ec1495d8adeb8884456 + size: 56354 + timestamp: 1734348889193 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-auth-0.7.31-he1a10d6_2.conda + sha256: 83fa4b24101cd85da825dcbb7611390c2a6e31a3fc17abb4d1ee5b8c40bdaa5a + md5: 76550a294cc78aaccfca7824bb4814ce depends: - - __osx >=11.0 + - __glibc >=2.17,<3.0.a0 - aws-c-cal >=0.7.4,<0.7.5.0a0 - - aws-c-common >=0.9.27,<0.9.28.0a0 - - aws-c-http >=0.8.8,<0.8.9.0a0 - - aws-c-io >=0.14.18,<0.14.19.0a0 + - aws-c-common >=0.9.29,<0.9.30.0a0 + - aws-c-http >=0.8.10,<0.8.11.0a0 + - aws-c-io >=0.14.19,<0.14.20.0a0 - aws-c-sdkutils >=0.1.19,<0.1.20.0a0 + - libgcc >=13 license: Apache-2.0 license_family: Apache purls: [] - size: 92576 - timestamp: 1725413964188 -- kind: conda - name: aws-c-auth - version: 0.7.27 - build: hc36b679_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/aws-c-auth-0.7.27-hc36b679_0.conda - sha256: 4d7e3978298607714ccb12331e33a70d1118a67651f6620ac3c2039aab75329d - md5: ab47c6b609a2233426239c2da7458982 + size: 107301 + timestamp: 1728796325782 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-auth-0.8.0-hb921021_15.conda + sha256: 537006ad6d5097c134494166a6a1dc1451d5d050878d7b82cef498bfda40ba8a + md5: c79d50f64cffa5ad51ecc1a81057962f depends: - __glibc >=2.17,<3.0.a0 - - aws-c-cal >=0.7.4,<0.7.5.0a0 - - aws-c-common >=0.9.27,<0.9.28.0a0 - - aws-c-http >=0.8.8,<0.8.9.0a0 - - aws-c-io >=0.14.18,<0.14.19.0a0 - - aws-c-sdkutils >=0.1.19,<0.1.20.0a0 + - aws-c-cal >=0.8.1,<0.8.2.0a0 + - aws-c-common >=0.10.6,<0.10.7.0a0 + - aws-c-http >=0.9.2,<0.9.3.0a0 + - aws-c-io >=0.15.3,<0.15.4.0a0 + - aws-c-sdkutils >=0.2.1,<0.2.2.0a0 - libgcc >=13 license: Apache-2.0 license_family: Apache purls: [] - size: 107548 - timestamp: 1725413843666 -- kind: conda - name: aws-c-cal - version: 0.7.4 - build: h2abdd08_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/aws-c-cal-0.7.4-h2abdd08_0.conda - sha256: 7f8d27167ca67a3bdf8ab2de9f5c17c88d85a02c1f14485f67857ab745a18d95 - md5: 006ee3bee3d0428e1b43b47ef1cffbc6 + size: 107614 + timestamp: 1734021692519 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-auth-0.7.31-h14f56dd_2.conda + sha256: 7ec650c52962f62e141d5c8ac018befd9a0c50eef1c951cba11089cadd90e703 + md5: 85a9125cf9705e4c7a829a829af6744b depends: - - __glibc >=2.17,<3.0.a0 - - aws-c-common >=0.9.27,<0.9.28.0a0 - - libgcc-ng >=13 - - openssl >=3.3.1,<4.0a0 + - __osx >=11.0 + - aws-c-cal >=0.7.4,<0.7.5.0a0 + - aws-c-common >=0.9.29,<0.9.30.0a0 + - aws-c-http >=0.8.10,<0.8.11.0a0 + - aws-c-io >=0.14.19,<0.14.20.0a0 + - aws-c-sdkutils >=0.1.19,<0.1.20.0a0 license: Apache-2.0 license_family: Apache purls: [] - size: 47302 - timestamp: 1724465491480 -- kind: conda - name: aws-c-cal - version: 0.7.4 - build: h41e72e7_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-cal-0.7.4-h41e72e7_0.conda - sha256: 511af4c04a13ca96b22f870364699619223727604ff696e669cda4eaeab95b4c - md5: e48f1946d72265f688574057ce762ee8 + size: 92624 + timestamp: 1728796392911 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-auth-0.8.0-h8bc59a9_15.conda + sha256: 0e41e56b662e76e024182adebcd91d09a4d38a83b35217c84e4967354dfff9a2 + md5: f688b8893c20ad9477a19e7ce614014a depends: - __osx >=11.0 - - aws-c-common >=0.9.27,<0.9.28.0a0 + - aws-c-cal >=0.8.1,<0.8.2.0a0 + - aws-c-common >=0.10.6,<0.10.7.0a0 + - aws-c-http >=0.9.2,<0.9.3.0a0 + - aws-c-io >=0.15.3,<0.15.4.0a0 + - aws-c-sdkutils >=0.2.1,<0.2.2.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 92507 + timestamp: 1734021831330 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-cal-0.7.4-hae4d56a_2.conda + sha256: 4bfed63898a1697364ce9621e1fc09c98f143777b0ca60655eb812efa5bf246d + md5: cdc628e4ffb4ffcd476e3847267e1689 + depends: + - __glibc >=2.17,<3.0.a0 + - aws-c-common >=0.9.29,<0.9.30.0a0 + - libgcc >=13 - openssl >=3.3.1,<4.0a0 license: Apache-2.0 license_family: Apache purls: [] - size: 39497 - timestamp: 1724465650217 -- kind: conda - name: aws-c-common - version: 0.9.27 - build: h4bc722e_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/aws-c-common-0.9.27-h4bc722e_0.conda - sha256: b1725a5ec43bcf606d6bdb248312aa51386b30339dd83a1f16edf620fe03d941 - md5: 817119e8a21a45d325f65d0d54710052 + size: 47181 + timestamp: 1728755555430 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-cal-0.8.1-h1a47875_3.conda + sha256: 095ac824ea9303eff67e04090ae531d9eb33d2bf8f82eaade39b839c421e16e8 + md5: 55a8561fdbbbd34f50f57d9be12ed084 depends: - __glibc >=2.17,<3.0.a0 - - libgcc-ng >=12 + - aws-c-common >=0.10.6,<0.10.7.0a0 + - libgcc >=13 + - openssl >=3.3.1,<4.0a0 license: Apache-2.0 license_family: Apache purls: [] - size: 236759 - timestamp: 1723639577027 -- kind: conda - name: aws-c-common - version: 0.9.27 - build: h99b78c6_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-common-0.9.27-h99b78c6_0.conda - sha256: 6c5a03e6e8436b307c6e36a257ceb24a95338e5d82de48c7462ceb921adadb35 - md5: b92f3870b54249178462862413137ca1 + size: 47601 + timestamp: 1733991564405 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-cal-0.7.4-hd45b2be_2.conda + sha256: d701872d79184dbb759aa033e6a6e4ec5c6f1b58e3255e53b756d0246d19986a + md5: de4bf687ac70a2b861a94b87164669c9 depends: - __osx >=11.0 + - aws-c-common >=0.9.29,<0.9.30.0a0 + - openssl >=3.3.1,<4.0a0 license: Apache-2.0 license_family: Apache purls: [] - size: 220718 - timestamp: 1723639978181 -- kind: conda - name: aws-c-compression - version: 0.2.19 - build: h41e72e7_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-compression-0.2.19-h41e72e7_0.conda - sha256: e61ee499ca9db361bca4d8c8f9bf3db439dfc25bd71f1405d6ec97e74699ef3f - md5: c0fa07c8ba0434260ee3e6a05d4ddfa4 + size: 39794 + timestamp: 1728755626145 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-cal-0.8.1-hc8a0bd2_3.conda + sha256: 1f44be36e1daa17b4b081debb8aee492d13571084f38b503ad13e869fef24fe4 + md5: 8b0ce61384e5a33d2b301a64f3d22ac5 depends: - __osx >=11.0 - - aws-c-common >=0.9.27,<0.9.28.0a0 + - aws-c-common >=0.10.6,<0.10.7.0a0 + - openssl >=3.3.1,<4.0a0 license: Apache-2.0 license_family: Apache purls: [] - size: 18046 - timestamp: 1724353909848 -- kind: conda - name: aws-c-compression - version: 0.2.19 - build: haa50ccc_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/aws-c-compression-0.2.19-haa50ccc_0.conda - sha256: d7cca92ff47e5de9e53ce6ea90186d578883b35d4c665b166ada2754d7786d05 - md5: 00c38c49d0befb632f686cf67ee8c9f5 + size: 39925 + timestamp: 1733991649383 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-common-0.10.6-hb9d3cd8_0.conda + sha256: 496e92f2150fdc351eacf6e236015deedb3d0d3114f8e5954341cbf9f3dda257 + md5: d7d4680337a14001b0e043e96529409b depends: - __glibc >=2.17,<3.0.a0 - - aws-c-common >=0.9.27,<0.9.28.0a0 - - libgcc-ng >=13 + - libgcc >=13 license: Apache-2.0 license_family: Apache purls: [] - size: 19010 - timestamp: 1724353825002 -- kind: conda - name: aws-c-event-stream - version: 0.4.3 - build: h570d160_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/aws-c-event-stream-0.4.3-h570d160_0.conda - sha256: 608225f14f0befcc351860c2961ae9734f7bf097b3ffb88aea69727c65843689 - md5: 1c121949295cac86798be8f369768d7c - depends: - - __glibc >=2.17,<3.0.a0 - - aws-c-common >=0.9.27,<0.9.28.0a0 - - aws-c-io >=0.14.18,<0.14.19.0a0 - - aws-checksums >=0.1.18,<0.1.19.0a0 - - libgcc-ng >=12 - - libstdcxx-ng >=12 + size: 236574 + timestamp: 1733975453350 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-common-0.9.29-hb9d3cd8_0.conda + sha256: b3b50f518e9afad383f6851bf7000cf8b343d7d3ca71558df233ee7b4bfc2919 + md5: acc51b49fd7467c8dfe4343001b812b4 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 license: Apache-2.0 license_family: Apache purls: [] - size: 53945 - timestamp: 1724071086055 -- kind: conda - name: aws-c-event-stream - version: 0.4.3 - build: h79ff00d_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-event-stream-0.4.3-h79ff00d_0.conda - sha256: bc45ee6a05f45b0ba2a8f014b2ac67e1aa33b98ec2f95286482bd9af37025fc7 - md5: 05dc0c49ea75ee73735416e2b3612c56 + size: 237231 + timestamp: 1728706773555 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-common-0.10.6-h5505292_0.conda + sha256: 3bde135c8e74987c0f79ecd4fa17ec9cff0d658b3090168727ca1af3815ae57a + md5: 145e5b4c9702ed279d7d68aaf096f77d depends: - __osx >=11.0 - - aws-c-common >=0.9.27,<0.9.28.0a0 - - aws-c-io >=0.14.18,<0.14.19.0a0 - - aws-checksums >=0.1.18,<0.1.19.0a0 - - libcxx >=16 license: Apache-2.0 license_family: Apache purls: [] - size: 47322 - timestamp: 1724071159670 -- kind: conda - name: aws-c-http - version: 0.8.8 - build: h69517e7_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-http-0.8.8-h69517e7_1.conda - sha256: b78122bbde3d3509fe1c44c0c984e16b2e973e0ee365e2fcad168a57ce0b4435 - md5: e6916a654d06547263078f5344ce9242 + size: 221863 + timestamp: 1733975576886 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-common-0.9.29-h7ab814d_0.conda + sha256: 8d2c330f0de571f1bf6f2db7650a1aa8c4060a2ccd25b48f392a4d3ea8222daa + md5: d4a90d217342b08daa7e80049fdaa6c9 depends: - __osx >=11.0 - - aws-c-cal >=0.7.4,<0.7.5.0a0 - - aws-c-common >=0.9.27,<0.9.28.0a0 - - aws-c-compression >=0.2.19,<0.2.20.0a0 - - aws-c-io >=0.14.18,<0.14.19.0a0 license: Apache-2.0 license_family: Apache purls: [] - size: 152051 - timestamp: 1724686217875 -- kind: conda - name: aws-c-http - version: 0.8.8 - build: h9b61739_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/aws-c-http-0.8.8-h9b61739_1.conda - sha256: 45e17e24d5af97a4cd1d66ff0011fd3a6635712056826f77464c56592b5cea06 - md5: cce4559ceae32920b4625594323841b4 + size: 220687 + timestamp: 1728706817796 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-compression-0.2.19-h2bff981_2.conda + sha256: 908a416ff3f62b09bed436e1f77418f54115412244734d3960b11d586dd0749f + md5: 87a059d4d2ab89409496416119dd7152 depends: - __glibc >=2.17,<3.0.a0 - - aws-c-cal >=0.7.4,<0.7.5.0a0 - - aws-c-common >=0.9.27,<0.9.28.0a0 - - aws-c-compression >=0.2.19,<0.2.20.0a0 - - aws-c-io >=0.14.18,<0.14.19.0a0 - - libgcc-ng >=13 - license: Apache-2.0 - license_family: Apache - purls: [] - size: 196689 - timestamp: 1724686094657 -- kind: conda - name: aws-c-io - version: 0.14.18 - build: h20e6805_7 - build_number: 7 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-io-0.14.18-h20e6805_7.conda - sha256: b1b0c96f6731766835439698ee6132913f9bad8baddac9b3f3155b997bb1bfee - md5: 43fd2b48c5069aed0c0395eea1382398 - depends: - - __osx >=11.0 - - aws-c-cal >=0.7.4,<0.7.5.0a0 - - aws-c-common >=0.9.27,<0.9.28.0a0 + - aws-c-common >=0.9.29,<0.9.30.0a0 + - libgcc >=13 license: Apache-2.0 license_family: Apache purls: [] - size: 137767 - timestamp: 1724672665309 -- kind: conda - name: aws-c-io - version: 0.14.18 - build: h49c7fd3_7 - build_number: 7 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/aws-c-io-0.14.18-h49c7fd3_7.conda - sha256: 5cd0753e4cbabe243270b7587e78ac8fc25b4ca36dc6dbe680ae2a8ab014725f - md5: 536d25f5bdf2badc197cef350161593a + size: 18983 + timestamp: 1728750679322 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-compression-0.3.0-h4e1184b_5.conda + sha256: 62ca84da83585e7814a40240a1e750b1563b2680b032a471464eccc001c3309b + md5: 3f4c1197462a6df2be6dc8241828fe93 depends: - __glibc >=2.17,<3.0.a0 - - aws-c-cal >=0.7.4,<0.7.5.0a0 - - aws-c-common >=0.9.27,<0.9.28.0a0 - - libgcc-ng >=13 - - s2n >=1.5.1,<1.5.2.0a0 + - aws-c-common >=0.10.6,<0.10.7.0a0 + - libgcc >=13 license: Apache-2.0 license_family: Apache purls: [] - size: 158750 - timestamp: 1724672608749 -- kind: conda - name: aws-c-mqtt - version: 0.10.4 - build: h3e8bf47_18 - build_number: 18 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-mqtt-0.10.4-h3e8bf47_18.conda - sha256: ec159192ab0f69ff79cbc3730a4096b5ff44716ef6a5197f5a438f89c32be400 - md5: 5816f2232e2aa59d4b43e5cca8365604 + size: 19086 + timestamp: 1733991637424 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-compression-0.2.19-hd45b2be_2.conda + sha256: 86900c68f95a2ca79cb9bcb8a3e8fd0a7912cfa3754a6a1e6b78d35c0b8db58b + md5: 9c634af661f50e923419e0df92633d31 depends: - __osx >=11.0 - - aws-c-common >=0.9.27,<0.9.28.0a0 - - aws-c-http >=0.8.8,<0.8.9.0a0 - - aws-c-io >=0.14.18,<0.14.19.0a0 - license: Apache-2.0 - license_family: Apache - purls: [] - size: 117152 - timestamp: 1724672546027 -- kind: conda - name: aws-c-mqtt - version: 0.10.4 - build: h5c8269d_18 - build_number: 18 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/aws-c-mqtt-0.10.4-h5c8269d_18.conda - sha256: 405c68044e3181888dbb4d7abf6c3c29a7c93af02472259d40846957f25d1b4d - md5: ae2b300e78008afad1fef638ed0ee09f - depends: - - __glibc >=2.17,<3.0.a0 - - aws-c-common >=0.9.27,<0.9.28.0a0 - - aws-c-http >=0.8.8,<0.8.9.0a0 - - aws-c-io >=0.14.18,<0.14.19.0a0 - - libgcc-ng >=13 + - aws-c-common >=0.9.29,<0.9.30.0a0 license: Apache-2.0 license_family: Apache purls: [] - size: 164040 - timestamp: 1724672527322 -- kind: conda - name: aws-c-s3 - version: 0.6.5 - build: h5e39592_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-s3-0.6.5-h5e39592_0.conda - sha256: 73d9e49f63c5900089cbdc9aeb7513d5a5fe32a61c80c7c41383c1baea975855 - md5: 46e3cce0c04aebb067fa4c4018177f62 + size: 18065 + timestamp: 1728750721405 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-compression-0.3.0-hc8a0bd2_5.conda + sha256: 47b2813f652ce7e64ac442f771b2a5f7d4af4ad0d07ff51f6075ea80ed2e3f09 + md5: a8b6c17732d14ed49d0e9b59c43186bc depends: - __osx >=11.0 - - aws-c-auth >=0.7.27,<0.7.28.0a0 - - aws-c-cal >=0.7.4,<0.7.5.0a0 - - aws-c-common >=0.9.27,<0.9.28.0a0 - - aws-c-http >=0.8.8,<0.8.9.0a0 - - aws-c-io >=0.14.18,<0.14.19.0a0 - - aws-checksums >=0.1.18,<0.1.19.0a0 + - aws-c-common >=0.10.6,<0.10.7.0a0 license: Apache-2.0 license_family: Apache purls: [] - size: 96347 - timestamp: 1725509213437 -- kind: conda - name: aws-c-s3 - version: 0.6.5 - build: h9204347_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/aws-c-s3-0.6.5-h9204347_0.conda - sha256: 12f0dac29820402162b6efef37cf5ed2e2d7175911f85c9de0e980f16df554ca - md5: b22146e93adf3c9d0d3ace7782a87a0e + size: 18068 + timestamp: 1733991869211 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-event-stream-0.4.3-h19b0707_4.conda + sha256: 951f96eb45a439a36935dc2099e10c902518ec511a287c1685ca65a88a9accaa + md5: df38f56123f30d61de24474e600e7d41 depends: - __glibc >=2.17,<3.0.a0 - - aws-c-auth >=0.7.27,<0.7.28.0a0 - - aws-c-cal >=0.7.4,<0.7.5.0a0 - - aws-c-common >=0.9.27,<0.9.28.0a0 - - aws-c-http >=0.8.8,<0.8.9.0a0 - - aws-c-io >=0.14.18,<0.14.19.0a0 - - aws-checksums >=0.1.18,<0.1.19.0a0 + - aws-c-common >=0.9.29,<0.9.30.0a0 + - aws-c-io >=0.14.19,<0.14.20.0a0 + - aws-checksums >=0.1.20,<0.1.21.0a0 - libgcc >=13 - - openssl >=3.3.2,<4.0a0 + - libstdcxx >=13 license: Apache-2.0 license_family: Apache purls: [] - size: 112702 - timestamp: 1725509184867 -- kind: conda - name: aws-c-sdkutils - version: 0.1.19 - build: h038f3f9_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/aws-c-sdkutils-0.1.19-h038f3f9_2.conda - sha256: 5612c9cad56662db50a1bcc2d8dca1fe273f7abad6f670fef328e4044beabc75 - md5: 6861cab6cddb5d713cb3db95c838d30f + size: 53821 + timestamp: 1728792746255 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-event-stream-0.5.0-h7959bf6_11.conda + sha256: 10d7240c7db0c941fb1a59c4f8ea6689a434b03309ee7b766fa15a809c553c02 + md5: 9b3fb60fe57925a92f399bc3fc42eccf depends: - __glibc >=2.17,<3.0.a0 - - aws-c-common >=0.9.27,<0.9.28.0a0 - - libgcc-ng >=12 + - aws-c-common >=0.10.6,<0.10.7.0a0 + - aws-c-io >=0.15.3,<0.15.4.0a0 + - aws-checksums >=0.2.2,<0.2.3.0a0 + - libgcc >=13 + - libstdcxx >=13 license: Apache-2.0 license_family: Apache purls: [] - size: 55878 - timestamp: 1723691348466 -- kind: conda - name: aws-c-sdkutils - version: 0.1.19 - build: h85401af_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-sdkutils-0.1.19-h85401af_2.conda - sha256: faf9f32a7b3f312f370e77cf52e6afe512c6cce4cd9709fe039ff08acd877f5a - md5: 23183f9ce785058346cbb89c4327b02b + size: 54003 + timestamp: 1734024480949 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-event-stream-0.4.3-hdf5079d_4.conda + sha256: 6976ea97bf8c79114da3026a9d46b717131e2445be01f244718a426ad4b587f2 + md5: d89057a51d66d9c0c907c3dfebf845eb + depends: + - __osx >=11.0 + - aws-c-common >=0.9.29,<0.9.30.0a0 + - aws-c-io >=0.14.19,<0.14.20.0a0 + - aws-checksums >=0.1.20,<0.1.21.0a0 + - libcxx >=17 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 46737 + timestamp: 1728792823021 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-event-stream-0.5.0-h54f970a_11.conda + sha256: f0667935f4e0d4c25e0e51da035640310b5ceeb8f723156734439bde8b848d7d + md5: ba41238f8e653998d7d2f42e3a8db054 depends: - __osx >=11.0 - - aws-c-common >=0.9.27,<0.9.28.0a0 + - aws-c-common >=0.10.6,<0.10.7.0a0 + - aws-c-io >=0.15.3,<0.15.4.0a0 + - aws-checksums >=0.2.2,<0.2.3.0a0 + - libcxx >=18 license: Apache-2.0 license_family: Apache purls: [] - size: 49819 - timestamp: 1723691442488 -- kind: conda - name: aws-checksums - version: 0.1.18 - build: h038f3f9_10 - build_number: 10 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/aws-checksums-0.1.18-h038f3f9_10.conda - sha256: a94547ff766fb420c368bb8d4fd1c8d99b13088d176c43ad7bb7458ef47e45bc - md5: 4bf9c8fcf2bb6793c55e5c5758b9b011 + size: 47078 + timestamp: 1734024749727 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-http-0.8.10-h14a7884_2.conda + sha256: 0561267292739a451d7d389f100330fefafb97859962f617cd5268c96400e3aa + md5: 6147c6b6cef67adcb85516f5cf775be7 depends: - __glibc >=2.17,<3.0.a0 - - aws-c-common >=0.9.27,<0.9.28.0a0 - - libgcc-ng >=12 + - aws-c-cal >=0.7.4,<0.7.5.0a0 + - aws-c-common >=0.9.29,<0.9.30.0a0 + - aws-c-compression >=0.2.19,<0.2.20.0a0 + - aws-c-io >=0.14.19,<0.14.20.0a0 + - libgcc >=13 license: Apache-2.0 license_family: Apache purls: [] - size: 49839 - timestamp: 1723691467978 -- kind: conda - name: aws-checksums - version: 0.1.18 - build: h85401af_10 - build_number: 10 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/aws-checksums-0.1.18-h85401af_10.conda - sha256: aeafa3581c3b82d5ac9b13a041795706c3cb0efe3764ee6825f0042a7f52041e - md5: 446c0b024a1cbf4b769d271da2bfdce2 + size: 197562 + timestamp: 1728792795954 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-http-0.9.2-hefd7a92_4.conda + sha256: 4a330206bd51148f6c13ca0b7a4db40f29a46f090642ebacdeb88b8a4abd7f99 + md5: 5ce4df662d32d3123ea8da15571b6f51 + depends: + - __glibc >=2.17,<3.0.a0 + - aws-c-cal >=0.8.1,<0.8.2.0a0 + - aws-c-common >=0.10.6,<0.10.7.0a0 + - aws-c-compression >=0.3.0,<0.3.1.0a0 + - aws-c-io >=0.15.3,<0.15.4.0a0 + - libgcc >=13 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 197731 + timestamp: 1734008380764 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-http-0.8.10-h4588aaf_2.conda + sha256: 0f422e1cb3ebfa4fbf316e0ee576ed8e8f96cd9890783a0d319366e7ad9ebca6 + md5: fd850cc4bc7af65f3b7e98324bda96fa depends: - __osx >=11.0 - - aws-c-common >=0.9.27,<0.9.28.0a0 + - aws-c-cal >=0.7.4,<0.7.5.0a0 + - aws-c-common >=0.9.29,<0.9.30.0a0 + - aws-c-compression >=0.2.19,<0.2.20.0a0 + - aws-c-io >=0.14.19,<0.14.20.0a0 license: Apache-2.0 license_family: Apache purls: [] - size: 48964 - timestamp: 1723691578183 -- kind: conda - name: aws-crt-cpp - version: 0.28.2 - build: h6552c9e_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/aws-crt-cpp-0.28.2-h6552c9e_2.conda - sha256: b41db5ff001a9258864509901e36569f304f3edca9b21d97b67491037160d269 - md5: f2305fd14eef886b7e502a84cd010c00 + size: 152421 + timestamp: 1728792977955 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-http-0.9.2-h96aa502_4.conda + sha256: 22e4737c8a885995b7c1ae1d79c1f6e78d489e16ec079615980fdde067aeaf76 + md5: 495c93a4f08b17deb3c04894512330e6 + depends: + - __osx >=11.0 + - aws-c-cal >=0.8.1,<0.8.2.0a0 + - aws-c-common >=0.10.6,<0.10.7.0a0 + - aws-c-compression >=0.3.0,<0.3.1.0a0 + - aws-c-io >=0.15.3,<0.15.4.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 152983 + timestamp: 1734008451473 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-io-0.14.19-hc9e6898_1.conda + sha256: 35f9719fb9d5ddf4955a432d73d910261d60754d20b58de2be2701a2e68a9cfb + md5: ec84785f7ae14ed43156a54aec33bb14 + depends: + - __glibc >=2.17,<3.0.a0 + - aws-c-cal >=0.7.4,<0.7.5.0a0 + - aws-c-common >=0.9.29,<0.9.30.0a0 + - libgcc >=13 + - s2n >=1.5.5,<1.5.6.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 158806 + timestamp: 1728770974012 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-io-0.15.3-h831e299_5.conda + sha256: 5920009b1c6f9a2bc131a36725251894e4b4773fce29c4b1065d4213ae337abe + md5: 80dd9f0ddf935290d1dc00ec75ff3023 + depends: + - __glibc >=2.17,<3.0.a0 + - aws-c-cal >=0.8.1,<0.8.2.0a0 + - aws-c-common >=0.10.6,<0.10.7.0a0 + - libgcc >=13 + - s2n >=1.5.10,<1.5.11.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 157864 + timestamp: 1734433578570 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-io-0.14.19-h5ad5fc2_1.conda + sha256: 0fcfbd9b46474b543d59183bedee08bf46d0f5167c95406b3b06ce922d6626c4 + md5: 463fae93275ddd0a6e2afb327b4d87e5 + depends: + - __osx >=11.0 + - aws-c-cal >=0.7.4,<0.7.5.0a0 + - aws-c-common >=0.9.29,<0.9.30.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 137474 + timestamp: 1728770995104 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-io-0.15.3-haba67d1_5.conda + sha256: c0a1a2b0750225ac3dc07fd258c88c2be866bf8ac67ba3d50bb4ecec852ff8ee + md5: 4c5ff4134e76426a75b8c548984fa933 + depends: + - __osx >=11.0 + - aws-c-cal >=0.8.1,<0.8.2.0a0 + - aws-c-common >=0.10.6,<0.10.7.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 135729 + timestamp: 1734433832730 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-mqtt-0.10.7-hb8d5873_2.conda + sha256: b30a3d8ba9352760c30f696b65486fe0e1d3cfe771f114b008a70ad440eb00c0 + md5: 8dc25ca24c1a50b8295a848c384ede99 + depends: + - __glibc >=2.17,<3.0.a0 + - aws-c-common >=0.9.29,<0.9.30.0a0 + - aws-c-http >=0.8.10,<0.8.11.0a0 + - aws-c-io >=0.14.19,<0.14.20.0a0 + - libgcc >=13 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 195951 + timestamp: 1728797647791 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-mqtt-0.11.0-h11f4f37_12.conda + sha256: 512d3969426152d9d5fd886e27b13706122dc3fa90eb08c37b0d51a33d7bb14a + md5: 96c3e0221fa2da97619ee82faa341a73 depends: - __glibc >=2.17,<3.0.a0 - - aws-c-auth >=0.7.27,<0.7.28.0a0 + - aws-c-common >=0.10.6,<0.10.7.0a0 + - aws-c-http >=0.9.2,<0.9.3.0a0 + - aws-c-io >=0.15.3,<0.15.4.0a0 + - libgcc >=13 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 194672 + timestamp: 1734025626798 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-mqtt-0.10.7-hbe077eb_2.conda + sha256: 376f757b460fc936da6b8159ef80ed5a51a23d2ba02e7834055a99616004d3bc + md5: 5013eaa8a8242355199a31e8973ff3f0 + depends: + - __osx >=11.0 + - aws-c-common >=0.9.29,<0.9.30.0a0 + - aws-c-http >=0.8.10,<0.8.11.0a0 + - aws-c-io >=0.14.19,<0.14.20.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 135058 + timestamp: 1728797199832 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-mqtt-0.11.0-h24f418c_12.conda + sha256: 96575ea1dd2a9ea94763882e40a66dcbff9c41f702bf37c9514c4c719b3c11dd + md5: c072045a6206f88015d02fcba1705ea1 + depends: + - __osx >=11.0 + - aws-c-common >=0.10.6,<0.10.7.0a0 + - aws-c-http >=0.9.2,<0.9.3.0a0 + - aws-c-io >=0.15.3,<0.15.4.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 134371 + timestamp: 1734025379525 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-s3-0.6.7-h666547d_0.conda + sha256: fe006f58bd9349ab7cd4cd864dd4e83409e89764b10d9d7eb7ec148e2f964465 + md5: 7f59dcbbd4eab14ca9256f20b43849eb + depends: + - __glibc >=2.17,<3.0.a0 + - aws-c-auth >=0.7.31,<0.7.32.0a0 - aws-c-cal >=0.7.4,<0.7.5.0a0 - - aws-c-common >=0.9.27,<0.9.28.0a0 + - aws-c-common >=0.9.29,<0.9.30.0a0 + - aws-c-http >=0.8.10,<0.8.11.0a0 + - aws-c-io >=0.14.19,<0.14.20.0a0 + - aws-checksums >=0.1.20,<0.1.21.0a0 + - libgcc >=13 + - openssl >=3.3.2,<4.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 113457 + timestamp: 1728967087200 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-s3-0.7.7-hf454442_0.conda + sha256: c2f205a7bf64c5f40eea373b3a0a7c363c9aa9246a13dd7f3d9c6a4434c4fe2d + md5: 947c82025693bebd557f782bb5d6b469 + depends: + - __glibc >=2.17,<3.0.a0 + - aws-c-auth >=0.8.0,<0.8.1.0a0 + - aws-c-cal >=0.8.1,<0.8.2.0a0 + - aws-c-common >=0.10.6,<0.10.7.0a0 + - aws-c-http >=0.9.2,<0.9.3.0a0 + - aws-c-io >=0.15.3,<0.15.4.0a0 + - aws-checksums >=0.2.2,<0.2.3.0a0 + - libgcc >=13 + - openssl >=3.4.0,<4.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 114156 + timestamp: 1734146123386 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-s3-0.6.7-h86d2b7d_0.conda + sha256: 4691154b75d85039da165b01bd25a2dce99f40b8a635fa9537a36a45dcc3e236 + md5: 851d2b927ba01ac963ffbc1868e971a3 + depends: + - __osx >=11.0 + - aws-c-auth >=0.7.31,<0.7.32.0a0 + - aws-c-cal >=0.7.4,<0.7.5.0a0 + - aws-c-common >=0.9.29,<0.9.30.0a0 + - aws-c-http >=0.8.10,<0.8.11.0a0 + - aws-c-io >=0.14.19,<0.14.20.0a0 + - aws-checksums >=0.1.20,<0.1.21.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 96707 + timestamp: 1728967262718 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-s3-0.7.7-h1be5864_0.conda + sha256: 22966164d63808689fffd35945f57756c95337327e28099b5d77b29fc6a56ecc + md5: a37bba7acb62dd70492ee01eacca3b8f + depends: + - __osx >=11.0 + - aws-c-auth >=0.8.0,<0.8.1.0a0 + - aws-c-cal >=0.8.1,<0.8.2.0a0 + - aws-c-common >=0.10.6,<0.10.7.0a0 + - aws-c-http >=0.9.2,<0.9.3.0a0 + - aws-c-io >=0.15.3,<0.15.4.0a0 + - aws-checksums >=0.2.2,<0.2.3.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 97598 + timestamp: 1734146239038 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-sdkutils-0.1.19-h2bff981_4.conda + sha256: ef65ca9eb9f32ada6fb1b47759374e7ef4f85db002f2265ebc8fd61718284cbc + md5: 5a8afd37e2dfe464d68e63d1c38b08c5 + depends: + - __glibc >=2.17,<3.0.a0 + - aws-c-common >=0.9.29,<0.9.30.0a0 + - libgcc >=13 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 55957 + timestamp: 1728755888042 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-sdkutils-0.2.1-h4e1184b_4.conda + sha256: df586f42210af1134b1c88ff4c278c3cb6d6c807c84eac48860062464b28554d + md5: a5126a90e74ac739b00564a4c7ddcc36 + depends: + - __glibc >=2.17,<3.0.a0 + - aws-c-common >=0.10.6,<0.10.7.0a0 + - libgcc >=13 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 56094 + timestamp: 1733994449690 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-sdkutils-0.1.19-hd45b2be_4.conda + sha256: cc374eef1b367fb9acc83b2e74830f62742d3e53e1f0f6a0d01939b16ed1e3d5 + md5: 7ccdd0f21ffbc77b11963f00892ca8b5 + depends: + - __osx >=11.0 + - aws-c-common >=0.9.29,<0.9.30.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 49543 + timestamp: 1728755942076 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-sdkutils-0.2.1-hc8a0bd2_4.conda + sha256: de98343ce42d2e569b3380292d20f47bf39bda08aadabcbb8e650d3f38fd742f + md5: 22f72f8cd7ead211304ac17d337d96e0 + depends: + - __osx >=11.0 + - aws-c-common >=0.10.6,<0.10.7.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 49664 + timestamp: 1733994553014 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-checksums-0.1.20-h2bff981_1.conda + sha256: e1793f2e52fe04ef3a6b2069abda7960d061c6f7af1f0d5f616d43e7a7c40e3c + md5: 8b424cf6b3cfc5cffe98bf4d16c032fb + depends: + - __glibc >=2.17,<3.0.a0 + - aws-c-common >=0.9.29,<0.9.30.0a0 + - libgcc >=13 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 72862 + timestamp: 1728750748391 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-checksums-0.2.2-h4e1184b_4.conda + sha256: 1ed9a332d06ad595694907fad2d6d801082916c27cd5076096fda4061e6d24a8 + md5: 74e8c3e4df4ceae34aa2959df4b28101 + depends: + - __glibc >=2.17,<3.0.a0 + - aws-c-common >=0.10.6,<0.10.7.0a0 + - libgcc >=13 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 72762 + timestamp: 1733994347547 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-checksums-0.1.20-hd45b2be_1.conda + sha256: d935ca7faa780cfa1053fe1bffb77611a54b4df791897a22048e770b250c651f + md5: ab0b68aafe787311cb8397fd2e60982d + depends: + - __osx >=11.0 + - aws-c-common >=0.9.29,<0.9.30.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 70087 + timestamp: 1728750818479 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-checksums-0.2.2-hc8a0bd2_4.conda + sha256: 215086d95e8ff1d3fcb0197ada116cc9d7db1fdae7573f5e810d20fa9215b47c + md5: e70e88a357a3749b67679c0788c5b08a + depends: + - __osx >=11.0 + - aws-c-common >=0.10.6,<0.10.7.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 70186 + timestamp: 1733994496998 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-crt-cpp-0.28.3-hbe26082_8.conda + sha256: a9c23a685929b24fcd032daae36b61c4862912abf0a0a8735aeef53418c5bce6 + md5: 80d5fac04be0e6c2774f57eb7529f145 + depends: + - __glibc >=2.17,<3.0.a0 + - aws-c-auth >=0.7.31,<0.7.32.0a0 + - aws-c-cal >=0.7.4,<0.7.5.0a0 + - aws-c-common >=0.9.29,<0.9.30.0a0 - aws-c-event-stream >=0.4.3,<0.4.4.0a0 - - aws-c-http >=0.8.8,<0.8.9.0a0 - - aws-c-io >=0.14.18,<0.14.19.0a0 - - aws-c-mqtt >=0.10.4,<0.10.5.0a0 - - aws-c-s3 >=0.6.5,<0.6.6.0a0 + - aws-c-http >=0.8.10,<0.8.11.0a0 + - aws-c-io >=0.14.19,<0.14.20.0a0 + - aws-c-mqtt >=0.10.7,<0.10.8.0a0 + - aws-c-s3 >=0.6.7,<0.6.8.0a0 - aws-c-sdkutils >=0.1.19,<0.1.20.0a0 - libgcc >=13 - libstdcxx >=13 license: Apache-2.0 license_family: Apache purls: [] - size: 349000 - timestamp: 1725571637583 -- kind: conda - name: aws-crt-cpp - version: 0.28.2 - build: h6f2a9b6_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/aws-crt-cpp-0.28.2-h6f2a9b6_2.conda - sha256: c53e2ab1da628d1e3f16d4bbca6bac07d53d24d32b935005b6f113739992554d - md5: d9e796b86f75254b856cd3791d12e10e + size: 349632 + timestamp: 1729181229435 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-crt-cpp-0.29.7-hd92328a_7.conda + sha256: 094cd81f1e5ba713e9e7a272ee52b5dde3ccc4842ea90f19c0354a00bbdac3d9 + md5: 02b95564257d5c3db9c06beccf711f95 + depends: + - __glibc >=2.17,<3.0.a0 + - aws-c-auth >=0.8.0,<0.8.1.0a0 + - aws-c-cal >=0.8.1,<0.8.2.0a0 + - aws-c-common >=0.10.6,<0.10.7.0a0 + - aws-c-event-stream >=0.5.0,<0.5.1.0a0 + - aws-c-http >=0.9.2,<0.9.3.0a0 + - aws-c-io >=0.15.3,<0.15.4.0a0 + - aws-c-mqtt >=0.11.0,<0.11.1.0a0 + - aws-c-s3 >=0.7.7,<0.7.8.0a0 + - aws-c-sdkutils >=0.2.1,<0.2.2.0a0 + - libgcc >=13 + - libstdcxx >=13 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 354703 + timestamp: 1734177883319 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-crt-cpp-0.28.3-h4f9f7e0_8.conda + sha256: 98cbed635af4841186aa3261e6ceadd03822983d6e30f0afa5d34eb452b2b509 + md5: 14af6354d5437421793e17e865301371 depends: - __osx >=11.0 - - aws-c-auth >=0.7.27,<0.7.28.0a0 + - aws-c-auth >=0.7.31,<0.7.32.0a0 - aws-c-cal >=0.7.4,<0.7.5.0a0 - - aws-c-common >=0.9.27,<0.9.28.0a0 + - aws-c-common >=0.9.29,<0.9.30.0a0 - aws-c-event-stream >=0.4.3,<0.4.4.0a0 - - aws-c-http >=0.8.8,<0.8.9.0a0 - - aws-c-io >=0.14.18,<0.14.19.0a0 - - aws-c-mqtt >=0.10.4,<0.10.5.0a0 - - aws-c-s3 >=0.6.5,<0.6.6.0a0 + - aws-c-http >=0.8.10,<0.8.11.0a0 + - aws-c-io >=0.14.19,<0.14.20.0a0 + - aws-c-mqtt >=0.10.7,<0.10.8.0a0 + - aws-c-s3 >=0.6.7,<0.6.8.0a0 - aws-c-sdkutils >=0.1.19,<0.1.20.0a0 - libcxx >=17 license: Apache-2.0 license_family: Apache purls: [] - size: 229432 - timestamp: 1725571721597 -- kind: conda - name: aws-sdk-cpp - version: 1.11.379 - build: h8d911dc_8 - build_number: 8 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/aws-sdk-cpp-1.11.379-h8d911dc_8.conda - sha256: 0d43c38c7018a3b0b709b5e5cdb9e098aa97fe45de15eb7fe78e836dea0da1f2 - md5: b35b5661373ccbb19a09bcd3230cdc56 + size: 229980 + timestamp: 1729181342157 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-crt-cpp-0.29.7-h19a973c_7.conda + sha256: 8269e6746eb3a5d15b732a3983888bf98dfc1f6594e95250fc8d16b43cfd5ff9 + md5: 95714136bef3e917bd5a2942d4682b20 depends: - __osx >=11.0 - - aws-c-common >=0.9.27,<0.9.28.0a0 + - aws-c-auth >=0.8.0,<0.8.1.0a0 + - aws-c-cal >=0.8.1,<0.8.2.0a0 + - aws-c-common >=0.10.6,<0.10.7.0a0 + - aws-c-event-stream >=0.5.0,<0.5.1.0a0 + - aws-c-http >=0.9.2,<0.9.3.0a0 + - aws-c-io >=0.15.3,<0.15.4.0a0 + - aws-c-mqtt >=0.11.0,<0.11.1.0a0 + - aws-c-s3 >=0.7.7,<0.7.8.0a0 + - aws-c-sdkutils >=0.2.1,<0.2.2.0a0 + - libcxx >=18 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 236249 + timestamp: 1734178020924 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-sdk-cpp-1.11.407-h25d6d5c_1.conda + sha256: f05d43f3204887cec9a9853a9217f06562b28161950b5485aed1f8afe42aad17 + md5: 0f2bd0128d59a45c9fd56151eab0b37e + depends: + - __glibc >=2.17,<3.0.a0 + - aws-c-common >=0.9.29,<0.9.30.0a0 - aws-c-event-stream >=0.4.3,<0.4.4.0a0 - - aws-checksums >=0.1.18,<0.1.19.0a0 - - aws-crt-cpp >=0.28.2,<0.28.3.0a0 - - libcurl >=8.9.1,<9.0a0 - - libcxx >=17 + - aws-checksums >=0.1.20,<0.1.21.0a0 + - aws-crt-cpp >=0.28.3,<0.28.4.0a0 + - libcurl >=8.10.1,<9.0a0 + - libgcc >=13 + - libstdcxx >=13 - libzlib >=1.3.1,<2.0a0 - - openssl >=3.3.1,<4.0a0 + - openssl >=3.3.2,<4.0a0 license: Apache-2.0 license_family: Apache purls: [] - size: 2667053 - timestamp: 1725105168351 -- kind: conda - name: aws-sdk-cpp - version: 1.11.379 - build: hc1bef60_8 - build_number: 8 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/aws-sdk-cpp-1.11.379-hc1bef60_8.conda - sha256: f720d4092b6aecbc22b602038485f5558e000b315a712d57fd34a9bcc98ae6d0 - md5: f52817ff334879e3dbdc7392e8248508 + size: 2931742 + timestamp: 1729235000691 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-sdk-cpp-1.11.458-hc430e4a_4.conda + sha256: 2dc09f6f9c49127b5f96e7535b64a9c521b944d76d8b7d03d48ae80257ac1cea + md5: aeefac461bea1f126653c1285cf5af08 depends: - __glibc >=2.17,<3.0.a0 - - aws-c-common >=0.9.27,<0.9.28.0a0 - - aws-c-event-stream >=0.4.3,<0.4.4.0a0 - - aws-checksums >=0.1.18,<0.1.19.0a0 - - aws-crt-cpp >=0.28.2,<0.28.3.0a0 - - libcurl >=8.9.1,<9.0a0 + - aws-c-common >=0.10.6,<0.10.7.0a0 + - aws-c-event-stream >=0.5.0,<0.5.1.0a0 + - aws-checksums >=0.2.2,<0.2.3.0a0 + - aws-crt-cpp >=0.29.7,<0.29.8.0a0 + - libcurl >=8.11.1,<9.0a0 - libgcc >=13 - libstdcxx >=13 - libzlib >=1.3.1,<2.0a0 - - openssl >=3.3.1,<4.0a0 + - openssl >=3.4.0,<4.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 3060561 + timestamp: 1734093737431 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-sdk-cpp-1.11.407-h880863c_1.conda + sha256: 9cea713c0d727def94e29a99cdfe1deb65c241c90bc41c96e1e77777cb84d4c9 + md5: 60877ad5c76505fa4b90ab5567babb3d + depends: + - __osx >=11.0 + - aws-c-common >=0.9.29,<0.9.30.0a0 + - aws-c-event-stream >=0.4.3,<0.4.4.0a0 + - aws-checksums >=0.1.20,<0.1.21.0a0 + - aws-crt-cpp >=0.28.3,<0.28.4.0a0 + - libcurl >=8.10.1,<9.0a0 + - libcxx >=17 + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.3.2,<4.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 2709553 + timestamp: 1729235667236 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-sdk-cpp-1.11.458-he0ff2e4_4.conda + sha256: 535b970aaa13be45f8cab8205c59f044b17364111c41a227f061775a5c834e18 + md5: 0981ed87098b149bdb7d99a4a3fd0e58 + depends: + - __osx >=11.0 + - aws-c-common >=0.10.6,<0.10.7.0a0 + - aws-c-event-stream >=0.5.0,<0.5.1.0a0 + - aws-checksums >=0.2.2,<0.2.3.0a0 + - aws-crt-cpp >=0.29.7,<0.29.8.0a0 + - libcurl >=8.11.1,<9.0a0 + - libcxx >=18 + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.4.0,<4.0a0 license: Apache-2.0 license_family: Apache purls: [] - size: 2948586 - timestamp: 1725104973916 -- kind: conda - name: azure-core-cpp - version: 1.13.0 - build: h935415a_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/azure-core-cpp-1.13.0-h935415a_0.conda + size: 2826534 + timestamp: 1734094018287 +- conda: https://conda.anaconda.org/conda-forge/linux-64/azure-core-cpp-1.13.0-h935415a_0.conda sha256: b7e0a22295db2e1955f89c69cefc32810309b3af66df986d9fb75d89f98a80f7 md5: debd1677c2fea41eb2233a260f48a298 depends: @@ -3055,12 +3369,21 @@ packages: purls: [] size: 338134 timestamp: 1720853194547 -- kind: conda - name: azure-core-cpp - version: 1.13.0 - build: hd01fc5c_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/azure-core-cpp-1.13.0-hd01fc5c_0.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/azure-core-cpp-1.14.0-h5cfcd09_0.conda + sha256: fe07debdb089a3db17f40a7f20d283d75284bb4fc269ef727b8ba6fc93f7cb5a + md5: 0a8838771cc2e985cd295e01ae83baf1 + depends: + - __glibc >=2.17,<3.0.a0 + - libcurl >=8.10.1,<9.0a0 + - libgcc >=13 + - libstdcxx >=13 + - openssl >=3.3.2,<4.0a0 + license: MIT + license_family: MIT + purls: [] + size: 345117 + timestamp: 1728053909574 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-core-cpp-1.13.0-hd01fc5c_0.conda sha256: aff4af38416cf7a81c79e5a3b071ce5aa13ec48da28db0312bc1ebe62cf7273d md5: 2083f6313e623079db6ee67af00e6b27 depends: @@ -3073,32 +3396,34 @@ packages: purls: [] size: 287922 timestamp: 1720853302106 -- kind: conda - name: azure-identity-cpp - version: 1.8.0 - build: h13ea094_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/azure-identity-cpp-1.8.0-h13ea094_2.conda - sha256: 11b01715cae19390890f29ebb56d36d895feafd787ba929aa10b6ce712f3f4b9 - md5: 383b72f2ee009992b21f4db08a708510 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-core-cpp-1.14.0-hd50102c_0.conda + sha256: f5b91329ed59ffc0be8747784c6e4cc7e56250c54032883a83bc11808ef6a87e + md5: f093a11dcf3cdcca010b20a818fcc6dc depends: - __osx >=11.0 - - azure-core-cpp >=1.13.0,<1.13.1.0a0 - - libcxx >=16 - - openssl >=3.3.1,<4.0a0 + - libcurl >=8.10.1,<9.0a0 + - libcxx >=17 + - openssl >=3.3.2,<4.0a0 license: MIT license_family: MIT purls: [] - size: 142135 - timestamp: 1721777696118 -- kind: conda - name: azure-identity-cpp - version: 1.8.0 - build: hd126650_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/azure-identity-cpp-1.8.0-hd126650_2.conda + size: 294299 + timestamp: 1728054014060 +- conda: https://conda.anaconda.org/conda-forge/linux-64/azure-identity-cpp-1.10.0-h113e628_0.conda + sha256: 286b31616c191486626cb49e9ceb5920d29394b9e913c23adb7eb637629ba4de + md5: 73f73f60854f325a55f1d31459f2ab73 + depends: + - __glibc >=2.17,<3.0.a0 + - azure-core-cpp >=1.14.0,<1.14.1.0a0 + - libgcc >=13 + - libstdcxx >=13 + - openssl >=3.3.2,<4.0a0 + license: MIT + license_family: MIT + purls: [] + size: 232351 + timestamp: 1728486729511 +- conda: https://conda.anaconda.org/conda-forge/linux-64/azure-identity-cpp-1.8.0-hd126650_2.conda sha256: f85452eca3ae0e156b1d1a321a1a9f4f58d44ff45236c0d8602ab96aaad3c6ba md5: 36df3cf05459de5d0a41c77c4329634b depends: @@ -3112,12 +3437,33 @@ packages: purls: [] size: 199516 timestamp: 1721777604325 -- kind: conda - name: azure-storage-blobs-cpp - version: 12.12.0 - build: hd2e3451_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-blobs-cpp-12.12.0-hd2e3451_0.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-identity-cpp-1.10.0-hc602bab_0.conda + sha256: bde446b916fff5150606f8ed3e6058ffc55a3aa72381e46f1ab346590b1ae40a + md5: d7b71593a937459f2d4b67e1a4727dc2 + depends: + - __osx >=11.0 + - azure-core-cpp >=1.14.0,<1.14.1.0a0 + - libcxx >=17 + - openssl >=3.3.2,<4.0a0 + license: MIT + license_family: MIT + purls: [] + size: 166907 + timestamp: 1728486882502 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-identity-cpp-1.8.0-h13ea094_2.conda + sha256: 11b01715cae19390890f29ebb56d36d895feafd787ba929aa10b6ce712f3f4b9 + md5: 383b72f2ee009992b21f4db08a708510 + depends: + - __osx >=11.0 + - azure-core-cpp >=1.13.0,<1.13.1.0a0 + - libcxx >=16 + - openssl >=3.3.1,<4.0a0 + license: MIT + license_family: MIT + purls: [] + size: 142135 + timestamp: 1721777696118 +- conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-blobs-cpp-12.12.0-hd2e3451_0.conda sha256: 69a0f5c2a08a1a40524b343060debb8d92295e2cc5805c3db56dad7a41246a93 md5: 61f1c193452f0daa582f39634627ea33 depends: @@ -3131,12 +3477,21 @@ packages: purls: [] size: 523120 timestamp: 1721865032339 -- kind: conda - name: azure-storage-blobs-cpp - version: 12.12.0 - build: hfde595f_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/azure-storage-blobs-cpp-12.12.0-hfde595f_0.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-blobs-cpp-12.13.0-h3cf044e_1.conda + sha256: 2606260e5379eed255bcdc6adc39b93fb31477337bcd911c121fc43cd29bf394 + md5: 7eb66060455c7a47d9dcdbfa9f46579b + depends: + - __glibc >=2.17,<3.0.a0 + - azure-core-cpp >=1.14.0,<1.14.1.0a0 + - azure-storage-common-cpp >=12.8.0,<12.8.1.0a0 + - libgcc >=13 + - libstdcxx >=13 + license: MIT + license_family: MIT + purls: [] + size: 549342 + timestamp: 1728578123088 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-storage-blobs-cpp-12.12.0-hfde595f_0.conda sha256: f733f4acedd8bf1705c780e0828f0b83242ae7e72963aef60d12a7c5b3a8640d md5: f2c935764fdacd0fafc05f975fd347e0 depends: @@ -3149,13 +3504,20 @@ packages: purls: [] size: 419976 timestamp: 1721865180569 -- kind: conda - name: azure-storage-common-cpp - version: 12.7.0 - build: h10ac4d7_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-common-cpp-12.7.0-h10ac4d7_1.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-storage-blobs-cpp-12.13.0-h7585a09_1.conda + sha256: 08d52d130addc0fb55d5ba10d9fa483e39be25d69bac7f4c676c2c3069207590 + md5: 704238ef05d46144dae2e6b5853df8bc + depends: + - __osx >=11.0 + - azure-core-cpp >=1.14.0,<1.14.1.0a0 + - azure-storage-common-cpp >=12.8.0,<12.8.1.0a0 + - libcxx >=17 + license: MIT + license_family: MIT + purls: [] + size: 438636 + timestamp: 1728578216193 +- conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-common-cpp-12.7.0-h10ac4d7_1.conda sha256: 1030fa54497a73eb78c509d451f25701e2e781dc182e7647f55719f1e1f9bee8 md5: ab6d507ad16dbe2157920451d662e4a1 depends: @@ -3170,13 +3532,22 @@ packages: purls: [] size: 143039 timestamp: 1721832724803 -- kind: conda - name: azure-storage-common-cpp - version: 12.7.0 - build: hcf3b6fd_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/azure-storage-common-cpp-12.7.0-hcf3b6fd_1.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-common-cpp-12.8.0-h736e048_1.conda + sha256: 273475f002b091b66ce7366da04bf164c3732c03f8692ab2ee2d23335b6a82ba + md5: 13de36be8de3ae3f05ba127631599213 + depends: + - __glibc >=2.17,<3.0.a0 + - azure-core-cpp >=1.14.0,<1.14.1.0a0 + - libgcc >=13 + - libstdcxx >=13 + - libxml2 >=2.12.7,<3.0a0 + - openssl >=3.3.2,<4.0a0 + license: MIT + license_family: MIT + purls: [] + size: 149312 + timestamp: 1728563338704 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-storage-common-cpp-12.7.0-hcf3b6fd_1.conda sha256: 3fdf9c0337c48706cffe2e4c761cdea4132fb6dbd1f144d969c28afd903cf256 md5: df7e01bcf8f3a9bfb0ab06778f915f29 depends: @@ -3190,33 +3561,21 @@ packages: purls: [] size: 119821 timestamp: 1721832870493 -- kind: conda - name: azure-storage-files-datalake-cpp - version: 12.11.0 - build: h082e32e_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/azure-storage-files-datalake-cpp-12.11.0-h082e32e_1.conda - sha256: 3c288dc1ae6bff9a1e21ab5196d13ab486850f61ec649a743a87bf9726901abf - md5: 16b05d31f626717668f01c01a970115f +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-storage-common-cpp-12.8.0-h9ca1f76_1.conda + sha256: 77ab04e8fe5636a2de9c718f72a43645f7502cd208868c8a91ffba385547d585 + md5: 7a187cd7b1445afc80253bb186a607cc depends: - __osx >=11.0 - - azure-core-cpp >=1.13.0,<1.13.1.0a0 - - azure-storage-blobs-cpp >=12.12.0,<12.12.1.0a0 - - azure-storage-common-cpp >=12.7.0,<12.7.1.0a0 - - libcxx >=16 + - azure-core-cpp >=1.14.0,<1.14.1.0a0 + - libcxx >=17 + - libxml2 >=2.12.7,<3.0a0 + - openssl >=3.3.2,<4.0a0 license: MIT license_family: MIT purls: [] - size: 189065 - timestamp: 1721925275724 -- kind: conda - name: azure-storage-files-datalake-cpp - version: 12.11.0 - build: h325d260_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-files-datalake-cpp-12.11.0-h325d260_1.conda + size: 121278 + timestamp: 1728563418777 +- conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-files-datalake-cpp-12.11.0-h325d260_1.conda sha256: 1726fa324bb402e52d63227d6cb3f849957cd6841f8cb8aed58bb0c81203befb md5: 11d926d1f4a75a1b03d1c053ca20424b depends: @@ -3231,36 +3590,72 @@ packages: purls: [] size: 274492 timestamp: 1721925100762 -- kind: pypi +- conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-files-datalake-cpp-12.12.0-ha633028_1.conda + sha256: 5371e4f3f920933bb89b926a85a67f24388227419abd6e99f6086481e5e8d5f2 + md5: 7c1980f89dd41b097549782121a73490 + depends: + - __glibc >=2.17,<3.0.a0 + - azure-core-cpp >=1.14.0,<1.14.1.0a0 + - azure-storage-blobs-cpp >=12.13.0,<12.13.1.0a0 + - azure-storage-common-cpp >=12.8.0,<12.8.1.0a0 + - libgcc >=13 + - libstdcxx >=13 + license: MIT + license_family: MIT + purls: [] + size: 287366 + timestamp: 1728729530295 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-storage-files-datalake-cpp-12.11.0-h082e32e_1.conda + sha256: 3c288dc1ae6bff9a1e21ab5196d13ab486850f61ec649a743a87bf9726901abf + md5: 16b05d31f626717668f01c01a970115f + depends: + - __osx >=11.0 + - azure-core-cpp >=1.13.0,<1.13.1.0a0 + - azure-storage-blobs-cpp >=12.12.0,<12.12.1.0a0 + - azure-storage-common-cpp >=12.7.0,<12.7.1.0a0 + - libcxx >=16 + license: MIT + license_family: MIT + purls: [] + size: 189065 + timestamp: 1721925275724 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/azure-storage-files-datalake-cpp-12.12.0-hcdd55da_1.conda + sha256: f48523f8aa0b5b80f45a92f0556b388dd96f44ac2dc2f44a01d08c1822eec97d + md5: c49fbc5233fcbaa86391162ff1adef38 + depends: + - __osx >=11.0 + - azure-core-cpp >=1.14.0,<1.14.1.0a0 + - azure-storage-blobs-cpp >=12.13.0,<12.13.1.0a0 + - azure-storage-common-cpp >=12.8.0,<12.8.1.0a0 + - libcxx >=17 + license: MIT + license_family: MIT + purls: [] + size: 196032 + timestamp: 1728729672889 +- pypi: . name: b3d version: 0.0.1 - path: . - sha256: 8205454982d4050f9f463be94c7abc6e9ee2f988144faedf294ad2b03532317d + sha256: 430ea485d74fcc03dd65a5f60bc11e13e178cde71b4e3281e9d59f1611ed0b2e + requires_dist: + - python-fcl>=0.7.0.6,<0.8 ; extra == 'core' requires_python: '>=3.10' editable: true -- kind: conda - name: babel - version: 2.14.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/babel-2.14.0-pyhd8ed1ab_0.conda - sha256: 8584e3da58e92b72641c89ff9b98c51f0d5dbe76e527867804cbdf03ac91d8e6 - md5: 9669586875baeced8fc30c0826c3270e +- conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.16.0-pyhd8ed1ab_1.conda + sha256: f6205d3a62e87447e06e98d911559be0208d824976d77ab092796c9176611fcb + md5: 3e23f7db93ec14c80525257d8affac28 depends: - - python >=3.7 - - pytz - - setuptools + - python >=3.9 + - pytz >=2015.7 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/babel?source=project-defined-mapping - size: 7609750 - timestamp: 1702422720584 -- kind: pypi + size: 6551057 + timestamp: 1733236466015 +- pypi: https://files.pythonhosted.org/packages/64/43/7a1259741bd989723272ac7d381a43be932422abcff09a1d9f7ba212cb74/beartype-0.18.5-py3-none-any.whl name: beartype version: 0.18.5 - url: https://files.pythonhosted.org/packages/64/43/7a1259741bd989723272ac7d381a43be932422abcff09a1d9f7ba212cb74/beartype-0.18.5-py3-none-any.whl sha256: 5301a14f2a9a5540fe47ec6d34d758e9cd8331d36c4760fc7a5499ab86310089 requires_dist: - typing-extensions>=3.10.0.0 ; extra == 'all' @@ -3270,14 +3665,14 @@ packages: - typing-extensions>=3.10.0.0 ; extra == 'dev' - pytest>=4.0.0 ; extra == 'dev' - tox>=3.20.1 ; extra == 'dev' - - sphinx<6.0.0,>=4.2.0 ; extra == 'dev' + - sphinx>=4.2.0,<6.0.0 ; extra == 'dev' - pydata-sphinx-theme<=0.7.2 ; extra == 'dev' - autoapi>=0.9.0 ; extra == 'dev' - sphinxext-opengraph>=0.7.5 ; extra == 'dev' - mypy>=0.800 ; platform_python_implementation != 'PyPy' and extra == 'dev' - sphinx ; python_full_version >= '3.8' and extra == 'dev' - numpy ; platform_python_implementation != 'PyPy' and sys_platform != 'darwin' and extra == 'dev' - - sphinx<6.0.0,>=4.2.0 ; extra == 'doc-rtd' + - sphinx>=4.2.0,<6.0.0 ; extra == 'doc-rtd' - pydata-sphinx-theme<=0.7.2 ; extra == 'doc-rtd' - autoapi>=0.9.0 ; extra == 'doc-rtd' - sphinxext-opengraph>=0.7.5 ; extra == 'doc-rtd' @@ -3290,101 +3685,88 @@ packages: - sphinx ; python_full_version >= '3.8' and extra == 'test-tox' - numpy ; platform_python_implementation != 'PyPy' and sys_platform != 'darwin' and extra == 'test-tox' requires_python: '>=3.8.0' -- kind: conda - name: beautifulsoup4 - version: 4.12.3 - build: pyha770c72_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/beautifulsoup4-4.12.3-pyha770c72_0.conda - sha256: 7b05b2d0669029326c623b9df7a29fa49d1982a9e7e31b2fea34b4c9a4a72317 - md5: 332493000404d8411859539a5a630865 +- conda: https://conda.anaconda.org/conda-forge/noarch/beautifulsoup4-4.12.3-pyha770c72_1.conda + sha256: fca842ab7be052eea1037ebee17ac25cc79c626382dd2187b5c6e007b9d9f65f + md5: d48f7e9fdec44baf6d1da416fe402b04 depends: - - python >=3.6 + - python >=3.9 - soupsieve >=1.2 license: MIT license_family: MIT purls: - pkg:pypi/beautifulsoup4?source=project-defined-mapping - size: 118200 - timestamp: 1705564819537 -- kind: conda - name: binutils - version: '2.40' - build: h4852527_7 - build_number: 7 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.40-h4852527_7.conda - sha256: 75d7f5cda999fe1efe9f1de1be2d3e4ce32b20cbf97d1ef7b770e2e90c062858 - md5: df53aa8418f8c289ae9b9665986034f8 - depends: - - binutils_impl_linux-64 >=2.40,<2.41.0a0 + size: 118042 + timestamp: 1733230951790 +- conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.43-h4852527_2.conda + sha256: 92be0f8ccd501ceeb3c782e2182e6ea04dca46799038176de40a57bca45512c5 + md5: 348619f90eee04901f4a70615efff35b + depends: + - binutils_impl_linux-64 >=2.43,<2.44.0a0 license: GPL-3.0-only license_family: GPL purls: [] - size: 31696 - timestamp: 1718625692046 -- kind: conda - name: binutils_impl_linux-64 - version: '2.40' - build: ha1999f0_7 - build_number: 7 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.40-ha1999f0_7.conda - sha256: 230f3136d17fdcf0e6da3a3ae59118570bc18106d79dd29bf2f341338d2a42c4 - md5: 3f840c7ed70a96b5ebde8044b2f36f32 - depends: - - ld_impl_linux-64 2.40 hf3520f5_7 + size: 33876 + timestamp: 1729655402186 +- conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.43-h4bf12b8_2.conda + sha256: 267e78990247369b13234bda270f31beb56a600b4851a8244e31dd9ad85b3b17 + md5: cf0c5521ac2a20dfa6c662a4009eeef6 + depends: + - ld_impl_linux-64 2.43 h712a8e2_2 - sysroot_linux-64 license: GPL-3.0-only license_family: GPL purls: [] - size: 6250821 - timestamp: 1718625666382 -- kind: conda - name: binutils_linux-64 - version: '2.40' - build: hb3c18ed_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.40-hb3c18ed_2.conda - sha256: cd45bfcc9baaf3e38a753dabe3bbb9d7c3fb7c0cc18d919130687e4cbb39c9ac - md5: e8255f2cf0772d7cde80d40c26028f53 + size: 5682777 + timestamp: 1729655371045 +- conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.43-h4852527_2.conda + sha256: df52bd8b8b2a20a0c529d9ad08aaf66093ac318aa8a33d270f18274341a77062 + md5: 18aba879ddf1f8f28145ca6fcb873d8c depends: - - binutils_impl_linux-64 2.40.* - - sysroot_linux-64 - license: BSD-3-Clause + - binutils_impl_linux-64 2.43 h4bf12b8_2 + license: GPL-3.0-only + license_family: GPL purls: [] - size: 29699 - timestamp: 1725663716797 -- kind: conda - name: bleach - version: 6.1.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/bleach-6.1.0-pyhd8ed1ab_0.conda - sha256: 845e77ef495376c5c3c328ccfd746ca0ef1978150cae8eae61a300fe7755fb08 - md5: 0ed9d7c0e9afa7c025807a9a8136ea3e + size: 34945 + timestamp: 1729655404893 +- conda: https://conda.anaconda.org/conda-forge/noarch/bleach-6.2.0-pyhd8ed1ab_1.conda + sha256: ffc8e4e53cd92aec0f0ea0bc9e28f5fd1b1e67bde46b0b298170e6fb78eecce1 + md5: 707af59db75b066217403a8f00c1d826 depends: - - packaging - - python >=3.6 - - setuptools - - six >=1.9.0 + - python >=3.9 - webencodings - license: Apache-2.0 + license: Apache-2.0 AND MIT license_family: Apache purls: - pkg:pypi/bleach?source=project-defined-mapping - size: 131220 - timestamp: 1696630354218 -- kind: conda - name: brotli - version: 1.1.0 - build: hb9d3cd8_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/brotli-1.1.0-hb9d3cd8_2.conda + size: 132933 + timestamp: 1733302409510 +- conda: https://conda.anaconda.org/conda-forge/noarch/blinker-1.9.0-pyhff2d567_0.conda + sha256: f7efd22b5c15b400ed84a996d777b6327e5c402e79e3c534a7e086236f1eb2dc + md5: 42834439227a4551b939beeeb8a4b085 + depends: + - python >=3.9 + license: MIT + license_family: MIT + purls: + - pkg:pypi/blinker?source=project-defined-mapping + size: 13934 + timestamp: 1731096548765 +- conda: https://conda.anaconda.org/conda-forge/linux-64/blosc-1.21.6-hef167b5_0.conda + sha256: 6cc260f9c6d32c5e728a2099a52fdd7ee69a782fff7b400d0606fcd32e0f5fd1 + md5: 54fe76ab3d0189acaef95156874db7f9 + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - libzlib >=1.3.1,<2.0a0 + - lz4-c >=1.9.3,<1.10.0a0 + - snappy >=1.2.0,<1.3.0a0 + - zstd >=1.5.6,<1.6.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 48842 + timestamp: 1719266029046 +- conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-1.1.0-hb9d3cd8_2.conda sha256: fcb0b5b28ba7492093e54f3184435144e074dfceab27ac8e6a9457e736565b0b md5: 98514fe74548d768907ce7a13f680e8f depends: @@ -3398,13 +3780,7 @@ packages: purls: [] size: 19264 timestamp: 1725267697072 -- kind: conda - name: brotli - version: 1.1.0 - build: hd74edd7_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-1.1.0-hd74edd7_2.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-1.1.0-hd74edd7_2.conda sha256: a086f36ff68d6e30da625e910547f6211385246fb2474b144ac8c47c32254576 md5: 215e3dc8f2f837906d066e7f01aa77c0 depends: @@ -3417,13 +3793,7 @@ packages: purls: [] size: 19588 timestamp: 1725268044856 -- kind: conda - name: brotli-bin - version: 1.1.0 - build: hb9d3cd8_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/brotli-bin-1.1.0-hb9d3cd8_2.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-bin-1.1.0-hb9d3cd8_2.conda sha256: 261364d7445513b9a4debc345650fad13c627029bfc800655a266bf1e375bc65 md5: c63b5e52939e795ba8d26e35d767a843 depends: @@ -3436,13 +3806,7 @@ packages: purls: [] size: 18881 timestamp: 1725267688731 -- kind: conda - name: brotli-bin - version: 1.1.0 - build: hd74edd7_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-bin-1.1.0-hd74edd7_2.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-bin-1.1.0-hd74edd7_2.conda sha256: 28f1af63b49fddf58084fb94e5512ad46e9c453eb4be1d97449c67059e5b0680 md5: b8512db2145dc3ae8d86cdc21a8d421e depends: @@ -3454,13 +3818,7 @@ packages: purls: [] size: 16772 timestamp: 1725268026061 -- kind: conda - name: brotli-python - version: 1.1.0 - build: py312h2ec8cdc_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/brotli-python-1.1.0-py312h2ec8cdc_2.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-python-1.1.0-py312h2ec8cdc_2.conda sha256: f2a59ccd20b4816dea9a2a5cb917eb69728271dbf1aeab4e1b7e609330a50b6f md5: b0b867af6fc74b2a0aa206da29c0f3cf depends: @@ -3477,13 +3835,7 @@ packages: - pkg:pypi/brotli?source=project-defined-mapping size: 349867 timestamp: 1725267732089 -- kind: conda - name: brotli-python - version: 1.1.0 - build: py312hde4cb15_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-python-1.1.0-py312hde4cb15_2.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-python-1.1.0-py312hde4cb15_2.conda sha256: 254b411fa78ccc226f42daf606772972466f93e9bc6895eabb4cfda22f5178af md5: a83c2ef76ccb11bc2349f4f17696b15d depends: @@ -3500,13 +3852,7 @@ packages: - pkg:pypi/brotli?source=project-defined-mapping size: 339360 timestamp: 1725268143995 -- kind: conda - name: bzip2 - version: 1.0.8 - build: h4bc722e_7 - build_number: 7 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-h4bc722e_7.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-h4bc722e_7.conda sha256: 5ced96500d945fb286c9c838e54fa759aa04a7129c59800f0846b4335cee770d md5: 62ee74e96c5ebb0af99386de58cf9553 depends: @@ -3517,13 +3863,7 @@ packages: purls: [] size: 252783 timestamp: 1720974456583 -- kind: conda - name: bzip2 - version: 1.0.8 - build: h99b78c6_7 - build_number: 7 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h99b78c6_7.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h99b78c6_7.conda sha256: adfa71f158cbd872a36394c56c3568e6034aa55c623634b37a4836bd036e6b91 md5: fc6948412dbbbe9a4c9ddbbcfe0a79ab depends: @@ -3533,44 +3873,28 @@ packages: purls: [] size: 122909 timestamp: 1720974522888 -- kind: conda - name: c-ares - version: 1.33.1 - build: hd74edd7_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.33.1-hd74edd7_0.conda - sha256: ad29a9cffa0504cb4bf7605963816feff3c7833f36b050e1e71912d09c38e3f6 - md5: 5b69c16ee900aeffcf0103268d708518 +- conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.4-hb9d3cd8_0.conda + sha256: d4f28d87b6339b94f74762c0076e29c8ef8ddfff51a564a92da2843573c18320 + md5: e2775acf57efd5af15b8e3d1d74d72d3 depends: - - __osx >=11.0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 license: MIT license_family: MIT purls: [] - size: 159389 - timestamp: 1724438175204 -- kind: conda - name: c-ares - version: 1.33.1 - build: heb4867d_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.33.1-heb4867d_0.conda - sha256: 2cb24f613eaf2850b1a08f28f967b10d8bd44ef623efa0154dc45eb718776be6 - md5: 0d3c60291342c0c025db231353376dfb + size: 206085 + timestamp: 1734208189009 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.4-h5505292_0.conda + sha256: 09c0c8476e50b2955f474a4a1c17c4c047dd52993b5366b6ea8e968e583b921f + md5: c1c999a38a4303b29d75c636eaa13cf9 depends: - - __glibc >=2.28,<3.0.a0 - - libgcc-ng >=13 + - __osx >=11.0 license: MIT license_family: MIT purls: [] - size: 182796 - timestamp: 1724438109690 -- kind: conda - name: c-compiler - version: 1.7.0 - build: hd590300_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.7.0-hd590300_1.conda + size: 179496 + timestamp: 1734208291879 +- conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.7.0-hd590300_1.conda sha256: 4213b6cbaed673c07f8b79c089f3487afdd56de944f21c4861ead862b7657eb4 md5: e9dffe1056994133616378309f932d77 depends: @@ -3582,38 +3906,22 @@ packages: purls: [] size: 6324 timestamp: 1714575511013 -- kind: conda - name: ca-certificates - version: 2024.8.30 - build: hbcca054_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/ca-certificates-2024.8.30-hbcca054_0.conda - sha256: afee721baa6d988e27fef1832f68d6f32ac8cc99cdf6015732224c2841a09cea - md5: c27d1c142233b5bc9ca570c6e2e0c244 +- conda: https://conda.anaconda.org/conda-forge/linux-64/ca-certificates-2024.12.14-hbcca054_0.conda + sha256: 1afd7274cbc9a334d6d0bc62fa760acc7afdaceb0b91a8df370ec01fd75dc7dd + md5: 720523eb0d6a9b0f6120c16b2aa4e7de license: ISC purls: [] - size: 159003 - timestamp: 1725018903918 -- kind: conda - name: ca-certificates - version: 2024.8.30 - build: hf0a4a13_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/ca-certificates-2024.8.30-hf0a4a13_0.conda - sha256: 2db1733f4b644575dbbdd7994a8f338e6ef937f5ebdb74acd557e9dda0211709 - md5: 40dec13fd8348dbe303e57be74bd3d35 + size: 157088 + timestamp: 1734208393264 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ca-certificates-2024.12.14-hf0a4a13_0.conda + sha256: 256be633fd0882ccc1a7a32bc278547e1703f85082c0789a87a603ee3ab8fb82 + md5: 7cb381a6783d91902638e4ed1ebd478e license: ISC purls: [] - size: 158482 - timestamp: 1725019034582 -- kind: conda - name: cached-property - version: 1.5.2 - build: hd8ed1ab_1 - build_number: 1 - subdir: noarch + size: 157091 + timestamp: 1734208344343 +- conda: https://conda.anaconda.org/conda-forge/noarch/cached-property-1.5.2-hd8ed1ab_1.tar.bz2 noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/cached-property-1.5.2-hd8ed1ab_1.tar.bz2 sha256: 561e6660f26c35d137ee150187d89767c988413c978e1b712d53f27ddf70ea17 md5: 9b347a7ec10940d3f7941ff6c460b551 depends: @@ -3624,14 +3932,7 @@ packages: - pkg:pypi/cached-property?source=project-defined-mapping size: 4134 timestamp: 1615209571450 -- kind: conda - name: cached_property - version: 1.5.2 - build: pyha770c72_1 - build_number: 1 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/cached_property-1.5.2-pyha770c72_1.tar.bz2 +- conda: https://conda.anaconda.org/conda-forge/noarch/cached_property-1.5.2-pyha770c72_1.tar.bz2 sha256: 6dbf7a5070cc43d90a1e4c2ec0c541c69d8e30a0e25f50ce9f6e4a432e42c5d7 md5: 576d629e47797577ab0f1b351297ef4a depends: @@ -3642,67 +3943,79 @@ packages: - pkg:pypi/cached-property?source=project-defined-mapping size: 11065 timestamp: 1615209567874 -- kind: conda - name: cairo - version: 1.18.0 - build: hb4a6bf7_3 - build_number: 3 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/cairo-1.18.0-hb4a6bf7_3.conda - sha256: f7603b7f6ee7c6e07c23d77302420194f4ec1b8e8facfff2b6aab17c7988a102 - md5: 08bd0752f3de8a2d8a35fd012f09531f +- conda: https://conda.anaconda.org/conda-forge/linux-64/cairo-1.18.0-h3faef2a_0.conda + sha256: 142e2639a5bc0e99c44d76f4cc8dce9c6a2d87330c4beeabb128832cd871a86e + md5: f907bb958910dc404647326ca80c263e depends: - - __osx >=11.0 - fontconfig >=2.14.2,<3.0a0 - fonts-conda-ecosystem - freetype >=2.12.1,<3.0a0 - - icu >=75.1,<76.0a0 - - libcxx >=16 - - libglib >=2.80.3,<3.0a0 - - libpng >=1.6.43,<1.7.0a0 - - libzlib >=1.3.1,<2.0a0 - - pixman >=0.43.4,<1.0a0 + - icu >=73.2,<74.0a0 + - libgcc-ng >=12 + - libglib >=2.78.0,<3.0a0 + - libpng >=1.6.39,<1.7.0a0 + - libstdcxx-ng >=12 + - libxcb >=1.15,<1.16.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - pixman >=0.42.2,<1.0a0 + - xorg-libice >=1.1.1,<2.0a0 + - xorg-libsm >=1.2.4,<2.0a0 + - xorg-libx11 >=1.8.6,<2.0a0 + - xorg-libxext >=1.3.4,<2.0a0 + - xorg-libxrender >=0.9.11,<0.10.0a0 - zlib license: LGPL-2.1-only or MPL-1.1 purls: [] - size: 899126 - timestamp: 1721139203735 -- kind: conda - name: cairo - version: 1.18.0 - build: hebfffa5_3 - build_number: 3 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cairo-1.18.0-hebfffa5_3.conda - sha256: aee5b9e6ef71cdfb2aee9beae3ea91910ca761c01c0ef32052e3f94a252fa173 - md5: fceaedf1cdbcb02df9699a0d9b005292 + size: 982351 + timestamp: 1697028423052 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cairo-1.18.2-h3394656_1.conda + sha256: de7d0d094e53decc005cb13e527be2635b8f604978da497d4c0d282c7dc08385 + md5: b34c2833a1f56db610aeb27f206d800d depends: - __glibc >=2.17,<3.0.a0 - - fontconfig >=2.14.2,<3.0a0 + - fontconfig >=2.15.0,<3.0a0 - fonts-conda-ecosystem - freetype >=2.12.1,<3.0a0 - icu >=75.1,<76.0a0 - - libgcc-ng >=12 - - libglib >=2.80.3,<3.0a0 - - libpng >=1.6.43,<1.7.0a0 - - libstdcxx-ng >=12 - - libxcb >=1.16,<1.17.0a0 + - libexpat >=2.6.4,<3.0a0 + - libgcc >=13 + - libglib >=2.82.2,<3.0a0 + - libpng >=1.6.44,<1.7.0a0 + - libstdcxx >=13 + - libxcb >=1.17.0,<2.0a0 - libzlib >=1.3.1,<2.0a0 - - pixman >=0.43.2,<1.0a0 + - pixman >=0.44.2,<1.0a0 - xorg-libice >=1.1.1,<2.0a0 - xorg-libsm >=1.2.4,<2.0a0 - - xorg-libx11 >=1.8.9,<2.0a0 - - xorg-libxext >=1.3.4,<2.0a0 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 - xorg-libxrender >=0.9.11,<0.10.0a0 - - zlib license: LGPL-2.1-only or MPL-1.1 purls: [] - size: 983604 - timestamp: 1721138900054 -- kind: pypi + size: 978868 + timestamp: 1733790976384 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/cairo-1.18.2-h6a3b0d2_1.conda + sha256: 9a28344e806b89c87fda0cdabd2fb961e5d2ff97107dba25bac9f5dc57220cc3 + md5: 8e3666c3f6e2c3e57aa261ab103a3600 + depends: + - __osx >=11.0 + - fontconfig >=2.15.0,<3.0a0 + - fonts-conda-ecosystem + - freetype >=2.12.1,<3.0a0 + - icu >=75.1,<76.0a0 + - libcxx >=18 + - libexpat >=2.6.4,<3.0a0 + - libglib >=2.82.2,<3.0a0 + - libpng >=1.6.44,<1.7.0a0 + - libzlib >=1.3.1,<2.0a0 + - pixman >=0.44.2,<1.0a0 + license: LGPL-2.1-only or MPL-1.1 + purls: [] + size: 894517 + timestamp: 1733791145035 +- pypi: https://files.pythonhosted.org/packages/49/f5/f4bfff55de6ca82445584eead7fc22f29f3d2bd66a76b8cf4c8c4feb2f32/carvekit-4.1.2-py3-none-any.whl name: carvekit version: 4.1.2 - url: https://files.pythonhosted.org/packages/49/f5/f4bfff55de6ca82445584eead7fc22f29f3d2bd66a76b8cf4c8c4feb2f32/carvekit-4.1.2-py3-none-any.whl sha256: 02cf1dc711bf49095f18f4f7bbf0ee9afccf4b0e01f4919eba223472a18e6e7d requires_dist: - requests>=2.31.0 @@ -3722,28 +4035,24 @@ packages: - aiofiles>=23.2.1 - python-multipart>=0.0.9 requires_python: '>=3.8' -- kind: conda - name: certifi - version: 2024.8.30 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/certifi-2024.8.30-pyhd8ed1ab_0.conda - sha256: 7020770df338c45ac6b560185956c32f0a5abf4b76179c037f115fc7d687819f - md5: 12f7d00853807b0531775e9be891cb11 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cccl-2.4.0-h7ab4013_0.conda + sha256: 4905e187cff74eea6850debc0bc56ef48c0cd06dd5b853bfd9df6b8018f52d76 + md5: d974280864e984929ea44bd982498da6 + license: Apache-2.0 AND BSD-3-Clause AND BSD-2-Clause AND BSL-1.0 AND NCSA AND MIT AND LicenseRef-NVIDIA-Software-License + purls: [] + size: 1346957 + timestamp: 1716324764578 +- conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2024.12.14-pyhd8ed1ab_0.conda + sha256: 048c16a9cbcb1fbad02083414d3bc7c1d0eea4b39aee6aa6bf8d1d5089ca8bad + md5: 6feb87357ecd66733be3279f16a8c400 depends: - - python >=3.7 + - python >=3.9 license: ISC purls: - pkg:pypi/certifi?source=project-defined-mapping - size: 163752 - timestamp: 1725278204397 -- kind: conda - name: cffi - version: 1.17.1 - build: py312h06ac9bb_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cffi-1.17.1-py312h06ac9bb_0.conda + size: 161642 + timestamp: 1734380604767 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cffi-1.17.1-py312h06ac9bb_0.conda sha256: cba6ea83c4b0b4f5b5dc59cb19830519b28f95d7ebef7c9c5cf1c14843621457 md5: a861504bbea4161a9170b85d4d2be840 depends: @@ -3754,16 +4063,12 @@ packages: - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 license: MIT + license_family: MIT purls: - pkg:pypi/cffi?source=project-defined-mapping size: 294403 timestamp: 1725560714366 -- kind: conda - name: cffi - version: 1.17.1 - build: py312h0fad829_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/cffi-1.17.1-py312h0fad829_0.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/cffi-1.17.1-py312h0fad829_0.conda sha256: 8d91a0d01358b5c3f20297c6c536c5d24ccd3e0c2ddd37f9d0593d0f0070226f md5: 19a5456f72f505881ba493979777b24e depends: @@ -3774,959 +4079,713 @@ packages: - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 license: MIT + license_family: MIT purls: - pkg:pypi/cffi?source=project-defined-mapping size: 281206 timestamp: 1725560813378 -- kind: conda - name: charset-normalizer - version: 3.3.2 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.3.2-pyhd8ed1ab_0.conda - sha256: 20cae47d31fdd58d99c4d2e65fbdcefa0b0de0c84e455ba9d6356a4bdbc4b5b9 - md5: 7f4a9e3fcff3f6356ae99244a014da6a +- conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.0-pyhd8ed1ab_1.conda + sha256: 63022ee2c6a157a9f980250a66f54bdcdf5abee817348d0f9a74c2441a6fbf0e + md5: 6581a17bba6b948bb60130026404a9d6 depends: - - python >=3.7 + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/charset-normalizer?source=project-defined-mapping - size: 46597 - timestamp: 1698833765762 -- kind: conda - name: chex - version: 0.1.86 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/chex-0.1.86-pyhd8ed1ab_0.conda - sha256: a95341e3131c7d9ad06188e0b5b8da3aa63214689bad5c7a0685c21800dacf26 - md5: a07f390c9f7e17295521faf5385e136f + size: 47533 + timestamp: 1733218182393 +- conda: https://conda.anaconda.org/conda-forge/noarch/chex-0.1.88-pyhd8ed1ab_1.conda + sha256: 768195125a4a65d0379fc5a2a8353b5f6e824a3a6901b54470f1bdafbe3c59ee + md5: a17935da351549d046aebab3720b11e5 depends: - absl-py >=0.9.0 - - jax >=0.4.16 - - jaxlib >=0.1.37 + - jax >=0.4.27 + - jaxlib >=0.4.27 - numpy >=1.24.1 - python >=3.9 - toolz >=0.9.0 - typing-extensions >=4.2.0 + - typing_extensions >=4.2.0 license: Apache-2.0 license_family: APACHE purls: - pkg:pypi/chex?source=project-defined-mapping - size: 77788 - timestamp: 1710851026888 -- kind: pypi + size: 79292 + timestamp: 1734075256104 +- pypi: https://files.pythonhosted.org/packages/00/2e/d53fa4befbf2cfa713304affc7ca780ce4fc1fd8710527771b58311a3229/click-8.1.7-py3-none-any.whl name: click version: 8.1.7 - url: https://files.pythonhosted.org/packages/00/2e/d53fa4befbf2cfa713304affc7ca780ce4fc1fd8710527771b58311a3229/click-8.1.7-py3-none-any.whl sha256: ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28 requires_dist: - colorama ; platform_system == 'Windows' - importlib-metadata ; python_full_version < '3.8' requires_python: '>=3.7' -- kind: pypi +- conda: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-unix_pyh707e725_1.conda + sha256: 1cd5fc6ccdd5141378e51252a7a3810b07fd5a7e6934a5b4a7eccba66566224b + md5: cb8e52f28f5e592598190c562e7b5bf1 + depends: + - __unix + - python >=3.9 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/click?source=project-defined-mapping + size: 84513 + timestamp: 1733221925078 +- pypi: https://files.pythonhosted.org/packages/48/41/e1d85ca3cab0b674e277c8c4f678cf66a91cd2cecf93df94353a606fe0db/cloudpickle-3.1.0-py3-none-any.whl name: cloudpickle - version: 3.0.0 - url: https://files.pythonhosted.org/packages/96/43/dae06432d0c4b1dc9e9149ad37b4ca8384cf6eb7700cd9215b177b914f0a/cloudpickle-3.0.0-py3-none-any.whl - sha256: 246ee7d0c295602a036e86369c77fecda4ab17b506496730f2f576d9016fd9c7 + version: 3.1.0 + sha256: fe11acda67f61aaaec473e3afe030feb131d78a43461b718185363384f1ba12e requires_python: '>=3.8' -- kind: conda - name: colorama - version: 0.4.6 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 - sha256: 2c1b2e9755ce3102bca8d69e8f26e4f087ece73f50418186aee7c74bef8e1698 - md5: 3faab06a954c2a04039983f2c4a50d99 +- conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda + sha256: ab29d57dc70786c1269633ba3dff20288b81664d3ff8d21af995742e2bb03287 + md5: 962b9857ee8e7018c22f2776ffa0b2d7 depends: - - python >=3.7 + - python >=3.9 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/colorama?source=project-defined-mapping - size: 25170 - timestamp: 1666700778190 -- kind: conda - name: comm - version: 0.2.2 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/comm-0.2.2-pyhd8ed1ab_0.conda - sha256: e923acf02708a8a0b591f3bce4bdc11c8e63b73198b99b35fe6cd96bfb6a0dbe - md5: 948d84721b578d426294e17a02e24cbb + size: 27011 + timestamp: 1733218222191 +- conda: https://conda.anaconda.org/conda-forge/noarch/comm-0.2.2-pyhd8ed1ab_1.conda + sha256: 7e87ef7c91574d9fac19faedaaee328a70f718c9b4ddadfdc0ba9ac021bd64af + md5: 74673132601ec2b7fc592755605f4c1b depends: - - python >=3.6 + - python >=3.9 - traitlets >=5.3 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/comm?source=project-defined-mapping - size: 12134 - timestamp: 1710320435158 -- kind: conda - name: contourpy - version: 1.3.0 - build: py312h6142ec9_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/contourpy-1.3.0-py312h6142ec9_1.conda - sha256: 74bec4e0536c178c52832db030bc050eed5b9a86e6448ed4dc8eb8db4ceddabe - md5: 241dbb81597bd5da8e36f624dad1ece1 + size: 12103 + timestamp: 1733503053903 +- conda: https://conda.anaconda.org/conda-forge/linux-64/contourpy-1.3.1-py312h68727a3_0.conda + sha256: e977af50b844b5b8cfec358131a4e923f0aa718e8334321cf8d84f5093576259 + md5: f5fbba0394ee45e9a64a73c2a994126a depends: - - __osx >=11.0 - - libcxx >=17 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 - numpy >=1.23 - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/contourpy?source=project-defined-mapping - size: 246729 - timestamp: 1725378844777 -- kind: conda - name: contourpy - version: 1.3.0 - build: py312h68727a3_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/contourpy-1.3.0-py312h68727a3_1.conda - sha256: e459bc2d05fabfffcf9bf1f3725e36a5ef64ae7f0b5af312eeaed2e0519e22c8 - md5: 6b9f9141c247bdd61a2d6d37e0a8b530 + size: 276332 + timestamp: 1731428454756 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/contourpy-1.3.1-py312hb23fbb9_0.conda + sha256: fa1f8505f45eac22f25c48cd46809da0d26bcb028c37517b3474bacddd029b0a + md5: f4408290387836e05ac267cd7ec80c5c depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=13 - - libstdcxx >=13 + - __osx >=11.0 + - libcxx >=18 - numpy >=1.23 - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/contourpy?source=project-defined-mapping - size: 272322 - timestamp: 1725378526351 -- kind: conda - name: cuda-cccl_linux-64 - version: 12.6.37 - build: ha770c72_0 - subdir: noarch + size: 245638 + timestamp: 1731428781337 +- conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.12.8-py312hd8ed1ab_1.conda noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-64-12.6.37-ha770c72_0.conda - sha256: a53b89a708375193d0f22c7166278bb6f289ac992c7c9b460019d963ab612bcb - md5: 891091c29d53f1ecc1dd19a53f2581ac + sha256: 05413d84485086301e5bd7c03fca2caae91f75474d99d9fc815cec912332452b + md5: caa04d37126e82822468d6bdf50f5ebd + depends: + - python 3.12.8.* + - python_abi * *_cp312 + license: Python-2.0 + purls: [] + size: 44751 + timestamp: 1733407917248 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cccl-12.5.39-ha770c72_0.conda + sha256: 1ab865226ac14548b48aad6d75c265de791f9f69442f9157b291f0370fe1bfdb + md5: b3c9ebdf02fb0ce96437c9908672a656 depends: - - cuda-version >=12.6,<12.7.0a0 + - cccl 2.4.0 + - cuda-cccl_linux-64 12.5.39 + - cuda-version >=12.5,<12.6.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 1072391 - timestamp: 1722608389859 -- kind: conda - name: cuda-command-line-tools - version: 12.6.1 - build: ha770c72_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-command-line-tools-12.6.1-ha770c72_0.conda - sha256: 51a1a3ad36b97a0daf4cc43d6510c82363b8e0470f8bb951cee9895402239d68 - md5: 06d99bb04930f118f345df3ad5fc5a36 - depends: - - cuda-cupti-dev 12.6.68.* - - cuda-gdb 12.6.68.* - - cuda-nvdisasm 12.6.68.* - - cuda-nvprof 12.6.68.* - - cuda-nvtx 12.6.68.* - - cuda-sanitizer-api 12.6.68.* + size: 21418 + timestamp: 1716328299353 +- conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-64-12.5.39-ha770c72_0.conda + sha256: c3a6421fbe529db62ba2db38ec05944996f570117a0307b270d37aec9b4eddff + md5: 1196ad96550a485d6c988d84839e93db + depends: + - cuda-version >=12.5,<12.6.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 19964 - timestamp: 1725023576979 -- kind: conda - name: cuda-compiler - version: 12.6.1 - build: hbad6d8a_0 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/cuda-compiler-12.6.1-hbad6d8a_0.conda - sha256: 526810e8a91e11191dbd770335c287b55015c91778585a84de5a5348b4a7a7d6 - md5: c1d140cee1339a1e95e3a1dcbb3addab + size: 1354110 + timestamp: 1716328285059 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-command-line-tools-12.5.0-ha770c72_0.conda + sha256: fd6c964bb031d2f08e0d664f2b2017fda8b1aa6296fc22a777ec7567675f8114 + md5: 88c2bcb690eb595b39b17241d43117c6 + depends: + - cuda-cupti-dev 12.5.39.* + - cuda-gdb 12.5.39.* + - cuda-nvdisasm 12.5.39.* + - cuda-nvprof 12.5.39.* + - cuda-nvtx 12.5.39.* + - cuda-sanitizer-api 12.5.39.* + license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] + size: 20189 + timestamp: 1716407106507 +- conda: https://conda.anaconda.org/conda-forge/noarch/cuda-compiler-12.5.0-hbad6d8a_0.conda + sha256: 449d3b58af1941c3f808c0bc67fb0a947d6c8eb697690401ffa29a7b07d8dc9c + md5: 7b46e23b42840569905ba1c8adb13e13 depends: - __linux - c-compiler - - cuda-cuobjdump 12.6.68.* - - cuda-cuxxfilt 12.6.68.* - - cuda-nvcc 12.6.68.* - - cuda-nvprune 12.6.68.* + - cuda-cuobjdump 12.5.39.* + - cuda-cuxxfilt 12.5.39.* + - cuda-nvcc 12.5.40.* + - cuda-nvprune 12.5.39.* - cxx-compiler license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 20097 - timestamp: 1725023771603 -- kind: conda - name: cuda-crt-dev_linux-64 - version: 12.6.68 - build: ha770c72_0 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-64-12.6.68-ha770c72_0.conda - sha256: aef313c549aa41d18a3cbdb91d5d2eeb2c5b32112ef1ec210838b73302d0d58c - md5: 379e26d4ecc04f2bf00b7216176f70a7 + size: 20299 + timestamp: 1716407094107 +- conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-64-12.5.40-ha770c72_0.conda + sha256: fb77118fcf859d9d2b25c0b1db23df39302359a2aaecfce4a20a1be7152ad7bf + md5: adf66999e96bf3c87190c694d49fed48 depends: - - cuda-version >=12.6,<12.7.0a0 + - cuda-version >=12.5,<12.6.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 87541 - timestamp: 1724960324737 -- kind: conda - name: cuda-crt-tools - version: 12.6.68 - build: ha770c72_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-crt-tools-12.6.68-ha770c72_0.conda - sha256: 9fff1414170d360d7a0e93f7479c6366a9ccb583bb75b28f83d02c833837d396 - md5: 3ff1b27e3ba24f6ef76cff22f745adfe - depends: - - cuda-version >=12.6,<12.7.0a0 + size: 87385 + timestamp: 1716385188045 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-crt-tools-12.5.40-ha770c72_0.conda + sha256: cdf00fe01d8f3a86c4df85853a0962cc3292a85cab44c032e3f206d3a696f582 + md5: 3c6bb9bd29688ae7db63f162c31a79f6 + depends: + - cuda-version >=12.5,<12.6.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 26260 - timestamp: 1724960329305 -- kind: conda - name: cuda-cudart - version: 12.6.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-12.6.68-h5888daf_0.conda - sha256: 0b318ea3434dec641a7ac408ca75049f4684a68a71e4c8d0a78362d52e335502 - md5: 0b7d12eb06cc4c88f1afb51ca403866d + size: 26432 + timestamp: 1716385207199 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-12.5.39-he02047a_0.conda + sha256: 356abe63148a07bff646258071899ccb9713914a23a0a925a737adfd141cd27c + md5: c60967d2a1a54ea3ca3660cf6249de36 depends: - __glibc >=2.17,<3.0.a0 - - cuda-cudart_linux-64 12.6.68 h3f2d84a_0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-cudart_linux-64 12.5.39 h85509e4_0 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 22421 - timestamp: 1724956837719 -- kind: conda - name: cuda-cudart-dev - version: 12.6.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-dev-12.6.68-h5888daf_0.conda - sha256: e567ca222de565a71821c1a901ca1059108b713e6260b1a00b0a5aa3668aa360 - md5: 441525ec5713d64171fe3e1f037169d3 - depends: - - __glibc >=2.17,<3.0.a0 - - cuda-cudart 12.6.68 h5888daf_0 - - cuda-cudart-dev_linux-64 12.6.68 h3f2d84a_0 - - cuda-cudart-static 12.6.68 h5888daf_0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + size: 22582 + timestamp: 1716331837792 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-dev-12.5.39-he02047a_0.conda + sha256: 798e23c9d027451b3e5907c81b30a246a14357d4d0c5a1912046035ad5b77fa7 + md5: 7c85081a6ffba35bc52c27f8afa9c398 + depends: + - __glibc >=2.17,<3.0.a0 + - cuda-cudart 12.5.39 he02047a_0 + - cuda-cudart-dev_linux-64 12.5.39 h85509e4_0 + - cuda-cudart-static 12.5.39 he02047a_0 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 22849 - timestamp: 1724956860901 -- kind: conda - name: cuda-cudart-dev_linux-64 - version: 12.6.68 - build: h3f2d84a_0 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-64-12.6.68-h3f2d84a_0.conda - sha256: 5b704308f42f6a071995c18a389c93f10cd5edb503471ef4bfe9a2d97e6384c6 - md5: f9ea76842b2194b20eec3bbcd603ddaa + size: 23061 + timestamp: 1716331865205 +- conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-64-12.5.39-h85509e4_0.conda + sha256: c6ca66c985118904c28c119c4581cc13d1229f764367eeceeeb32d59cf0338e7 + md5: 7d312740938701c854d434714a38e296 depends: - cuda-cccl_linux-64 - cuda-cudart-static_linux-64 - cuda-cudart_linux-64 - - cuda-version >=12.6,<12.7.0a0 + - cuda-version >=12.5,<12.6.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 365390 - timestamp: 1724956842631 -- kind: conda - name: cuda-cudart-static - version: 12.6.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-static-12.6.68-h5888daf_0.conda - sha256: 597c0b93b78a336d2e6ded15c1e2644116bbda071107be7571ad7b5c326efbd9 - md5: 429aa2c0e9bd974594b73dabbd30b69c + size: 366049 + timestamp: 1716331843861 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-static-12.5.39-he02047a_0.conda + sha256: f0361dc14687d55ae28571b9bbef3358c7c8202f76c7be81a02194f102b21efe + md5: c99976910ac10a5a1cd58fcb09311303 depends: - __glibc >=2.17,<3.0.a0 - - cuda-cudart-static_linux-64 12.6.68 h3f2d84a_0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-cudart-static_linux-64 12.5.39 h85509e4_0 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 22452 - timestamp: 1724956849270 -- kind: conda - name: cuda-cudart-static_linux-64 - version: 12.6.68 - build: h3f2d84a_0 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-64-12.6.68-h3f2d84a_0.conda - sha256: 4afbfe1a05914ada4b550ad8bbe91366018a74f8f54e73564f13400d4bb0dc2c - md5: 3f844a41c281876742c243ad8f7a3487 + size: 22664 + timestamp: 1716331851590 +- conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-64-12.5.39-h85509e4_0.conda + sha256: 9a1d415463c46230029744fd5f0d976ed1857031df5bc806d9692250d8c12e13 + md5: bef4ae216ed3fbc759a58605e0a69f5d depends: - - cuda-version >=12.6,<12.7.0a0 + - cuda-version >=12.5,<12.6.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 760037 - timestamp: 1724956819230 -- kind: conda - name: cuda-cudart_linux-64 - version: 12.6.68 - build: h3f2d84a_0 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-64-12.6.68-h3f2d84a_0.conda - sha256: 89cdca6b404920a70a7d3565189f7d37fcfd3505018cda74ae18407c7ed22595 - md5: 324647f838d7554ed6ebd6d28139d17f + size: 741994 + timestamp: 1716331804040 +- conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-64-12.5.39-h85509e4_0.conda + sha256: cdf5a049e368dc306637071e5a6779df2a3a67e48d5f6fddedab939a33775bdb + md5: 32bc114164d5ca4ad38f775316506d0b depends: - - cuda-version >=12.6,<12.7.0a0 + - cuda-version >=12.5,<12.6.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 187973 - timestamp: 1724956827608 -- kind: conda - name: cuda-cuobjdump - version: 12.6.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-cuobjdump-12.6.68-h5888daf_0.conda - sha256: 91e75904e9eda4ce4aea93380e746edd0a9e5c0c66dae4a1926ec796bbb2d221 - md5: 1e329537a97ec5774da5e7e36466b9a0 + size: 187630 + timestamp: 1716331825540 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cuobjdump-12.5.39-he02047a_0.conda + sha256: 411e259787d37b093971b604bbc7506f49d7a67cf2596ada3c9b03e12969040d + md5: a25550961e7449840c40800279cc6bc6 depends: - __glibc >=2.17,<3.0.a0 - cuda-nvdisasm - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 245517 - timestamp: 1724960766012 -- kind: conda - name: cuda-cupti - version: 12.6.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-cupti-12.6.68-h5888daf_0.conda - sha256: 0b29fab14064df7fcd0530b0df6920d60e924f52cacc1dc8bcb3deb24e0f5ea1 - md5: ee55a34660af08e4b5ccd24c777f02bf + size: 243571 + timestamp: 1716325794017 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cupti-12.5.39-he02047a_0.conda + sha256: 921d13c303702ece7113c5487cd4e9d4ac150b49a7ecefb77997d27cbfc805b1 + md5: 067614625e27625220ed63f0e592b99e depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 1973226 - timestamp: 1724956978398 -- kind: conda - name: cuda-cupti-dev - version: 12.6.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-cupti-dev-12.6.68-h5888daf_0.conda - sha256: ace8da61a7a635627f64dd1fd0f726bde373a2f93f193117b00ed8c09b7117bb - md5: e878ed06fc65bae04eed5b0669116a9f + size: 1946788 + timestamp: 1716318528923 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cupti-dev-12.5.39-he02047a_0.conda + sha256: 8fcf256a3b8a88a09faade16d656bc78c97e04a7cf915dcb7f1789985f3a12e4 + md5: 6d8ffa334992be7ec9b14655353ce32f depends: - __glibc >=2.17,<3.0.a0 - - cuda-cupti 12.6.68 h5888daf_0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-cupti 12.5.39 he02047a_0 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 constrains: - - cuda-cupti-static >=12.6.68 + - cuda-cupti-static >=12.5.39 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 2988211 - timestamp: 1724957027526 -- kind: conda - name: cuda-cuxxfilt - version: 12.6.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-cuxxfilt-12.6.68-h5888daf_0.conda - sha256: 15c78013b79b517131de97d7bed7f16dfe019decb2d70c5a7d5fa1f13e1e298c - md5: 926ad54e554b26dddb85bc9c32e7f340 + size: 8036270 + timestamp: 1716318607696 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cuxxfilt-12.5.39-he02047a_0.conda + sha256: e4c6ca1a3a555a64bd9414f1ce82cdb34a4309a524014ee32ae078604d544144 + md5: cc7ff8d6e6bf6f950a22002ebb95dd11 depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 215481 - timestamp: 1724957020270 -- kind: conda - name: cuda-driver-dev - version: 12.6.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-driver-dev-12.6.68-h5888daf_0.conda - sha256: 63f2043c4d7dc0d4aee9ea23084bad43e0e89208640cfec4b74c84fb11ac2642 - md5: 65b7f78286869a41ccb0586c5f066f38 + size: 215444 + timestamp: 1716318836089 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-driver-dev-12.5.39-he02047a_0.conda + sha256: ae18eaeb586486718087c63656a7aae3b68776bf6db5d370a05428d7e1e50893 + md5: 1d533a00a54131c9a1ee4dc277019147 depends: - __glibc >=2.17,<3.0.a0 - cuda-driver-dev_linux-64 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 22246 - timestamp: 1724956856092 -- kind: conda - name: cuda-driver-dev_linux-64 - version: 12.6.68 - build: h3f2d84a_0 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/cuda-driver-dev_linux-64-12.6.68-h3f2d84a_0.conda - sha256: 3bdc14082abd45fb6f68a45494d0c6d61842e7525f97396449529e7e075d041d - md5: abd042dea6b41be2bbec096832e57a5e + size: 22435 + timestamp: 1716331859151 +- conda: https://conda.anaconda.org/conda-forge/noarch/cuda-driver-dev_linux-64-12.5.82-h85509e4_0.conda + sha256: 5bffb9a54b075904378dee4e22997f647c2d8d84f9eda05913654488ca3145ec + md5: 36582ad02f86902a9cdf3a6db68f6fae depends: - - cuda-version >=12.6,<12.7.0a0 + - cuda-version >=12.5,<12.6.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 35770 - timestamp: 1724956832799 -- kind: conda - name: cuda-gdb - version: 12.6.68 - build: hf8b0789_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-gdb-12.6.68-hf8b0789_0.conda - sha256: 51ad30955685aee26f95c65b2d410247a0fbc3ac48ad1de1218a93222ade89fd - md5: c656619eff07312c9d9cbbdad6217d39 + size: 35661 + timestamp: 1720449910369 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-gdb-12.5.39-hda18ab6_0.conda + sha256: db49ce6fef4d4c2833347e469f3e73ce7d1d30dfdc0251e27e62ccbe0bdac44b + md5: 7cab0cd39d27b538c099901ae1be6862 depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 + - cuda-version >=12.5,<12.6.0a0 - gmp >=6.3.0,<7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 377885 - timestamp: 1724956340074 -- kind: conda - name: cuda-libraries - version: 12.6.1 - build: ha770c72_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-libraries-12.6.1-ha770c72_0.conda - sha256: e9e6d860dff2d96fa0d47b1e37c202b7b3027e56e3bab110f0ee3fabc291c708 - md5: d47f5b9610e95b44b170dff8dd87161c - depends: - - cuda-cudart 12.6.68.* - - cuda-nvrtc 12.6.68.* - - cuda-opencl 12.6.68.* - - libcublas 12.6.1.4.* - - libcufft 11.2.6.59.* - - libcufile 1.11.1.6.* - - libcurand 10.3.7.68.* - - libcusolver 11.6.4.69.* - - libcusparse 12.5.3.3.* - - libnpp 12.3.1.54.* - - libnvfatbin 12.6.68.* - - libnvjitlink 12.6.68.* - - libnvjpeg 12.3.3.54.* + size: 378508 + timestamp: 1716318537998 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-libraries-12.5.0-ha770c72_0.conda + sha256: 156e8e0a04efbd994d8ff8863292000c7b5063c25887392f99994a861631c5bb + md5: 038b33525fa1b22eb74e52fe161b3bac + depends: + - cuda-cudart 12.5.39.* + - cuda-nvrtc 12.5.40.* + - cuda-opencl 12.5.39.* + - libcublas 12.5.2.13.* + - libcufft 11.2.3.18.* + - libcufile 1.10.0.4.* + - libcurand 10.3.6.39.* + - libcusolver 11.6.2.40.* + - libcusparse 12.4.1.24.* + - libnpp 12.3.0.116.* + - libnvfatbin 12.5.39.* + - libnvjitlink 12.5.40.* + - libnvjpeg 12.3.2.38.* license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 19967 - timestamp: 1725023906792 -- kind: conda - name: cuda-libraries-dev - version: 12.6.1 - build: ha770c72_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-libraries-dev-12.6.1-ha770c72_0.conda - sha256: 584871f1e84bff6cc18b08b54147f0dde17086d36357d63a4ef683f5519f8bc4 - md5: 27fccd5278dcc00d496240983cb481d8 - depends: - - cuda-cccl_linux-64 12.6.37.* - - cuda-cudart-dev 12.6.68.* - - cuda-driver-dev 12.6.68.* - - cuda-nvrtc-dev 12.6.68.* - - cuda-opencl-dev 12.6.68.* - - cuda-profiler-api 12.6.68.* - - libcublas-dev 12.6.1.4.* - - libcufft-dev 11.2.6.59.* - - libcufile-dev 1.11.1.6.* - - libcurand-dev 10.3.7.68.* - - libcusolver-dev 11.6.4.69.* - - libcusparse-dev 12.5.3.3.* - - libnpp-dev 12.3.1.54.* - - libnvfatbin-dev 12.6.68.* - - libnvjitlink-dev 12.6.68.* - - libnvjpeg-dev 12.3.3.54.* + size: 20205 + timestamp: 1716407127794 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-libraries-dev-12.5.0-ha770c72_0.conda + sha256: 1320409e4cf23fcb760e43e5face23b0a7c30025a44f0a375f84fb1d24753fc1 + md5: fe3aab6009b9e63235069555aa6bc1cb + depends: + - cuda-cccl 12.5.39.* + - cuda-cudart-dev 12.5.39.* + - cuda-driver-dev 12.5.39.* + - cuda-nvrtc-dev 12.5.40.* + - cuda-opencl-dev 12.5.39.* + - cuda-profiler-api 12.5.39.* + - libcublas-dev 12.5.2.13.* + - libcufft-dev 11.2.3.18.* + - libcufile-dev 1.10.0.4.* + - libcurand-dev 10.3.6.39.* + - libcusolver-dev 11.6.2.40.* + - libcusparse-dev 12.4.1.24.* + - libnpp-dev 12.3.0.116.* + - libnvfatbin-dev 12.5.39.* + - libnvjitlink-dev 12.5.40.* + - libnvjpeg-dev 12.3.2.38.* license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 20075 - timestamp: 1725023832957 -- kind: conda - name: cuda-nsight - version: 12.6.68 - build: ha770c72_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-nsight-12.6.68-ha770c72_0.conda - sha256: 57a29614d665701b7b5cb27c1545006381bc24f66e61604f98f8e242b70062f0 - md5: 7ec71501b8495be7485d2c0b2736a859 - depends: - - cuda-version >=12.6,<12.7.0a0 + size: 20285 + timestamp: 1716407123451 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nsight-12.5.39-ha770c72_0.conda + sha256: d54769e0694e720cd7fac95acc06d37d705db213c2dd71bcc1a89acdc116a75f + md5: 7b1f328d113237a0c74cb90bf17730fb + depends: + - cuda-version >=12.5,<12.6.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 118697357 - timestamp: 1724959113951 -- kind: conda - name: cuda-nvcc - version: 12.6.68 - build: hcdd1206_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvcc-12.6.68-hcdd1206_0.conda - sha256: 000f688375f51950c36f2dfd27601776ae065f7461fd3fc0299a127dea6514b8 - md5: 60c8560721164000444f788331dc4342 - depends: - - cuda-nvcc_linux-64 12.6.68.* + size: 118682253 + timestamp: 1716318456049 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvcc-12.5.40-hcdd1206_0.conda + sha256: b4b1bb8487f7ba9c4b86061653f08c63c60bec9671f866066b75f085a276b8e5 + md5: 2a68e542d4d58ef24eb265d5d306fb3d + depends: + - cuda-nvcc_linux-64 12.5.40.* - gcc_linux-64 - gxx_linux-64 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 23538 - timestamp: 1724973275940 -- kind: conda - name: cuda-nvcc-dev_linux-64 - version: 12.6.68 - build: he91c749_0 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/cuda-nvcc-dev_linux-64-12.6.68-he91c749_0.conda - sha256: 86f0b22ab26ce3ccb01d7e6589a57c0e1355a300fc7322cfe8f203dfe4cf4e2a - md5: ff8941d6cd2cc1a8a86772324d6df85e + size: 23780 + timestamp: 1716399166053 +- conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvcc-dev_linux-64-12.5.40-ha770c72_0.conda + sha256: 0442e045480dd01fb495fce930e6877ab6cbc6dd2f4a19c682d9743828d6404a + md5: f49632352a60f0fbfb2a1d5c42ccaff9 depends: - - cuda-crt-dev_linux-64 12.6.68 ha770c72_0 - - cuda-nvvm-dev_linux-64 12.6.68 ha770c72_0 - - cuda-version >=12.6,<12.7.0a0 + - cuda-crt-dev_linux-64 12.5.40 ha770c72_0 + - cuda-nvvm-dev_linux-64 12.5.40 ha770c72_0 + - cuda-version >=12.5,<12.6.0a0 - libgcc-ng >=6 constrains: - - gcc_impl_linux-64 >=6,<14.0a0 + - gcc_impl_linux-64 >=6,<13 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 11351670 - timestamp: 1724960430257 -- kind: conda - name: cuda-nvcc-impl - version: 12.6.68 - build: h85509e4_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvcc-impl-12.6.68-h85509e4_0.conda - sha256: fd7a268512471d90f777d8a9eb3c8fb88b1c23b965ed4e71fa73a3d7522a291d - md5: dd171a9bf2f5388e0a0accff84026aaf - depends: - - cuda-cudart >=12.6.68,<13.0a0 + size: 11436997 + timestamp: 1716385314895 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvcc-impl-12.5.40-hd3aeb46_0.conda + sha256: e32305ad70861d67f6bb99a8e5a7f3152663a3209446958d404e9a9b3f156422 + md5: e28565b58cb211bc508e6c555ca02fab + depends: + - __glibc >=2.17,<3.0.a0 + - cuda-cudart >=12.5.39,<13.0a0 - cuda-cudart-dev - - cuda-nvcc-dev_linux-64 12.6.68 he91c749_0 - - cuda-nvcc-tools 12.6.68 he02047a_0 - - cuda-nvvm-impl 12.6.68 he02047a_0 - - cuda-version >=12.6,<12.7.0a0 + - cuda-nvcc-dev_linux-64 12.5.40 ha770c72_0 + - cuda-nvcc-tools 12.5.40 hd3aeb46_0 + - cuda-nvvm-impl 12.5.40 h59595ed_0 + - cuda-version >=12.5,<12.6.0a0 constrains: - - gcc_impl_linux-64 >=6,<14.0a0 + - gcc_impl_linux-64 >=6,<13 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 24568 - timestamp: 1724960461873 -- kind: conda - name: cuda-nvcc-tools - version: 12.6.68 - build: he02047a_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvcc-tools-12.6.68-he02047a_0.conda - sha256: 42f9003155eec3d699dd8272e5d97867834594f356f84a6627fcef30e9a1dfbb - md5: 61730380c89bc2f13b18898d8ffa062d - depends: - - __glibc >=2.17,<3.0.a0 - - cuda-crt-tools 12.6.68 ha770c72_0 - - cuda-nvvm-tools 12.6.68 he02047a_0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=12 - - libstdcxx >=12 + size: 24809 + timestamp: 1716385346771 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvcc-tools-12.5.40-hd3aeb46_0.conda + sha256: 9ad65a5b7077bbd676e870d4c24604b1b1c65d631270fc69ff00e436e11b10ca + md5: 98cd9496694e49b22ca12b3da4969b47 + depends: + - __glibc >=2.17,<3.0.a0 + - cuda-crt-tools 12.5.40 ha770c72_0 + - cuda-nvvm-tools 12.5.40 h59595ed_0 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 constrains: - - gcc_impl_linux-64 >=6,<14.0a0 + - gcc_impl_linux-64 >=6,<13 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 23941791 - timestamp: 1724960385139 -- kind: conda - name: cuda-nvcc_linux-64 - version: 12.6.68 - build: h8a487aa_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvcc_linux-64-12.6.68-h8a487aa_0.conda - sha256: 2d66de6f16dcc628e533c70323170e6705a3dd17cbaee010b00604ff0409a603 - md5: b012c2467ff3e1f71634fba6f9680867 - depends: - - __glibc >=2.17,<3.0.a0 - - cuda-cudart-dev_linux-64 12.6.* - - cuda-driver-dev_linux-64 12.6.* - - cuda-nvcc-dev_linux-64 12.6.68.* - - cuda-nvcc-impl 12.6.68.* - - cuda-nvcc-tools 12.6.68.* + size: 23883968 + timestamp: 1716385271169 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvcc_linux-64-12.5.40-h8a487aa_0.conda + sha256: 08615c4477161fb541f906933a2ca63e3a85eff7d3c80ab05085cd691fdd2a48 + md5: 16b05232da3562cdfa7dea56131990e1 + depends: + - __glibc >=2.17,<3.0.a0 + - cuda-cudart-dev_linux-64 12.5.* + - cuda-driver-dev_linux-64 12.5.* + - cuda-nvcc-dev_linux-64 12.5.40.* + - cuda-nvcc-impl 12.5.40.* + - cuda-nvcc-tools 12.5.40.* - sysroot_linux-64 >=2.17,<3.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 25263 - timestamp: 1724973272933 -- kind: conda - name: cuda-nvdisasm - version: 12.6.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvdisasm-12.6.68-h5888daf_0.conda - sha256: 5127cb1719d5ecc31d734137a77fe42daa75d81445b51af73e013111131b2eba - md5: c3538edfd380096fe05da5cd0a423f2c + size: 25487 + timestamp: 1716399158733 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvdisasm-12.5.39-he02047a_0.conda + sha256: c40a16699249d4abda622a5a754d8ae0f111db6e9a430c49ac41f87ea587a1ce + md5: cfa3b86bfc6800c13d5cf5426f5b7297 depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 49922119 - timestamp: 1724957254308 -- kind: conda - name: cuda-nvml-dev - version: 12.6.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvml-dev-12.6.68-h5888daf_0.conda - sha256: abf92d611a0b8cda26ca2ce06e7fe610079bbf7e01ceda74b77e95075cfdf8cb - md5: 22262da6a1ec122df3987d353863e9af + size: 49934569 + timestamp: 1716318991301 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvml-dev-12.5.39-he02047a_0.conda + sha256: 3c02887eb8be4a907e5678835ff282d4a637950fc0f4ebc0d2f620ea7354cd9d + md5: 48c1d4d336135c67a0caad74f74ecb05 depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 161496 - timestamp: 1724957256916 -- kind: conda - name: cuda-nvprof - version: 12.6.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvprof-12.6.68-h5888daf_0.conda - sha256: d97ffc1f7679f99ec62758aeb5b7b4ea45f41b2c36050d3ddcae9e119f6bca62 - md5: 5ed6ecf1c6ca70f88b3f0d4eed9e00d5 + size: 159924 + timestamp: 1716318720719 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvprof-12.5.39-he02047a_0.conda + sha256: d4f6a1392736e606c65c3c5bc2001e46526381ae94ac28ae38bde48618e45226 + md5: 798f0725aa5910f01baaad0c2af25752 depends: - __glibc >=2.17,<3.0.a0 - cuda-cupti - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 2683295 - timestamp: 1724960955168 -- kind: conda - name: cuda-nvprune - version: 12.6.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvprune-12.6.68-h5888daf_0.conda - sha256: 4e72bda6da3d5a71780e1c98b511fe0fcb5a17f2d453f3fb29a15e083dfe3f46 - md5: f8d9c29ee55dd1c7fe9e029d8bd16e22 + size: 2685396 + timestamp: 1716326664426 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvprune-12.5.39-he02047a_0.conda + sha256: 68915118e4735adbd3ee9ee443682bc56832a5f386ba625bd3f1dc55ac564a2b + md5: ddfe2e736c7e60fb463fb156e8bfe845 depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 67545 - timestamp: 1724957545821 -- kind: conda - name: cuda-nvrtc - version: 12.6.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-12.6.68-h5888daf_0.conda - sha256: 2d83714b08566debee557ac7d00c2483943cf21b1c1acb59743830b165a6b1b2 - md5: 827a5f2dbfd33e7ff3925c9d145fee5a + size: 67586 + timestamp: 1716319278466 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-12.5.40-he02047a_0.conda + sha256: 9c38d103deb425631d0aee9555a72f17a5ccc5d1108fc9980b3124de534a5fbb + md5: fd873f7d082eb09b64f2845c5bf5b873 depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 18126968 - timestamp: 1724957899086 -- kind: conda - name: cuda-nvrtc-dev - version: 12.6.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-dev-12.6.68-h5888daf_0.conda - sha256: 39e2b53e3f064446c6748a3e37b37f675c996c8d89b421dbd9eba1d2e0c4f806 - md5: 639abfe070f927f2343870220f0d70a3 + size: 19013340 + timestamp: 1716320007011 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-dev-12.5.40-he02047a_0.conda + sha256: ab4ee1dd45f0305884a54f87eb9fedfc7b403d0ac1f6046a3dafe9fb8a681d7d + md5: 114d3f70ada9dc9baa4a22273e197c1f depends: - __glibc >=2.17,<3.0.a0 - - cuda-nvrtc 12.6.68 h5888daf_0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-nvrtc 12.5.40 he02047a_0 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 constrains: - - cuda-nvrtc-static >=12.6.68 + - cuda-nvrtc-static >=12.5.40 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 32213 - timestamp: 1724958010440 -- kind: conda - name: cuda-nvtx - version: 12.6.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvtx-12.6.68-h5888daf_0.conda - sha256: bd67598f7ca91ddf326173eb21dd95e9f513335f6754630aec3eb1e031f10101 - md5: 0b186c8d486129b58bf5f367b1364766 + size: 32077 + timestamp: 1716320120894 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvtx-12.5.39-he02047a_0.conda + sha256: d350153fc49a89eb9eb9c9a4b549de9b3047b94529d76ae512a31a12c62ed323 + md5: 83e70531447952503b0f9681ce3a42ca depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 31321 - timestamp: 1724957562199 -- kind: conda - name: cuda-nvvm-dev_linux-64 - version: 12.6.68 - build: ha770c72_0 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-64-12.6.68-ha770c72_0.conda - sha256: 620dad9d7caf07015d729cb5353dd58d2f7215c2199be0d5957a2fffd4cb1054 - md5: 473413de667e1ff907ff6157d79584da + size: 31664 + timestamp: 1716318996982 +- conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-64-12.5.40-ha770c72_0.conda + sha256: 65bd2959336d5dbe46dff8425f62135e16db853a79d6608ef969b1a3fbe5f904 + md5: 3ef2eae0f780bdd301dca19d9923ea72 depends: - - cuda-version >=12.6,<12.7.0a0 + - cuda-version >=12.5,<12.6.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 24252 - timestamp: 1724960333152 -- kind: conda - name: cuda-nvvm-impl - version: 12.6.68 - build: he02047a_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-12.6.68-he02047a_0.conda - sha256: c9c0eebcdbebc8171e3e12f09d6c54a8c5ba666a8cb3629dd4b447bbecf5df4d - md5: e11179a97c9f6c152cbeb3307116d27c + size: 24408 + timestamp: 1716385213249 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-12.5.40-h59595ed_0.conda + sha256: 6980665f9d9ac77ebde5b5c4536370fbbfb6ed8bf96c4e7120b6547485b19aac + md5: 94a9b0d015c658b8f5a094ef0d3fdade depends: - - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=12 - - libstdcxx >=12 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 8070387 - timestamp: 1724960343511 -- kind: conda - name: cuda-nvvm-tools - version: 12.6.68 - build: he02047a_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-tools-12.6.68-he02047a_0.conda - sha256: 86ccfcbdc1cb8d96fa2d3314a8f3c9c0bebb7c3335de4ad686a51a870038bc55 - md5: ca417ac0e26f79f641a0626e390eb7b1 + size: 9065157 + timestamp: 1716385224595 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-tools-12.5.40-h59595ed_0.conda + sha256: aa095e0377dac42653fd0942f537e9778c5e60ecaaafc971af95bc7fe1634483 + md5: 00c31a1db8e5659809a205a942b4ab9a depends: - - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=12 - - libstdcxx >=12 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 10865275 - timestamp: 1724960361940 -- kind: conda - name: cuda-nvvp - version: 12.6.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvp-12.6.68-h5888daf_0.conda - sha256: f6819ea77b7ad6e007fdf740e0f70ef24e749baadf2616db0e6b02772ee4e7f6 - md5: 6888998192007bdae641687ca91768b2 + size: 11675741 + timestamp: 1716385244494 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvp-12.5.39-he02047a_0.conda + sha256: 43afa5d1187913267660a4e80b8932f1b0c58c16749215cd6dd92dd8a7e5f746 + md5: 33373f21a5757b8a815f0fc0701663c4 depends: - __glibc >=2.17,<3.0.a0 - cuda-nvdisasm - cuda-nvprof - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 117857736 - timestamp: 1724973264201 -- kind: conda - name: cuda-opencl - version: 12.6.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-opencl-12.6.68-h5888daf_0.conda - sha256: 00a12fd56d93f123b8e57eeeb083d0c5853a6c90a3ba0973802b55ccf111851b - md5: dcb584f2ed1354c4d05bb4ff38c83997 + size: 117814618 + timestamp: 1716356587920 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-opencl-12.5.39-he02047a_1.conda + sha256: 2a67dac57514028a10abadf2bcab8dade408eb609db81b4b2c6b70db0dca0e17 + md5: 9601ffc0dc5be480b0bf0db1c5c8f6d4 depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 - ocl-icd >=2.3.2,<3.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 30128 - timestamp: 1724957701481 -- kind: conda - name: cuda-opencl-dev - version: 12.6.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-opencl-dev-12.6.68-h5888daf_0.conda - sha256: e73e85680b539d828f71da25c37f9b510ba34d4b49741d5c32502c5fafb21b68 - md5: 1bd310af9bd6620bad492d4a147a45e8 + size: 30092 + timestamp: 1722370506103 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-opencl-dev-12.5.39-he02047a_1.conda + sha256: d2475f2ec5ba230ab0a1ec89dbd62dd8664ba2fd85abd299c663149d03955a0a + md5: dd60dc3a21a98fa62f98e324c4ae31bd depends: - __glibc >=2.17,<3.0.a0 - - cuda-opencl 12.6.68 h5888daf_0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-opencl 12.5.39 he02047a_1 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 95075 - timestamp: 1724957707369 -- kind: conda - name: cuda-profiler-api - version: 12.6.68 - build: ha770c72_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-profiler-api-12.6.68-ha770c72_0.conda - sha256: d9bed6a6ad430fe4d6c6ec968080056e61d8f5cb7af3440f5395e80c1aa1480b - md5: 16cb8e8c8fdb1b57075ecf2e79d5c00c + size: 94930 + timestamp: 1722370514855 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-profiler-api-12.5.39-ha770c72_0.conda + sha256: d2b109678867e3a573e78c0cee5aad3d672563e0e78a56366fc85fdbd3c06298 + md5: bd53edd147e9d663d189c10628ca2709 depends: - cuda-cudart-dev - - cuda-version >=12.6,<12.7.0a0 + - cuda-version >=12.5,<12.6.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 22810 - timestamp: 1724960125617 -- kind: conda - name: cuda-sanitizer-api - version: 12.6.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-sanitizer-api-12.6.68-h5888daf_0.conda - sha256: 5076761c5fe930d9177a30227afeb300fc487e981897ed5c946ed819b50dc45b - md5: 91789af92cea70b56950061dd87ed588 + size: 23031 + timestamp: 1716399609062 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-sanitizer-api-12.5.39-he02047a_0.conda + sha256: 4ec494e099b04d658487dfe6861a30f4639f42864ef256b21ec796273f0c8e07 + md5: 792b6de1efd57038666199ab44f98419 depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 9487334 - timestamp: 1724957856577 -- kind: conda - name: cuda-toolkit - version: 12.6.1 - build: ha804496_0 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/cuda-toolkit-12.6.1-ha804496_0.conda - sha256: 64240a5ff1c13cb8138554046fb29ccd2a5c91b687d630f6b988474348bfc27d - md5: eeced9644944ae4707963d768be41b29 + size: 9881121 + timestamp: 1716319731558 +- conda: https://conda.anaconda.org/conda-forge/noarch/cuda-toolkit-12.5.0-ha804496_0.conda + sha256: 37e31e8d1870d43562cd74b3aaef383dc8b3335e25e25111ea68999f8bfd6bca + md5: 07cd30a505f4e9885dc4739c9b3cb551 depends: - __linux - - cuda-compiler 12.6.1.* - - cuda-libraries 12.6.1.* - - cuda-libraries-dev 12.6.1.* - - cuda-nvml-dev 12.6.68.* - - cuda-tools 12.6.1.* + - cuda-compiler 12.5.0.* + - cuda-libraries 12.5.0.* + - cuda-libraries-dev 12.5.0.* + - cuda-nvml-dev 12.5.39.* + - cuda-tools 12.5.0.* license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 19917 - timestamp: 1725031904715 -- kind: conda - name: cuda-tools - version: 12.6.1 - build: ha770c72_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-tools-12.6.1-ha770c72_0.conda - sha256: 0f694d33d886b3218ce3deca05ca1efd04789214872b48285311b456154e349c - md5: 4f10f0f774ae2f1cfecbff51eff0928c - depends: - - cuda-command-line-tools 12.6.1.* - - cuda-visual-tools 12.6.1.* - - gds-tools 1.11.1.6.* + size: 20134 + timestamp: 1717089168170 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-tools-12.5.0-ha770c72_0.conda + sha256: ee71daf2b97edae4398c3ddf69d5938f153034d6e48a3491d99457a01914048a + md5: da0d079f597ad48df78c944663486e50 + depends: + - cuda-command-line-tools 12.5.0.* + - cuda-visual-tools 12.5.0.* + - gds-tools 1.10.0.4.* license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 19783 - timestamp: 1725028927473 -- kind: conda - name: cuda-version - version: '12.6' - build: h7480c83_3 - build_number: 3 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/cuda-version-12.6-h7480c83_3.conda - sha256: fd9104d73199040285b6a6ad56322b38af04828fabbac1f5a268a83509358425 - md5: 1c8b99e65a4423b1e4ac2e4c76fb0978 + size: 19954 + timestamp: 1717086722208 +- conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-12.5-hd4f0392_3.conda + sha256: e45a5d14909296abd0784a073da9ee5c420fa58671fbc999f8a9ec898cf3486b + md5: 6ae1a563a4aa61e55e8ae8260f0d021b constrains: - - cudatoolkit 12.6|12.6.* - __cuda >=12 + - cudatoolkit 12.5|12.5.* license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 20940 - timestamp: 1722603990914 -- kind: conda - name: cuda-visual-tools - version: 12.6.1 - build: ha770c72_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cuda-visual-tools-12.6.1-ha770c72_0.conda - sha256: 189c68400ed3fd7bd83f8b8d0eb829540619756748ef5bb02dc20dc991ae48a8 - md5: 54ed0b9dcb1d8f93ea9a3d1332357f9e - depends: - - cuda-libraries-dev 12.6.1.* - - cuda-nsight 12.6.68.* - - cuda-nvml-dev 12.6.68.* - - cuda-nvvp 12.6.68.* - - nsight-compute 2024.3.1.2.* + size: 21151 + timestamp: 1716314536803 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-visual-tools-12.5.0-ha770c72_0.conda + sha256: 1fd112cbd99f8c8a27906e5546e9d663ecc026800cde12f97b9c971ffa26b00b + md5: 9e0f7972e90f2c113ffd5b3c55c51b4d + depends: + - cuda-libraries-dev 12.5.0.* + - cuda-nsight 12.5.39.* + - cuda-nvml-dev 12.5.39.* + - cuda-nvvp 12.5.39.* + - nsight-compute 2024.2.0.16.* license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 19853 - timestamp: 1725026534145 -- kind: conda - name: cudnn - version: 8.9.7.29 - build: h092f7fd_3 - build_number: 3 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cudnn-8.9.7.29-h092f7fd_3.conda + size: 20033 + timestamp: 1717084502048 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cudnn-8.9.7.29-h092f7fd_3.conda sha256: 27156736f5a0a30e6fb426f35216b903968b58bdf209d0a04b6eeb6530838456 md5: 2242eab289d88f2f819f8aee5aa49823 depends: @@ -4742,13 +4801,7 @@ packages: purls: [] size: 468267309 timestamp: 1710307755197 -- kind: conda - name: cxx-compiler - version: 1.7.0 - build: h00ab1b0_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.7.0-h00ab1b0_1.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.7.0-h00ab1b0_1.conda sha256: cf895938292cfd4cfa2a06c6d57aa25c33cc974d4ffe52e704ffb67f5577b93f md5: 28de2e073db9ca9b72858bee9fb6f571 depends: @@ -4760,48 +4813,91 @@ packages: purls: [] size: 6283 timestamp: 1714575513327 -- kind: conda - name: cycler - version: 0.12.1 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhd8ed1ab_0.conda - sha256: f221233f21b1d06971792d491445fd548224641af9443739b4b7b6d5d72954a8 - md5: 5cd86562580f274031ede6aa6aa24441 +- conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhd8ed1ab_1.conda + sha256: 9827efa891e507a91a8a2acf64e210d2aff394e1cde432ad08e1f8c66b12293c + md5: 44600c4667a319d67dbe0681fc0bc833 depends: - - python >=3.8 + - python >=3.9 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/cycler?source=project-defined-mapping - size: 13458 - timestamp: 1696677888423 -- kind: pypi + size: 13399 + timestamp: 1733332563512 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cyrus-sasl-2.1.27-h54b06d7_7.conda + sha256: d2ea5e52da745c4249e1a818095a28f9c57bd4df22cbfc645352defa468e86c2 + md5: dce22f70b4e5a407ce88f2be046f4ceb + depends: + - krb5 >=1.21.1,<1.22.0a0 + - libgcc-ng >=12 + - libntlm + - libstdcxx-ng >=12 + - openssl >=3.1.1,<4.0a0 + license: BSD-3-Clause-Attribution + license_family: BSD + purls: [] + size: 219527 + timestamp: 1690061203707 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.0.11-py312h8fd2918_3.conda + sha256: 7a888ddda463a3146949540229c70625fbefb05bcb1352cbff990f205b8392b0 + md5: 21e433caf1bb1e4c95832f8bb731d64c + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/cython?source=project-defined-mapping + size: 3752086 + timestamp: 1727456382070 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/cython-3.0.11-py312hde4cb15_2.conda + sha256: bd50c1d3f13403bbc96c0cd18ae95d492eda85df8ab9febe1719bf01018c6e32 + md5: bc620580cd4cafd885769a3975c00287 + depends: + - __osx >=11.0 + - libcxx >=17 + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/cython?source=project-defined-mapping + size: 3395577 + timestamp: 1725379375750 +- conda: https://conda.anaconda.org/conda-forge/noarch/dash-2.18.2-pyhd8ed1ab_1.conda + sha256: 33dec7b294596f59216d9952dd1e16fbca7453f1416b47e01ef8ad01bd30ac00 + md5: 67a5a590e7fde3d0696752184d6009a5 + depends: + - flask >=1.0.4 + - importlib-metadata + - nest-asyncio + - plotly >=5.0.0 + - python >=3.9 + - requests + - retrying + - setuptools + - typing-extensions >=4.1.1 + - werkzeug + constrains: + - dash_table >=5.0.0 + - dash-core-components >=2.0.0 + - dash-html-components >=2.0.0 + license: MIT + license_family: MIT + purls: + - pkg:pypi/dash?source=project-defined-mapping + size: 5457162 + timestamp: 1734247796370 +- pypi: https://us-west1-python.pkg.dev/probcomp-caliban/probcomp/datasync/datasync-0.0.2-py3-none-any.whl#sha256=ce28394757ba65fa1ff3a3010a1f67720f372c877f7d27bc23176a53e2cfa3a4 name: datasync version: 0.0.2 - url: https://us-west1-python.pkg.dev/probcomp-caliban/probcomp/datasync/datasync-0.0.2-py3-none-any.whl#sha256=ce28394757ba65fa1ff3a3010a1f67720f372c877f7d27bc23176a53e2cfa3a4 sha256: ce28394757ba65fa1ff3a3010a1f67720f372c877f7d27bc23176a53e2cfa3a4 requires_python: '>=3.10' -- kind: conda - name: dav1d - version: 1.2.1 - build: hb547adb_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/dav1d-1.2.1-hb547adb_0.conda - sha256: 93e077b880a85baec8227e8c72199220c7f87849ad32d02c14fb3807368260b8 - md5: 5a74cdee497e6b65173e10d94582fae6 - license: BSD-2-Clause - license_family: BSD - purls: [] - size: 316394 - timestamp: 1685695959391 -- kind: conda - name: dav1d - version: 1.2.1 - build: hd590300_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/dav1d-1.2.1-hd590300_0.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/dav1d-1.2.1-hd590300_0.conda sha256: 22053a5842ca8ee1cf8e1a817138cdb5e647eb2c46979f84153f6ad7bde73020 md5: 418c6ca5929a611cbd69204907a83995 depends: @@ -4811,13 +4907,15 @@ packages: purls: [] size: 760229 timestamp: 1685695754230 -- kind: conda - name: dbus - version: 1.13.6 - build: h5008d03_3 - build_number: 3 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.13.6-h5008d03_3.tar.bz2 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/dav1d-1.2.1-hb547adb_0.conda + sha256: 93e077b880a85baec8227e8c72199220c7f87849ad32d02c14fb3807368260b8 + md5: 5a74cdee497e6b65173e10d94582fae6 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 316394 + timestamp: 1685695959391 +- conda: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.13.6-h5008d03_3.tar.bz2 sha256: 8f5f995699a2d9dbdd62c61385bfeeb57c82a681a7c8c5313c395aa0ccab68a5 md5: ecfff944ba3960ecb334b9a2663d708d depends: @@ -4829,15 +4927,9 @@ packages: purls: [] size: 618596 timestamp: 1640112124844 -- kind: conda - name: debugpy - version: 1.8.5 - build: py312h2ec8cdc_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/debugpy-1.8.5-py312h2ec8cdc_1.conda - sha256: 63b027e5605955d22d6bd491316c81876363bce36c7b5fea006a664337d77686 - md5: f89b813bd9fe5ae6e3b7d17e17801f68 +- conda: https://conda.anaconda.org/conda-forge/linux-64/debugpy-1.8.11-py312h2ec8cdc_0.conda + sha256: 3d800be438a76d8a636219afd63a617737729867af5800d50fc72e71ac4f27f1 + md5: 0235a6da7d128c7e068973c4de62fc7b depends: - __glibc >=2.17,<3.0.a0 - libgcc >=13 @@ -4848,20 +4940,14 @@ packages: license_family: MIT purls: - pkg:pypi/debugpy?source=project-defined-mapping - size: 2085616 - timestamp: 1725269284102 -- kind: conda - name: debugpy - version: 1.8.5 - build: py312hde4cb15_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/debugpy-1.8.5-py312hde4cb15_1.conda - sha256: 5124effa4a8238c6b49be9ac71cf2c8a20712fbf62a0f76527f14ba618bc9441 - md5: d1489234be14b26357641e8a80b4a093 + size: 2668691 + timestamp: 1734159098550 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/debugpy-1.8.11-py312hd8f9ff3_0.conda + sha256: c219e3ba0cf97fdd9fa3d8601f8d37a7fe584cc2f31e199a820fa005649871ea + md5: 0f4c9c498b7ca4f010f7de44463c5403 depends: - __osx >=11.0 - - libcxx >=17 + - libcxx >=18 - python >=3.12,<3.13.0a0 - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 @@ -4869,32 +4955,20 @@ packages: license_family: MIT purls: - pkg:pypi/debugpy?source=project-defined-mapping - size: 2092223 - timestamp: 1725269494048 -- kind: conda - name: decorator - version: 5.1.1 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/decorator-5.1.1-pyhd8ed1ab_0.tar.bz2 - sha256: 328a6a379f9bdfd0230e51de291ce858e6479411ea4b0545fb377c71662ef3e2 - md5: 43afe5ab04e35e17ba28649471dd7364 + size: 2517686 + timestamp: 1734159183809 +- conda: https://conda.anaconda.org/conda-forge/noarch/decorator-5.1.1-pyhd8ed1ab_1.conda + sha256: 84e5120c97502a3785e8c3241c3bf51f64b4d445f13b4d2445db00d9816fe479 + md5: d622d8d7ee8868870f9cbe259f381181 depends: - - python >=3.5 + - python >=3.9 license: BSD-2-Clause license_family: BSD purls: - pkg:pypi/decorator?source=project-defined-mapping - size: 12072 - timestamp: 1641555714315 -- kind: conda - name: defusedxml - version: 0.7.1 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/defusedxml-0.7.1-pyhd8ed1ab_0.tar.bz2 + size: 14068 + timestamp: 1733236549190 +- conda: https://conda.anaconda.org/conda-forge/noarch/defusedxml-0.7.1-pyhd8ed1ab_0.tar.bz2 sha256: 9717a059677553562a8f38ff07f3b9f61727bd614f505658b0a5ecbcf8df89be md5: 961b3a227b437d82ad7054484cfa71b2 depends: @@ -4905,26 +4979,21 @@ packages: - pkg:pypi/defusedxml?source=project-defined-mapping size: 24062 timestamp: 1615232388757 -- kind: pypi +- pypi: https://files.pythonhosted.org/packages/1d/8f/c7f227eb42cfeaddce3eb0c96c60cbca37797fa7b34f8e1aeadf6c5c0983/Deprecated-1.2.15-py2.py3-none-any.whl name: deprecated - version: 1.2.14 - url: https://files.pythonhosted.org/packages/20/8d/778b7d51b981a96554f29136cd59ca7880bf58094338085bcf2a979a0e6a/Deprecated-1.2.14-py2.py3-none-any.whl - sha256: 6fac8b097794a90302bdbb17b9b815e732d3c4720583ff1b198499d78470466c + version: 1.2.15 + sha256: 353bc4a8ac4bfc96800ddab349d89c25dec1079f65fd53acdcc1e0b975b21320 requires_dist: - - wrapt<2,>=1.10 + - wrapt>=1.10,<2 - tox ; extra == 'dev' - pytest ; extra == 'dev' - pytest-cov ; extra == 'dev' - bump2version<1 ; extra == 'dev' - sphinx<2 ; extra == 'dev' + - jinja2~=3.0.3 ; extra == 'dev' + - setuptools ; python_full_version >= '3.12' and extra == 'dev' requires_python: '>=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*' -- kind: conda - name: distinctipy - version: 1.3.4 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/distinctipy-1.3.4-pyhd8ed1ab_0.conda +- conda: https://conda.anaconda.org/conda-forge/noarch/distinctipy-1.3.4-pyhd8ed1ab_0.conda sha256: 37a45d5ec20ceb0e59408d3bcbbe4c3296ec0d46ea5ed09bfca3f65a3764fd08 md5: aefc99db1bcbb65f9be44b54db9f849e depends: @@ -4936,22 +5005,15 @@ packages: - pkg:pypi/distinctipy?source=project-defined-mapping size: 29896 timestamp: 1704994701404 -- kind: pypi +- pypi: https://files.pythonhosted.org/packages/10/10/5f9eed00b1186921e447960443f03cda6374cba8cd5cf7aff2b42ecb8a0e/dm_tree-0.1.8-cp312-cp312-macosx_11_0_arm64.whl name: dm-tree version: 0.1.8 - url: https://files.pythonhosted.org/packages/10/10/5f9eed00b1186921e447960443f03cda6374cba8cd5cf7aff2b42ecb8a0e/dm_tree-0.1.8-cp312-cp312-macosx_11_0_arm64.whl sha256: 435227cf3c5dc63f4de054cf3d00183790bd9ead4c3623138c74dde7f67f521b -- kind: pypi +- pypi: https://files.pythonhosted.org/packages/c9/d4/8cbb857612ca69763ee4f4f97c7b91659df1d373d62237cb9c772e55ae97/dm_tree-0.1.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl name: dm-tree version: 0.1.8 - url: https://files.pythonhosted.org/packages/c9/d4/8cbb857612ca69763ee4f4f97c7b91659df1d373d62237cb9c772e55ae97/dm_tree-0.1.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl sha256: c0a94aba18a35457a1b5cd716fd7b46c5dafdc4cf7869b4bae665b91c4682a8e -- kind: conda - name: double-conversion - version: 3.3.0 - build: h59595ed_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/double-conversion-3.3.0-h59595ed_0.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/double-conversion-3.3.0-h59595ed_0.conda sha256: 9eee491a73b67fd64379cf715f85f8681568ebc1f02f9e11b4c50d46a3323544 md5: c2f83a5ddadadcdb08fe05863295ee97 depends: @@ -4962,12 +5024,18 @@ packages: purls: [] size: 78645 timestamp: 1686489937183 -- kind: conda - name: elfutils - version: '0.191' - build: h924a536_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/elfutils-0.191-h924a536_0.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/eigen-3.4.0-h00ab1b0_0.conda + sha256: 53b15a98aadbe0704479bacaf7a5618fcb32d1577be320630674574241639b34 + md5: b1b879d6d093f55dd40d58b5eb2f0699 + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + license: MPL-2.0 + license_family: MOZILLA + purls: [] + size: 1088433 + timestamp: 1690272126173 +- conda: https://conda.anaconda.org/conda-forge/linux-64/elfutils-0.191-h924a536_0.conda sha256: f65caab27989a545a058933538acdeb7e5f4aaafe6304de770e337fe7be0f586 md5: 73d050766060acd2b3a289f27d857090 depends: @@ -4986,107 +5054,109 @@ packages: purls: [] size: 1184130 timestamp: 1709347008329 -- kind: conda - name: entrypoints - version: '0.4' - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/entrypoints-0.4-pyhd8ed1ab_0.tar.bz2 - sha256: 2ec4a0900a4a9f42615fc04d0fb3286b796abe56590e8e042f6ec25e102dd5af - md5: 3cf04868fee0a029769bd41f4b2fbf2d +- conda: https://conda.anaconda.org/conda-forge/linux-64/elfutils-0.192-h7f4e02f_1.conda + sha256: 16097884784f9eb81625e0e2a566d1a6ec677fe39916b41926629fa723874f45 + md5: 369ce48a589a2aac91906c9ed89dd6e8 depends: - - python >=3.6 + - __glibc >=2.17,<3.0.a0 + - bzip2 >=1.0.8,<2.0a0 + - libarchive >=3.7.7,<3.8.0a0 + - libcurl >=8.10.1,<9.0a0 + - libgcc >=13 + - liblzma >=5.6.3,<6.0a0 + - libmicrohttpd >=1.0.1,<1.1.0a0 + - libsqlite >=3.47.2,<4.0a0 + - libstdcxx >=13 + - libzlib >=1.3.1,<2.0a0 + - zstd >=1.5.6,<1.6.0a0 + license: LGPL-3.0-only + license_family: LGPL + purls: [] + size: 1121608 + timestamp: 1733937284793 +- conda: https://conda.anaconda.org/conda-forge/linux-64/embree-3.13.0-habf647b_1.conda + sha256: 79da1b12b5e937388ffa36c6b7bcc2904af28a1fa7b80bee0adc6787d27f6469 + md5: 57d72012e3bfd4b4e0328be1cbe7d102 + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - tbb >=2021.11.0 + license: Apache-2.0 + license_family: APACHE + purls: [] + size: 8017017 + timestamp: 1709640585549 +- conda: https://conda.anaconda.org/conda-forge/noarch/entrypoints-0.4-pyhd8ed1ab_1.conda + sha256: 80f579bfc71b3dab5bef74114b89e26c85cb0df8caf4c27ab5ffc16363d57ee7 + md5: 3366592d3c219f2731721f11bc93755c + depends: + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/entrypoints?source=project-defined-mapping - size: 9199 - timestamp: 1643888357950 -- kind: pypi + size: 11259 + timestamp: 1733327239578 +- pypi: https://files.pythonhosted.org/packages/3a/af/411e94c165229882eb2d0a329114826aa52c7c61ef3108d0d3d8ad7189ed/equinox-0.11.10-py3-none-any.whl name: equinox - version: 0.11.5 - url: https://files.pythonhosted.org/packages/08/0f/1d22866c1ff666766b2c207487bef3f06edae096df2f6b4176d5f7072a10/equinox-0.11.5-py3-none-any.whl - sha256: 470e93b7f6a47ae794e350a702b1931ca80eb2efebdbea997be3a8d6172acb4e + version: 0.11.10 + sha256: ee6809e31664b92487b247f811fca48a2107f7ec958084b2294af2ee8a750e3b requires_dist: - - jax!=0.4.27,>=0.4.13 + - jax>=0.4.13,!=0.4.27 - jaxtyping>=0.2.20 - typing-extensions>=4.5.0 - requires_python: ~=3.9 -- kind: conda - name: exceptiongroup - version: 1.2.2 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.2-pyhd8ed1ab_0.conda - sha256: e0edd30c4b7144406bb4da975e6bb97d6bc9c0e999aa4efe66ae108cada5d5b5 - md5: d02ae936e42063ca46af6cdad2dbd1e0 + requires_python: '>=3.9' +- conda: https://conda.anaconda.org/conda-forge/noarch/etils-1.10.0-pyhd8ed1ab_1.conda + sha256: 793d09e5fa2c575e42c6862d7654d524bca68318c4fbb0a094c90b604e26d81b + md5: 3f0f95562447041f5f719a65ef9d921c depends: - - python >=3.7 + - python >=3.10 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/etils?source=project-defined-mapping + size: 783985 + timestamp: 1734005284098 +- conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.2-pyhd8ed1ab_1.conda + sha256: cbde2c64ec317118fc06b223c5fd87c8a680255e7348dd60e7b292d2e103e701 + md5: a16662747cdeb9abbac74d0057cc976e + depends: + - python >=3.9 license: MIT and PSF-2.0 purls: - pkg:pypi/exceptiongroup?source=project-defined-mapping - size: 20418 - timestamp: 1720869435725 -- kind: conda - name: executing - version: 2.1.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/executing-2.1.0-pyhd8ed1ab_0.conda - sha256: a52d7516e2e11d3eb10908e10d3eb3f8ef267fea99ed9b09d52d96c4db3441b8 - md5: d0441db20c827c11721889a241df1220 + size: 20486 + timestamp: 1733208916977 +- conda: https://conda.anaconda.org/conda-forge/noarch/executing-2.1.0-pyhd8ed1ab_1.conda + sha256: 28d25ea375ebab4bf7479228f8430db20986187b04999136ff5c722ebd32eb60 + md5: ef8b5fca76806159fc25b4f48d8737eb depends: - - python >=2.7 + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/executing?source=project-defined-mapping - size: 28337 - timestamp: 1725214501850 -- kind: conda - name: expat - version: 2.6.3 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/expat-2.6.3-h5888daf_0.conda - sha256: 65bd479c75ce876f26600cb230d6ebc474086e31fa384af9b4282b36842ed7e2 - md5: 6595440079bed734b113de44ffd3cd0a - depends: - - __glibc >=2.17,<3.0.a0 - - libexpat 2.6.3 h5888daf_0 - - libgcc >=13 - license: MIT - license_family: MIT - purls: [] - size: 137891 - timestamp: 1725568750673 -- kind: conda - name: expat - version: 2.6.3 - build: hf9b8971_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/expat-2.6.3-hf9b8971_0.conda - sha256: 4d52ad7a7eb39f71a38bbf2b6377183024bd3bf4cfb5dcd33b31636a6f9a7abc - md5: 726bbcf3549fe22b4556285d946fed2d + size: 28348 + timestamp: 1733569440265 +- conda: https://conda.anaconda.org/conda-forge/linux-64/expat-2.6.4-h5888daf_0.conda + sha256: 1848c7db9e264e3b8036ee133d570dd880422983cd20dd9585a505289606d276 + md5: 1d6afef758879ef5ee78127eb4cd2c4a depends: - - __osx >=11.0 - - libexpat 2.6.3 hf9b8971_0 + - __glibc >=2.17,<3.0.a0 + - libexpat 2.6.4 h5888daf_0 + - libgcc >=13 license: MIT license_family: MIT purls: [] - size: 125005 - timestamp: 1725568799108 -- kind: pypi + size: 138145 + timestamp: 1730967050578 +- pypi: https://files.pythonhosted.org/packages/52/b3/7e4df40e585df024fac2f80d1a2d579c854ac37109675db2b0cc22c0bb9e/fastapi-0.115.6-py3-none-any.whl name: fastapi - version: 0.114.0 - url: https://files.pythonhosted.org/packages/d0/80/17037f322c280efbc623e341358d38d0299c6ee899d619a879b3593aa6da/fastapi-0.114.0-py3-none-any.whl - sha256: fee75aa1b1d3d73f79851c432497e4394e413e1dece6234f68d3ce250d12760a + version: 0.115.6 + sha256: e9240b29e36fa8f4bb7290316988e90c381e5092e0cbe84e7818cc3713bcf305 requires_dist: - - starlette<0.39.0,>=0.37.2 - - pydantic!=1.8,!=1.8.1,!=2.0.0,!=2.0.1,!=2.1.0,<3.0.0,>=1.7.4 + - starlette>=0.40.0,<0.42.0 + - pydantic>=1.7.4,!=1.8,!=1.8.1,!=2.0.0,!=2.0.1,!=2.1.0,<3.0.0 - typing-extensions>=4.8.0 - fastapi-cli[standard]>=0.0.5 ; extra == 'standard' - httpx>=0.23.0 ; extra == 'standard' @@ -5100,24 +5170,46 @@ packages: - python-multipart>=0.0.7 ; extra == 'all' - itsdangerous>=1.1.0 ; extra == 'all' - pyyaml>=5.3.1 ; extra == 'all' - - ujson!=4.0.2,!=4.1.0,!=4.2.0,!=4.3.0,!=5.0.0,!=5.1.0,>=4.0.1 ; extra == 'all' + - ujson>=4.0.1,!=4.0.2,!=4.1.0,!=4.2.0,!=4.3.0,!=5.0.0,!=5.1.0 ; extra == 'all' - orjson>=3.2.1 ; extra == 'all' - email-validator>=2.0.0 ; extra == 'all' - uvicorn[standard]>=0.12.0 ; extra == 'all' - pydantic-settings>=2.0.0 ; extra == 'all' - pydantic-extra-types>=2.0.0 ; extra == 'all' requires_python: '>=3.8' -- kind: conda - name: ffmpeg - version: 6.1.2 - build: gpl_h226ea3b_102 - build_number: 102 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/ffmpeg-6.1.2-gpl_h226ea3b_102.conda - sha256: aa64c9724fc87f7a4867a79f9dcb5d2d98247ec41f93687f71dc489efb78c2ef - md5: 53ed7cb9007c617ad951f7aa9f4c92a4 +- conda: https://conda.anaconda.org/conda-forge/linux-64/fcl-0.7.0-h543440a_6.conda + sha256: 3df69742828d1b52d72aba9b336895d6cd8052040f108ec61c4acf32fe274b01 + md5: a69e2481c68b9f8bdef3287cceee30ae depends: - __glibc >=2.17,<3.0.a0 + - flann >=1.9.2,<1.9.3.0a0 + - libccd-double >=2.1,<2.2.0a0 + - libgcc >=13 + - libstdcxx >=13 + - octomap >=1.10.0,<1.11.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 1553565 + timestamp: 1731217767246 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/fcl-0.7.0-he078184_6.conda + sha256: 97c971a2e04e8a8e5dd54d50307009635df00f2ec680078fb232f235e86fc8c9 + md5: 204ba0540488041dd50f0beaecb0ed9a + depends: + - __osx >=11.0 + - flann >=1.9.2,<1.9.3.0a0 + - libccd-double >=2.1,<2.2.0a0 + - libcxx >=16 + - octomap >=1.10.0,<1.11.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 1042149 + timestamp: 1731217421887 +- conda: https://conda.anaconda.org/conda-forge/linux-64/ffmpeg-6.1.1-gpl_h853fe30_113.conda + sha256: b87c35b0fd64c5280b8db40cedbec7f9c421cb11f16803b7e4fd29274c1dc298 + md5: 802f1dc6254553bdb53765d6f8f34147 + depends: - aom >=3.9.1,<3.10.0a0 - bzip2 >=1.0.8,<2.0a0 - dav1d >=1.2.1,<1.2.2.0a0 @@ -5125,115 +5217,151 @@ packages: - fonts-conda-ecosystem - freetype >=2.12.1,<3.0a0 - gmp >=6.3.0,<7.0a0 - - gnutls >=3.8.7,<3.9.0a0 + - gnutls >=3.7.9,<3.8.0a0 + - harfbuzz >=8.5.0,<9.0a0 + - lame >=3.100,<3.101.0a0 + - libass >=0.17.1,<0.17.2.0a0 + - libgcc-ng >=12 + - libiconv >=1.17,<2.0a0 + - libopenvino >=2024.2.0,<2024.2.1.0a0 + - libopenvino-auto-batch-plugin >=2024.2.0,<2024.2.1.0a0 + - libopenvino-auto-plugin >=2024.2.0,<2024.2.1.0a0 + - libopenvino-hetero-plugin >=2024.2.0,<2024.2.1.0a0 + - libopenvino-intel-cpu-plugin >=2024.2.0,<2024.2.1.0a0 + - libopenvino-intel-gpu-plugin >=2024.2.0,<2024.2.1.0a0 + - libopenvino-intel-npu-plugin >=2024.2.0,<2024.2.1.0a0 + - libopenvino-ir-frontend >=2024.2.0,<2024.2.1.0a0 + - libopenvino-onnx-frontend >=2024.2.0,<2024.2.1.0a0 + - libopenvino-paddle-frontend >=2024.2.0,<2024.2.1.0a0 + - libopenvino-pytorch-frontend >=2024.2.0,<2024.2.1.0a0 + - libopenvino-tensorflow-frontend >=2024.2.0,<2024.2.1.0a0 + - libopenvino-tensorflow-lite-frontend >=2024.2.0,<2024.2.1.0a0 + - libopus >=1.3.1,<2.0a0 + - libstdcxx-ng >=12 + - libva >=2.21.0,<3.0a0 + - libvpx >=1.14.1,<1.15.0a0 + - libxcb >=1.15,<1.16.0a0 + - libxml2 >=2.12.7,<3.0a0 + - libzlib >=1.3.1,<2.0a0 + - openh264 >=2.4.1,<2.4.2.0a0 + - svt-av1 >=2.1.0,<2.1.1.0a0 + - x264 >=1!164.3095,<1!165 + - x265 >=3.5,<3.6.0a0 + - xorg-libx11 >=1.8.9,<2.0a0 + - xz >=5.2.6,<6.0a0 + license: GPL-2.0-or-later + license_family: GPL + purls: [] + size: 9790817 + timestamp: 1718838865365 +- conda: https://conda.anaconda.org/conda-forge/linux-64/ffmpeg-7.1.0-gpl_heed6883_705.conda + sha256: 3637be79049c92a7ff379a3ef97499c6fe87c23718e0b0ed90207e25571fe1f7 + md5: 77806f0330381aed7f104a1b67af7cea + depends: + - __glibc >=2.17,<3.0.a0 + - aom >=3.9.1,<3.10.0a0 + - bzip2 >=1.0.8,<2.0a0 + - dav1d >=1.2.1,<1.2.2.0a0 + - fontconfig >=2.15.0,<3.0a0 + - fonts-conda-ecosystem + - freetype >=2.12.1,<3.0a0 + - gmp >=6.3.0,<7.0a0 - harfbuzz >=9.0.0,<10.0a0 - lame >=3.100,<3.101.0a0 - libass >=0.17.3,<0.17.4.0a0 - - libgcc-ng >=13 + - libexpat >=2.6.4,<3.0a0 + - libgcc >=13 - libiconv >=1.17,<2.0a0 - - libopenvino >=2024.3.0,<2024.3.1.0a0 - - libopenvino-auto-batch-plugin >=2024.3.0,<2024.3.1.0a0 - - libopenvino-auto-plugin >=2024.3.0,<2024.3.1.0a0 - - libopenvino-hetero-plugin >=2024.3.0,<2024.3.1.0a0 - - libopenvino-intel-cpu-plugin >=2024.3.0,<2024.3.1.0a0 - - libopenvino-intel-gpu-plugin >=2024.3.0,<2024.3.1.0a0 - - libopenvino-intel-npu-plugin >=2024.3.0,<2024.3.1.0a0 - - libopenvino-ir-frontend >=2024.3.0,<2024.3.1.0a0 - - libopenvino-onnx-frontend >=2024.3.0,<2024.3.1.0a0 - - libopenvino-paddle-frontend >=2024.3.0,<2024.3.1.0a0 - - libopenvino-pytorch-frontend >=2024.3.0,<2024.3.1.0a0 - - libopenvino-tensorflow-frontend >=2024.3.0,<2024.3.1.0a0 - - libopenvino-tensorflow-lite-frontend >=2024.3.0,<2024.3.1.0a0 + - libopenvino >=2024.4.0,<2024.4.1.0a0 + - libopenvino-auto-batch-plugin >=2024.4.0,<2024.4.1.0a0 + - libopenvino-auto-plugin >=2024.4.0,<2024.4.1.0a0 + - libopenvino-hetero-plugin >=2024.4.0,<2024.4.1.0a0 + - libopenvino-intel-cpu-plugin >=2024.4.0,<2024.4.1.0a0 + - libopenvino-intel-gpu-plugin >=2024.4.0,<2024.4.1.0a0 + - libopenvino-intel-npu-plugin >=2024.4.0,<2024.4.1.0a0 + - libopenvino-ir-frontend >=2024.4.0,<2024.4.1.0a0 + - libopenvino-onnx-frontend >=2024.4.0,<2024.4.1.0a0 + - libopenvino-paddle-frontend >=2024.4.0,<2024.4.1.0a0 + - libopenvino-pytorch-frontend >=2024.4.0,<2024.4.1.0a0 + - libopenvino-tensorflow-frontend >=2024.4.0,<2024.4.1.0a0 + - libopenvino-tensorflow-lite-frontend >=2024.4.0,<2024.4.1.0a0 - libopus >=1.3.1,<2.0a0 - - libstdcxx-ng >=13 + - librsvg >=2.58.4,<3.0a0 + - libstdcxx >=13 - libva >=2.22.0,<3.0a0 - libvpx >=1.14.1,<1.15.0a0 - - libxcb >=1.16,<1.17.0a0 - - libxml2 >=2.12.7,<3.0a0 + - libxcb >=1.17.0,<2.0a0 + - libxml2 >=2.13.5,<3.0a0 - libzlib >=1.3.1,<2.0a0 - - openh264 >=2.4.1,<2.4.2.0a0 - - svt-av1 >=2.2.1,<2.2.2.0a0 + - openh264 >=2.5.0,<2.5.1.0a0 + - openssl >=3.4.0,<4.0a0 + - svt-av1 >=2.3.0,<2.3.1.0a0 - x264 >=1!164.3095,<1!165 - x265 >=3.5,<3.6.0a0 - - xorg-libx11 >=1.8.9,<2.0a0 + - xorg-libx11 >=1.8.10,<2.0a0 - xz >=5.2.6,<6.0a0 + constrains: + - __cuda >=12.4 license: GPL-2.0-or-later license_family: GPL purls: [] - size: 9890555 - timestamp: 1724646335505 -- kind: conda - name: ffmpeg - version: 6.1.2 - build: gpl_h3ef3969_102 - build_number: 102 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/ffmpeg-6.1.2-gpl_h3ef3969_102.conda - sha256: d88267b52f88fdc6b332fb75242199acc916be07d2d410818da6139ab6cee718 - md5: 20bb671f432f0d6b327c9517547e9840 + size: 10337715 + timestamp: 1732156362272 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ffmpeg-6.1.2-gpl_hbafc610_106.conda + sha256: f21efbafbdaeff15ccefe24e6a39df00c31823b26ca88f7dd65893ff3e9d2d74 + md5: ed763c1f083a698c8ca559804152ee48 depends: - __osx >=11.0 - aom >=3.9.1,<3.10.0a0 - bzip2 >=1.0.8,<2.0a0 - dav1d >=1.2.1,<1.2.2.0a0 - - fontconfig >=2.14.2,<3.0a0 + - fontconfig >=2.15.0,<3.0a0 - fonts-conda-ecosystem - freetype >=2.12.1,<3.0a0 - gmp >=6.3.0,<7.0a0 - - gnutls >=3.8.7,<3.9.0a0 - harfbuzz >=9.0.0,<10.0a0 - lame >=3.100,<3.101.0a0 - libass >=0.17.3,<0.17.4.0a0 - - libcxx >=17 + - libcxx >=18 + - libexpat >=2.6.3,<3.0a0 - libiconv >=1.17,<2.0a0 - - libopenvino >=2024.3.0,<2024.3.1.0a0 - - libopenvino-arm-cpu-plugin >=2024.3.0,<2024.3.1.0a0 - - libopenvino-auto-batch-plugin >=2024.3.0,<2024.3.1.0a0 - - libopenvino-auto-plugin >=2024.3.0,<2024.3.1.0a0 - - libopenvino-hetero-plugin >=2024.3.0,<2024.3.1.0a0 - - libopenvino-ir-frontend >=2024.3.0,<2024.3.1.0a0 - - libopenvino-onnx-frontend >=2024.3.0,<2024.3.1.0a0 - - libopenvino-paddle-frontend >=2024.3.0,<2024.3.1.0a0 - - libopenvino-pytorch-frontend >=2024.3.0,<2024.3.1.0a0 - - libopenvino-tensorflow-frontend >=2024.3.0,<2024.3.1.0a0 - - libopenvino-tensorflow-lite-frontend >=2024.3.0,<2024.3.1.0a0 + - libopenvino >=2024.4.0,<2024.4.1.0a0 + - libopenvino-arm-cpu-plugin >=2024.4.0,<2024.4.1.0a0 + - libopenvino-auto-batch-plugin >=2024.4.0,<2024.4.1.0a0 + - libopenvino-auto-plugin >=2024.4.0,<2024.4.1.0a0 + - libopenvino-hetero-plugin >=2024.4.0,<2024.4.1.0a0 + - libopenvino-ir-frontend >=2024.4.0,<2024.4.1.0a0 + - libopenvino-onnx-frontend >=2024.4.0,<2024.4.1.0a0 + - libopenvino-paddle-frontend >=2024.4.0,<2024.4.1.0a0 + - libopenvino-pytorch-frontend >=2024.4.0,<2024.4.1.0a0 + - libopenvino-tensorflow-frontend >=2024.4.0,<2024.4.1.0a0 + - libopenvino-tensorflow-lite-frontend >=2024.4.0,<2024.4.1.0a0 - libopus >=1.3.1,<2.0a0 - libvpx >=1.14.1,<1.15.0a0 - - libxml2 >=2.12.7,<3.0a0 + - libxml2 >=2.13.4,<3.0a0 - libzlib >=1.3.1,<2.0a0 - openh264 >=2.4.1,<2.4.2.0a0 - - svt-av1 >=2.2.1,<2.2.2.0a0 + - openssl >=3.3.2,<4.0a0 + - svt-av1 >=2.3.0,<2.3.1.0a0 - x264 >=1!164.3095,<1!165 - x265 >=3.5,<3.6.0a0 - xz >=5.2.6,<6.0a0 license: GPL-2.0-or-later license_family: GPL purls: [] - size: 8643313 - timestamp: 1724646269620 -- kind: conda - name: filelock - version: 3.15.4 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.15.4-pyhd8ed1ab_0.conda - sha256: f78d9c0be189a77cb0c67d02f33005f71b89037a85531996583fb79ff3fe1a0a - md5: 0e7e4388e9d5283e22b35a9443bdbcc9 + size: 8664762 + timestamp: 1730672122327 +- conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.16.1-pyhd8ed1ab_1.conda + sha256: 18dca6e2194732df7ebf824abaefe999e4765ebe8e8a061269406ab88fc418b9 + md5: d692e9ba6f92dc51484bf3477e36ce7c depends: - - python >=3.7 + - python >=3.9 license: Unlicense purls: - pkg:pypi/filelock?source=project-defined-mapping - size: 17592 - timestamp: 1719088395353 -- kind: conda - name: fire - version: 0.6.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/fire-0.6.0-pyhd8ed1ab_0.conda + size: 17441 + timestamp: 1733240909987 +- conda: https://conda.anaconda.org/conda-forge/noarch/fire-0.6.0-pyhd8ed1ab_0.conda sha256: bfc87eb02451144794e441bc58f616bef0a7eb7d0179852ad590a60e1b704371 md5: e9ed10aa8fa1dd6782940b95c942a6ae depends: @@ -5246,13 +5374,93 @@ packages: - pkg:pypi/fire?source=project-defined-mapping size: 85151 timestamp: 1710221690085 -- kind: conda - name: font-ttf-dejavu-sans-mono - version: '2.37' - build: hab24e00_0 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 +- conda: https://conda.anaconda.org/conda-forge/linux-64/flann-1.9.2-h776a335_3.conda + sha256: 4bc82c9674b14e72523e3383a789ecd8fc144cf95cf7b39bb3adab6b4522740a + md5: ba80b547621ef03339157ebd25cef8bc + depends: + - __glibc >=2.17,<3.0.a0 + - _openmp_mutex >=4.5 + - hdf5 >=1.14.3,<1.14.4.0a0 + - libgcc >=13 + - libstdcxx >=13 + - lz4-c >=1.9.3,<1.10.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 1574025 + timestamp: 1733306733759 +- conda: https://conda.anaconda.org/conda-forge/linux-64/flann-1.9.2-h783367e_4.conda + sha256: 7e6b9d30281562496c53067e01e6e84dcbb16f43273510454463351155a7c80e + md5: 6998a241450abd1cb9305f4608001870 + depends: + - __glibc >=2.17,<3.0.a0 + - _openmp_mutex >=4.5 + - hdf5 >=1.14.3,<1.14.4.0a0 + - libgcc >=13 + - libstdcxx >=13 + - lz4-c >=1.10.0,<1.11.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 1564105 + timestamp: 1733524739597 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/flann-1.9.2-h4918f9b_3.conda + sha256: 433831e530aa4d891a2c73ce5ea00485d14b4155db8a13973eff3c7e3c17f9c5 + md5: 0ec1fce79f9767e73064baf943253cd5 + depends: + - __osx >=11.0 + - hdf5 >=1.14.3,<1.14.4.0a0 + - libcxx >=18 + - llvm-openmp >=18.1.8 + - lz4-c >=1.9.3,<1.10.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 1466127 + timestamp: 1733307019663 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/flann-1.9.2-h5d00db4_4.conda + sha256: 8140d97e50493b58c82a3b8272e5fccd3621b2049c0ec8998abc3ee8b50e485e + md5: f71379e5496ea562900943381fa31d24 + depends: + - __osx >=11.0 + - hdf5 >=1.14.3,<1.14.4.0a0 + - libcxx >=18 + - llvm-openmp >=18.1.8 + - lz4-c >=1.10.0,<1.11.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 1470167 + timestamp: 1733524919181 +- conda: https://conda.anaconda.org/conda-forge/noarch/flask-3.1.0-pyhff2d567_0.conda + sha256: 5eb604e7993c519d8ac5bfe9ce0a50709d4c502bafda4d38f0d4d54da2411a36 + md5: 3963487fb67f4deb3e16728ad101da7c + depends: + - blinker >=1.9 + - click >=8.1.3 + - importlib-metadata >=3.6 + - itsdangerous >=2.2 + - jinja2 >=3.1.2 + - python >=3.9 + - werkzeug >=3.1 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/flask?source=project-defined-mapping + size: 81448 + timestamp: 1731556474301 +- conda: https://conda.anaconda.org/conda-forge/linux-64/fmt-9.1.0-h924138e_0.tar.bz2 + sha256: bd48506faffa86e07f7b40d54f2d7e13b0fc956eda9760236750f5ea20db7129 + md5: b57864c85261a0fbc7132d2cc17478c7 + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + license: MIT + license_family: MIT + purls: [] + size: 189730 + timestamp: 1661661115134 +- conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 sha256: 58d7f40d2940dd0a8aa28651239adbf5613254df0f75789919c4e6762054403b md5: 0c96522c6bdaed4b1566d11387caaf45 license: BSD-3-Clause @@ -5260,13 +5468,7 @@ packages: purls: [] size: 397370 timestamp: 1566932522327 -- kind: conda - name: font-ttf-inconsolata - version: '3.000' - build: h77eed37_0 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 +- conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 sha256: c52a29fdac682c20d252facc50f01e7c2e7ceac52aa9817aaf0bb83f7559ec5c md5: 34893075a5c9e55cdafac56607368fc6 license: OFL-1.1 @@ -5274,13 +5476,7 @@ packages: purls: [] size: 96530 timestamp: 1620479909603 -- kind: conda - name: font-ttf-source-code-pro - version: '2.038' - build: h77eed37_0 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2 +- conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2 sha256: 00925c8c055a2275614b4d983e1df637245e19058d79fc7dd1a93b8d9fb4b139 md5: 4d59c254e01d9cde7957100457e2d5fb license: OFL-1.1 @@ -5288,64 +5484,43 @@ packages: purls: [] size: 700814 timestamp: 1620479612257 -- kind: conda - name: font-ttf-ubuntu - version: '0.83' - build: h77eed37_2 - build_number: 2 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_2.conda - sha256: c940f6e969143e13a3a9660abb3c7e7e23b8319efb29dbdd5dee0b9939236e13 - md5: cbbe59391138ea5ad3658c76912e147f +- conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_3.conda + sha256: 2821ec1dc454bd8b9a31d0ed22a7ce22422c0aef163c59f49dfdf915d0f0ca14 + md5: 49023d73832ef61042f6a237cb2687e7 license: LicenseRef-Ubuntu-Font-Licence-Version-1.0 license_family: Other purls: [] - size: 1622566 - timestamp: 1714483134319 -- kind: conda - name: fontconfig - version: 2.14.2 - build: h14ed4e7_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/fontconfig-2.14.2-h14ed4e7_0.conda - sha256: 155d534c9037347ea7439a2c6da7c24ffec8e5dd278889b4c57274a1d91e0a83 - md5: 0f69b688f52ff6da70bccb7ff7001d1d - depends: - - expat >=2.5.0,<3.0a0 + size: 1620504 + timestamp: 1727511233259 +- conda: https://conda.anaconda.org/conda-forge/linux-64/fontconfig-2.15.0-h7e30c49_1.conda + sha256: 7093aa19d6df5ccb6ca50329ef8510c6acb6b0d8001191909397368b65b02113 + md5: 8f5b0b297b59e1ac160ad4beec99dbee + depends: + - __glibc >=2.17,<3.0.a0 - freetype >=2.12.1,<3.0a0 - - libgcc-ng >=12 - - libuuid >=2.32.1,<3.0a0 - - libzlib >=1.2.13,<2.0.0a0 + - libexpat >=2.6.3,<3.0a0 + - libgcc >=13 + - libuuid >=2.38.1,<3.0a0 + - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT purls: [] - size: 272010 - timestamp: 1674828850194 -- kind: conda - name: fontconfig - version: 2.14.2 - build: h82840c6_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/fontconfig-2.14.2-h82840c6_0.conda - sha256: 7094917fc6758186e17c61d8ee8fd2bbbe9f303b4addac61d918fa415c497e2b - md5: f77d47ddb6d3cc5b39b9bdf65635afbb - depends: - - expat >=2.5.0,<3.0a0 + size: 265599 + timestamp: 1730283881107 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/fontconfig-2.15.0-h1383a14_1.conda + sha256: f79d3d816fafbd6a2b0f75ebc3251a30d3294b08af9bb747194121f5efa364bc + md5: 7b29f48742cea5d1ccb5edd839cb5621 + depends: + - __osx >=11.0 - freetype >=2.12.1,<3.0a0 - - libzlib >=1.2.13,<2.0.0a0 + - libexpat >=2.6.3,<3.0a0 + - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT purls: [] - size: 237668 - timestamp: 1674829263740 -- kind: conda - name: fonts-conda-ecosystem - version: '1' - build: '0' - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2 + size: 234227 + timestamp: 1730284037572 +- conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2 sha256: a997f2f1921bb9c9d76e6fa2f6b408b7fa549edd349a77639c9fe7a23ea93e61 md5: fee5683a3f04bd15cbd8318b096a27ab depends: @@ -5355,13 +5530,7 @@ packages: purls: [] size: 3667 timestamp: 1566974674465 -- kind: conda - name: fonts-conda-forge - version: '1' - build: '0' - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-forge-1-0.tar.bz2 +- conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-forge-1-0.tar.bz2 sha256: 53f23a3319466053818540bcdf2091f253cbdbab1e0e9ae7b9e509dcaa2a5e38 md5: f766549260d6815b0c52253f1fb1bb29 depends: @@ -5374,81 +5543,59 @@ packages: purls: [] size: 4102 timestamp: 1566932280397 -- kind: conda - name: fonttools - version: 4.53.1 - build: py312h024a12e_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/fonttools-4.53.1-py312h024a12e_1.conda - sha256: c5b5ca1f92028e0e90a6205375bd8e7f5892eb4d0a2ba6ce2933ed78ef0d13b3 - md5: 5b9a2bdebe4a0652ef570212f470afcf +- conda: https://conda.anaconda.org/conda-forge/linux-64/fonttools-4.55.3-py312h178313f_0.conda + sha256: a5d26a5311fecbf8546a2fd056c7f4c350fa54da998e223b7d5cc74eab3971e1 + md5: 968104bfe69e21fadeb30edd9c3785f9 depends: - - __osx >=11.0 + - __glibc >=2.17,<3.0.a0 - brotli + - libgcc >=13 - munkres - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 + - unicodedata2 >=15.1.0 license: MIT license_family: MIT purls: - pkg:pypi/fonttools?source=project-defined-mapping - size: 2718315 - timestamp: 1725391752926 -- kind: conda - name: fonttools - version: 4.53.1 - build: py312h66e93f0_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/fonttools-4.53.1-py312h66e93f0_1.conda - sha256: 19e4bc017b219e02de712e948d48a23c8bb98dabe741c807949c7fb48abe71d8 - md5: 7abb7d39d482ac3b8e27e6c0fff3b168 + size: 2860392 + timestamp: 1733909107861 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/fonttools-4.55.3-py312h998013c_0.conda + sha256: d86c5c27ba6b942e192645ce1c93b7f5e41add67f68620460d986dcefab3bb31 + md5: 911d629633318fc366d27757efa218d2 depends: - - __glibc >=2.17,<3.0.a0 + - __osx >=11.0 - brotli - - libgcc >=13 - munkres - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 + - unicodedata2 >=15.1.0 license: MIT license_family: MIT purls: - pkg:pypi/fonttools?source=project-defined-mapping - size: 2797458 - timestamp: 1725391437161 -- kind: conda - name: fqdn - version: 1.5.1 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/fqdn-1.5.1-pyhd8ed1ab_0.tar.bz2 - sha256: 6cfd1f9bcd2358a69fb571f4b3af049b630d52647d906822dbedac03e84e4f63 - md5: 642d35437078749ef23a5dca2c9bb1f3 + size: 2750836 + timestamp: 1733909211860 +- conda: https://conda.anaconda.org/conda-forge/noarch/fqdn-1.5.1-pyhd8ed1ab_1.conda + sha256: 2509992ec2fd38ab27c7cdb42cf6cadc566a1cc0d1021a2673475d9fa87c6276 + md5: d3549fd50d450b6d9e7dddff25dd2110 depends: - cached-property >=1.3.0 - - python >=2.7,<4 + - python >=3.9,<4 license: MPL-2.0 license_family: MOZILLA purls: - pkg:pypi/fqdn?source=project-defined-mapping - size: 14395 - timestamp: 1638810388635 -- kind: conda - name: freeglut - version: 3.2.2 - build: ha6d2627_3 - build_number: 3 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/freeglut-3.2.2-ha6d2627_3.conda + size: 16705 + timestamp: 1733327494780 +- conda: https://conda.anaconda.org/conda-forge/linux-64/freeglut-3.2.2-ha6d2627_3.conda sha256: 676540a8e7f73a894cb1fcb870e7bec623ec1c0a2d277094fd713261a02d8d56 md5: 84ec3f5b46f3076be49f2cf3f1cfbf02 depends: - libgcc-ng >=12 - libstdcxx-ng >=12 - - libxcb >=1.16,<1.17.0a0 + - libxcb >=1.16,<2.0.0a0 - xorg-libx11 >=1.8.9,<2.0a0 - xorg-libxau >=1.0.11,<2.0a0 - xorg-libxext >=1.3.4,<2.0a0 @@ -5459,13 +5606,24 @@ packages: purls: [] size: 144010 timestamp: 1719014356708 -- kind: conda - name: freetype - version: 2.12.1 - build: h267a509_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/freetype-2.12.1-h267a509_2.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/freeglut-3.2.2-hac7e632_2.conda + sha256: 6dc7be5d0853ea5bcbb2b1921baf7d069605594c207e8ce36a662f447cd81a3f + md5: 6e553df297f6e64668efb54302e0f139 + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - libxcb >=1.15,<1.16.0a0 + - xorg-libx11 >=1.8.4,<2.0a0 + - xorg-libxau >=1.0.11,<2.0a0 + - xorg-libxext >=1.3.4,<2.0a0 + - xorg-libxfixes + - xorg-libxi + license: MIT + license_family: MIT + purls: [] + size: 142933 + timestamp: 1684688443008 +- conda: https://conda.anaconda.org/conda-forge/linux-64/freetype-2.12.1-h267a509_2.conda sha256: b2e3c449ec9d907dd4656cb0dc93e140f447175b125a3824b31368b06c666bb6 md5: 9ae35c3d96db2c94ce0cef86efdfa2cb depends: @@ -5476,13 +5634,7 @@ packages: purls: [] size: 634972 timestamp: 1694615932610 -- kind: conda - name: freetype - version: 2.12.1 - build: hadb7bae_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/freetype-2.12.1-hadb7bae_2.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/freetype-2.12.1-hadb7bae_2.conda sha256: 791673127e037a2dc0eebe122dc4f904cb3f6e635bb888f42cbe1a76b48748d9 md5: e6085e516a3e304ce41a8ee08b9b89ad depends: @@ -5492,24 +5644,7 @@ packages: purls: [] size: 596430 timestamp: 1694616332835 -- kind: conda - name: fribidi - version: 1.0.10 - build: h27ca646_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/fribidi-1.0.10-h27ca646_0.tar.bz2 - sha256: 4b37ea851a2cf85edf0a63d2a63266847ec3dcbba4a31156d430cdd6aa811303 - md5: c64443234ff91d70cb9c7dc926c58834 - license: LGPL-2.1 - purls: [] - size: 60255 - timestamp: 1604417405528 -- kind: conda - name: fribidi - version: 1.0.10 - build: h36c2ea0_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/fribidi-1.0.10-h36c2ea0_0.tar.bz2 +- conda: https://conda.anaconda.org/conda-forge/linux-64/fribidi-1.0.10-h36c2ea0_0.tar.bz2 sha256: 5d7b6c0ee7743ba41399e9e05a58ccc1cfc903942e49ff6f677f6e423ea7a627 md5: ac7bc6a654f8f41b352b38f4051135f8 depends: @@ -5518,35 +5653,44 @@ packages: purls: [] size: 114383 timestamp: 1604416621168 -- kind: conda - name: fsspec - version: 2024.9.0 - build: pyhff2d567_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/fsspec-2024.9.0-pyhff2d567_0.conda - sha256: 8f4e9805b4ec223dea0d99f9e7e57c391d9026455eb9f0d6e0784c5d1a1200dc - md5: ace4329fbff4c69ab0309db6da182987 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/fribidi-1.0.10-h27ca646_0.tar.bz2 + sha256: 4b37ea851a2cf85edf0a63d2a63266847ec3dcbba4a31156d430cdd6aa811303 + md5: c64443234ff91d70cb9c7dc926c58834 + license: LGPL-2.1 + purls: [] + size: 60255 + timestamp: 1604417405528 +- conda: https://conda.anaconda.org/conda-forge/linux-64/frozenlist-1.5.0-py312h66e93f0_0.conda + sha256: 7e0c12983b20f2816b3712729b5a35ecb7ee152132ca7cf805427c62395ea823 + md5: f98e36c96b2c66d9043187179ddb04f4 depends: - - python >=3.8 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/frozenlist?source=project-defined-mapping + size: 60968 + timestamp: 1729699568442 +- conda: https://conda.anaconda.org/conda-forge/noarch/fsspec-2024.10.0-pyhd8ed1ab_1.conda + sha256: 790a50b4f94042951518f911a914a886a837c926094c6a14ed1d9d03ce336807 + md5: 906fe13095e734cb413b57a49116cdc8 + depends: + - python >=3.9 license: BSD-3-Clause + license_family: BSD purls: - pkg:pypi/fsspec?source=project-defined-mapping - size: 134378 - timestamp: 1725543368393 -- kind: pypi + size: 134726 + timestamp: 1733493445080 +- pypi: https://files.pythonhosted.org/packages/a3/61/8001b38461d751cd1a0c3a6ae84346796a5758123f3ed97a1b121dfbf4f3/gast-0.6.0-py3-none-any.whl name: gast version: 0.6.0 - url: https://files.pythonhosted.org/packages/a3/61/8001b38461d751cd1a0c3a6ae84346796a5758123f3ed97a1b121dfbf4f3/gast-0.6.0-py3-none-any.whl sha256: 52b182313f7330389f72b069ba00f174cfe2a06411099547288839c6cbafbd54 requires_python: '>=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*' -- kind: conda - name: gcc - version: 12.4.0 - build: h236703b_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/gcc-12.4.0-h236703b_1.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-12.4.0-h236703b_1.conda sha256: 62cfa6eeb1827d0d02739bfca66c49aa7ef63c7a3c055035062fb7fe0479a1b7 md5: b7f73ce286b834487d6cb2dc424ed684 depends: @@ -5556,29 +5700,7 @@ packages: purls: [] size: 53770 timestamp: 1724802037449 -- kind: conda - name: gcc - version: 14.1.0 - build: h6f9ffa1_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/gcc-14.1.0-h6f9ffa1_1.conda - sha256: 2d5c513f6bee00a853cf51a8629c2a453bef387b13c72a6fa15ea60bc62035ce - md5: 595dbf08d669d19b0aeda43015a47127 - depends: - - gcc_impl_linux-64 14.1.0.* - license: BSD-3-Clause - license_family: BSD - purls: [] - size: 53884 - timestamp: 1724802102436 -- kind: conda - name: gcc_impl_linux-64 - version: 12.4.0 - build: hb2e57f8_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-12.4.0-hb2e57f8_1.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-12.4.0-hb2e57f8_1.conda sha256: 778cd1bfd417a9d4ddeb0fc4b5a0eb9eb9edf69112e1be0b2f2df125225f27af md5: 3085fe2c70960ea96f1b4171584b500b depends: @@ -5594,109 +5716,61 @@ packages: purls: [] size: 62030150 timestamp: 1724801895487 -- kind: conda - name: gcc_impl_linux-64 - version: 14.1.0 - build: h3c94d91_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-14.1.0-h3c94d91_1.conda - sha256: 295f03681896f1660deb1a3b3b1d41b17da8089b0de5233c04ddc8c8f6a55854 - md5: 4e32ec060bf4a30c6fff81a920dc0ec9 - depends: - - binutils_impl_linux-64 >=2.40 - - libgcc >=14.1.0 - - libgcc-devel_linux-64 14.1.0 h5d3d1c9_101 - - libgomp >=14.1.0 - - libsanitizer 14.1.0 hcba0ae0_1 - - libstdcxx >=14.1.0 - - sysroot_linux-64 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL - purls: [] - size: 73076591 - timestamp: 1724801948880 -- kind: conda - name: gcc_linux-64 - version: 12.4.0 - build: h6b7512a_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-12.4.0-h6b7512a_2.conda - sha256: d4d4df65fe3e98a41a3fff6303f0b6c9e90addd3d1fde371b9dc26f6f5f6ada9 - md5: e5785fb47b77cf464148ddb38781ee45 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-12.4.0-h6b7512a_7.conda + sha256: 4b5a85de5a20cc4c93b2a8f471ac93188210f3409d75ca0b5c09108def090249 + md5: 0ecba92a58a72f1d1e42289fd9610f66 depends: - - binutils_linux-64 2.40 hb3c18ed_2 + - binutils_linux-64 - gcc_impl_linux-64 12.4.0.* - sysroot_linux-64 license: BSD-3-Clause + license_family: BSD + purls: [] + size: 32033 + timestamp: 1731939586925 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gdk-pixbuf-2.42.12-hb9ae30d_0.conda + sha256: d5283b95a8d49dcd88d29b360d8b38694aaa905d968d156d72ab71d32b38facb + md5: 201db6c2d9a3c5e46573ac4cb2e92f4f + depends: + - libgcc-ng >=12 + - libglib >=2.80.2,<3.0a0 + - libjpeg-turbo >=3.0.0,<4.0a0 + - libpng >=1.6.43,<1.7.0a0 + - libtiff >=4.6.0,<4.8.0a0 + license: LGPL-2.1-or-later + license_family: LGPL purls: [] - size: 31912 - timestamp: 1725663986487 -- kind: conda - name: gds-tools - version: 1.11.1.6 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/gds-tools-1.11.1.6-h5888daf_0.conda - sha256: 21901e02c1a3b3e8c47095abea5dcf078f113b2a24517e291f89471369875111 - md5: 3851567e70262e9fadb3f90329444a28 + size: 528149 + timestamp: 1715782983957 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gds-tools-1.10.0.4-he02047a_0.conda + sha256: f84804a77aee5613233da463354fc3ee0d42e42b8ec5c898f7f36d928462827c + md5: 73126c1d80e5521f91d12ac1b960aa80 depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libcufile >=1.11.1.6,<2.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libcufile >=1.10.0.4,<2.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 39626551 - timestamp: 1724957783210 -- kind: pypi + size: 39617873 + timestamp: 1716319323597 +- pypi: https://us-west1-python.pkg.dev/probcomp-caliban/probcomp/genjax/genjax-0.6.1-py3-none-any.whl#sha256=7e6afa8ab867266a9fa66ccadab3823d2e93d41d19d671ced853407c8e16cf44 name: genjax - version: 0.5.1 - url: https://us-west1-python.pkg.dev/probcomp-caliban/probcomp/genjax/genjax-0.5.1-py3-none-any.whl#sha256=1ad4363ce44f64cc1e5d92f826f4c7c14e99370a8c86d39cbe6fa8c3b6a657ce - sha256: 1ad4363ce44f64cc1e5d92f826f4c7c14e99370a8c86d39cbe6fa8c3b6a657ce + version: 0.6.1 + sha256: 7e6afa8ab867266a9fa66ccadab3823d2e93d41d19d671ced853407c8e16cf44 requires_dist: - beartype>=0.18.5,<0.19.0 - deprecated>=1.2.14,<2.0.0 - - genstudio==2024.7.29.1900 ; extra == 'all' or extra == 'genstudio' + - genstudio==2024.7.30.1946 ; extra == 'all' or extra == 'genstudio' - jax>=0.4.24,<0.5.0 - - jaxtyping>=0.2.28,<0.3.0 + - jaxtyping>=0.2.24,<0.3.0 - msgpack>=1.0.8,<2.0.0 ; extra == 'all' or extra == 'msgpack' + - numpy>=1.22,<2.0.0 - penzai>=0.1.1,<0.2.0 - tensorflow-probability>=0.23.0,<0.24.0 requires_python: '>=3.10,<3.13' -- kind: conda - name: gettext - version: 0.22.5 - build: h8414b35_3 - build_number: 3 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/gettext-0.22.5-h8414b35_3.conda - sha256: 634e11f6e6560568ede805f823a2be8634c6a0a2fa6743880ec403d925923138 - md5: 89b31a91b3ac2b7b3b0e5bc4eb99c39d - depends: - - __osx >=11.0 - - gettext-tools 0.22.5 h8414b35_3 - - libasprintf 0.22.5 h8414b35_3 - - libasprintf-devel 0.22.5 h8414b35_3 - - libcxx >=16 - - libgettextpo 0.22.5 h8414b35_3 - - libgettextpo-devel 0.22.5 h8414b35_3 - - libiconv >=1.17,<2.0a0 - - libintl 0.22.5 h8414b35_3 - - libintl-devel 0.22.5 h8414b35_3 - license: LGPL-2.1-or-later AND GPL-3.0-or-later - purls: [] - size: 483255 - timestamp: 1723627203687 -- kind: conda - name: gettext - version: 0.22.5 - build: he02047a_3 - build_number: 3 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/gettext-0.22.5-he02047a_3.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/gettext-0.22.5-he02047a_3.conda sha256: c3d9a453f523acbf2b3e1c82a42edfc7c7111b4686a2180ab48cb9b51a274218 md5: c7f243bbaea97cd6ea1edd693270100e depends: @@ -5712,31 +5786,7 @@ packages: purls: [] size: 479452 timestamp: 1723626088190 -- kind: conda - name: gettext-tools - version: 0.22.5 - build: h8414b35_3 - build_number: 3 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/gettext-tools-0.22.5-h8414b35_3.conda - sha256: 50b530cf2326938b80330f78cf4056492fa8c6a5c7e313d92069ebbbb2f4d264 - md5: 47071f4b2915032e1d47119f779f9d9c - depends: - - __osx >=11.0 - - libiconv >=1.17,<2.0a0 - - libintl 0.22.5 h8414b35_3 - license: GPL-3.0-or-later - license_family: GPL - purls: [] - size: 2467439 - timestamp: 1723627140130 -- kind: conda - name: gettext-tools - version: 0.22.5 - build: he02047a_3 - build_number: 3 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/gettext-tools-0.22.5-he02047a_3.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/gettext-tools-0.22.5-he02047a_3.conda sha256: 0fd003953ce1ce9f4569458aab9ffaa397e3be2bc069250e2f05fd93b0ad2976 md5: fcd2016d1d299f654f81021e27496818 depends: @@ -5747,45 +5797,56 @@ packages: purls: [] size: 2750908 timestamp: 1723626056740 -- kind: conda - name: gflags - version: 2.2.2 - build: hc88da5d_1004 - build_number: 1004 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/gflags-2.2.2-hc88da5d_1004.tar.bz2 - sha256: 25d4a20af2e5ace95fdec88970f6d190e77e20074d2f6d3cef766198b76a4289 - md5: aab9ddfad863e9ef81229a1f8852211b - depends: - - libcxx >=11.0.0.rc1 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gflags-2.2.2-h5888daf_1005.conda + sha256: 6c33bf0c4d8f418546ba9c250db4e4221040936aef8956353bc764d4877bc39a + md5: d411fc29e338efb48c5fd4576d71d881 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 license: BSD-3-Clause license_family: BSD purls: [] - size: 86690 - timestamp: 1599590990520 -- kind: conda - name: gflags - version: 2.2.2 - build: he1b5a44_1004 - build_number: 1004 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/gflags-2.2.2-he1b5a44_1004.tar.bz2 - sha256: a853c0cacf53cfc59e1bca8d6e5cdfe9f38fce836f08c2a69e35429c2a492e77 - md5: cddaf2c63ea4a5901cf09524c490ecdc + size: 119654 + timestamp: 1726600001928 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/gflags-2.2.2-hf9b8971_1005.conda + sha256: fd56ed8a1dab72ab90d8a8929b6f916a6d9220ca297ff077f8f04c5ed3408e20 + md5: 57a511a5905caa37540eb914dfcbf1fb depends: - - libgcc-ng >=7.5.0 - - libstdcxx-ng >=7.5.0 + - __osx >=11.0 + - libcxx >=17 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 82090 + timestamp: 1726600145480 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gl2ps-1.4.2-hae5d5c5_1.conda + sha256: 68f071ea25e79ee427c0d6c35ccc137d66f093a37660a4e41bafe0c49d64f2d6 + md5: 00e642ec191a19bf806a3915800e9524 + depends: + - libgcc-ng >=12 + - libpng >=1.6.43,<1.7.0a0 + - libzlib >=1.3.1,<2.0a0 + license: LGPL-2.0-or-later + license_family: LGPL + purls: [] + size: 74102 + timestamp: 1718542981099 +- conda: https://conda.anaconda.org/conda-forge/linux-64/glew-2.1.0-h9c3ff4c_2.tar.bz2 + sha256: 86f5484e38f4604f7694b14f64238e932e8fd8d7364e86557f4911eded2843ae + md5: fb05eb5c47590b247658243d27fc32f1 + depends: + - libgcc-ng >=9.3.0 + - libglu + - libstdcxx-ng >=9.3.0 + - xorg-libx11 + - xorg-libxext license: BSD-3-Clause license_family: BSD purls: [] - size: 116549 - timestamp: 1594303828933 -- kind: conda - name: glfw - version: '3.4' - build: hd590300_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/glfw-3.4-hd590300_0.conda + size: 662569 + timestamp: 1607113198887 +- conda: https://conda.anaconda.org/conda-forge/linux-64/glfw-3.4-hd590300_0.conda sha256: 852298b9d1b6e58d8653d943049f7bce0ef3774c87fccd5ac1e8b04d5d702d40 md5: 4c7a044d25e000fef39b77c10a102ea1 depends: @@ -5798,12 +5859,7 @@ packages: purls: [] size: 167421 timestamp: 1708788896752 -- kind: conda - name: glog - version: 0.7.1 - build: hbabe93e_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/glog-0.7.1-hbabe93e_0.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/glog-0.7.1-hbabe93e_0.conda sha256: dc824dc1d0aa358e28da2ecbbb9f03d932d976c8dca11214aa1dcdfcbd054ba2 md5: ff862eebdfeb2fd048ae9dc92510baca depends: @@ -5815,12 +5871,7 @@ packages: purls: [] size: 143452 timestamp: 1718284177264 -- kind: conda - name: glog - version: 0.7.1 - build: heb240a5_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/glog-0.7.1-heb240a5_0.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/glog-0.7.1-heb240a5_0.conda sha256: 9fc77de416953aa959039db72bc41bfa4600ae3ff84acad04a7d0c1ab9552602 md5: fef68d0a95aa5b84b5c1a4f6f3bf40e1 depends: @@ -5832,29 +5883,7 @@ packages: purls: [] size: 112215 timestamp: 1718284365403 -- kind: conda - name: gmp - version: 6.3.0 - build: h7bae524_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/gmp-6.3.0-h7bae524_2.conda - sha256: 76e222e072d61c840f64a44e0580c2503562b009090f55aa45053bf1ccb385dd - md5: eed7278dfbab727b56f2c0b64330814b - depends: - - __osx >=11.0 - - libcxx >=16 - license: GPL-2.0-or-later OR LGPL-3.0-or-later - purls: [] - size: 365188 - timestamp: 1718981343258 -- kind: conda - name: gmp - version: 6.3.0 - build: hac33072_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/gmp-6.3.0-hac33072_2.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/gmp-6.3.0-hac33072_2.conda sha256: 309cf4f04fec0c31b6771a5809a1909b4b3154a2208f52351e1ada006f4c750c md5: c94a5994ef49749880a8139cf9afcbe1 depends: @@ -5864,15 +5893,19 @@ packages: purls: [] size: 460055 timestamp: 1718980856608 -- kind: conda - name: gmpy2 - version: 2.1.5 - build: py312h7201bc8_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/gmpy2-2.1.5-py312h7201bc8_2.conda - sha256: 66665fbf074e9cc8975ba1a0c7d4fd378cea6efc7ba34f0da5a355a16dfb323a - md5: af9faf103fb57241246416dc70b466f7 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmp-6.3.0-h7bae524_2.conda + sha256: 76e222e072d61c840f64a44e0580c2503562b009090f55aa45053bf1ccb385dd + md5: eed7278dfbab727b56f2c0b64330814b + depends: + - __osx >=11.0 + - libcxx >=16 + license: GPL-2.0-or-later OR LGPL-3.0-or-later + purls: [] + size: 365188 + timestamp: 1718981343258 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gmpy2-2.1.5-py312h7201bc8_3.conda + sha256: addd0bc226ca86c11f1223ab322d12b67501c2b3d93749bdab2068ccaedd8ef0 + md5: 673ef4d6611f5b4ca7b5c1f8c65a38dc depends: - __glibc >=2.17,<3.0.a0 - gmp >=6.3.0,<7.0a0 @@ -5885,17 +5918,11 @@ packages: license_family: LGPL purls: - pkg:pypi/gmpy2?source=project-defined-mapping - size: 211651 - timestamp: 1725379960923 -- kind: conda - name: gmpy2 - version: 2.1.5 - build: py312h87fada9_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/gmpy2-2.1.5-py312h87fada9_2.conda - sha256: a41f68fc4016813f285bec42157a19030a8e9aca8ffcd7e89bbfb7f6ea9e605f - md5: 2f3497178aaeec7e4811bc8a2426cae8 + size: 209631 + timestamp: 1733462668219 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmpy2-2.1.5-py312h524cf62_3.conda + sha256: 0ea196e4b706321951af1eebdb6a4eb9307faa1fd5361bcf49acb150e71774f7 + md5: ab7a5d10c7b4e249a9fe7bc280909803 depends: - __osx >=11.0 - gmp >=6.3.0,<7.0a0 @@ -5908,18 +5935,12 @@ packages: license_family: LGPL purls: - pkg:pypi/gmpy2?source=project-defined-mapping - size: 148575 - timestamp: 1725380166808 -- kind: conda - name: gnutls - version: 3.8.7 - build: h32866dd_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/gnutls-3.8.7-h32866dd_0.conda - sha256: 99d04717db680766bb63841d2110e6d4aefbd87a22aac274517f20db7aa3874d - md5: b3217a6e20b24a6dafa0f0b3d13995c6 + size: 147983 + timestamp: 1733462785197 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gnutls-3.7.9-hb077bed_0.conda + sha256: 52d824a5d2b8a5566cd469cae6ad6920469b5a15b3e0ddc609dd29151be71be2 + md5: 33eded89024f21659b1975886a4acf70 depends: - - __glibc >=2.17,<3.0.a0 - libgcc-ng >=12 - libidn2 >=2,<3.0a0 - libstdcxx-ng >=12 @@ -5929,38 +5950,25 @@ packages: license: LGPL-2.1-or-later license_family: LGPL purls: [] - size: 1876982 - timestamp: 1723812913498 -- kind: conda - name: gnutls - version: 3.8.7 - build: h9df781c_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/gnutls-3.8.7-h9df781c_0.conda - sha256: 84c7d7db526f69d05859be5879f27a1f15da865e5c53dd627d11bc1b981af9a3 - md5: 01234407ecd8012e93d267b7cc15af4f + size: 1974935 + timestamp: 1701111180127 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gnutls-3.8.8-h2d3e045_0.conda + sha256: 665b6c02b63224fd7dd362baa7350c6980c08fefa5f196e6181f6b4fb3a951c2 + md5: 28d86f5826387902f48a63906b4a1a24 depends: - - __osx >=11.0 - - libasprintf >=0.22.5,<1.0a0 - - libcxx >=16 - - libgettextpo >=0.22.5,<1.0a0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 - libidn2 >=2,<3.0a0 - - libintl >=0.22.5,<1.0a0 + - libstdcxx >=13 - libtasn1 >=4.19.0,<5.0a0 - nettle >=3.9.1,<3.10.0a0 - p11-kit >=0.24.1,<0.25.0a0 license: LGPL-2.1-or-later license_family: LGPL purls: [] - size: 1738547 - timestamp: 1723812228427 -- kind: conda - name: graphite2 - version: 1.3.13 - build: h59595ed_1003 - build_number: 1003 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/graphite2-1.3.13-h59595ed_1003.conda + size: 2001536 + timestamp: 1730802938288 +- conda: https://conda.anaconda.org/conda-forge/linux-64/graphite2-1.3.13-h59595ed_1003.conda sha256: 0595b009f20f8f60f13a6398e7cdcbd2acea5f986633adcf85f5a2283c992add md5: f87c7b7c2cb45f323ffbce941c78ab7c depends: @@ -5971,13 +5979,7 @@ packages: purls: [] size: 96855 timestamp: 1711634169756 -- kind: conda - name: graphite2 - version: 1.3.13 - build: hebf3989_1003 - build_number: 1003 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/graphite2-1.3.13-hebf3989_1003.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/graphite2-1.3.13-hebf3989_1003.conda sha256: 2eadafbfc52f5e7df3da3c3b7e5bbe34d970bea1d645ffe60b0b1c3a216657f5 md5: 339991336eeddb70076d8ca826dac625 depends: @@ -5987,13 +5989,7 @@ packages: purls: [] size: 79774 timestamp: 1711634444608 -- kind: conda - name: gxx - version: 12.4.0 - build: h236703b_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/gxx-12.4.0-h236703b_1.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-12.4.0-h236703b_1.conda sha256: ccf038a2832624528dfdc52579cad6aa6d1d0ef1272fe9b9efc3b50ac4aa81b9 md5: 1749f731236f6660f3ba74a052cede24 depends: @@ -6004,13 +6000,7 @@ packages: purls: [] size: 53219 timestamp: 1724802186786 -- kind: conda - name: gxx_impl_linux-64 - version: 12.4.0 - build: h613a52c_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-12.4.0-h613a52c_1.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-12.4.0-h613a52c_1.conda sha256: b08ddbe2bdb1c0c0804e86a99eac9f5041227ba44c652b1dc9083843a4e25374 md5: ef8a8e632fd38345288c3419c868904f depends: @@ -6023,90 +6013,129 @@ packages: purls: [] size: 12711904 timestamp: 1724802140227 -- kind: conda - name: gxx_linux-64 - version: 12.4.0 - build: h8489865_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-12.4.0-h8489865_2.conda - sha256: 93747f22bfa09dea77e2526e38d22d5e78c34970e18531e979dff764e94eb8f5 - md5: 650a15e2801b8c26bf9647e8da5c4ea4 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-12.4.0-h8489865_7.conda + sha256: bfd83c546f90e8714d966d29e56ba65bcf0a8c5e55386a514a8a4376ead3c538 + md5: 7b5cb09214f4ce24ce444ba0a6e18b07 depends: - - binutils_linux-64 2.40 hb3c18ed_2 - - gcc_linux-64 12.4.0 h6b7512a_2 + - binutils_linux-64 + - gcc_linux-64 12.4.0 h6b7512a_7 - gxx_impl_linux-64 12.4.0.* - sysroot_linux-64 license: BSD-3-Clause + license_family: BSD purls: [] - size: 30226 - timestamp: 1725664002811 -- kind: conda - name: h11 - version: 0.14.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/h11-0.14.0-pyhd8ed1ab_0.tar.bz2 - sha256: 817d2c77d53afe3f3d9cf7f6eb8745cdd8ea76c7adaa9d7ced75c455a2c2c085 - md5: b21ed0883505ba1910994f1df031a428 + size: 30384 + timestamp: 1731939606577 +- conda: https://conda.anaconda.org/conda-forge/noarch/h11-0.14.0-pyhd8ed1ab_1.conda + sha256: 622516185a7c740d5c7f27016d0c15b45782c1501e5611deec63fd70344ce7c8 + md5: 7ee49e89531c0dcbba9466f6d115d585 depends: - - python >=3 + - python >=3.9 - typing_extensions license: MIT license_family: MIT purls: - pkg:pypi/h11?source=project-defined-mapping - size: 48251 - timestamp: 1664132995560 -- kind: conda - name: h2 - version: 4.1.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/h2-4.1.0-pyhd8ed1ab_0.tar.bz2 - sha256: bfc6a23849953647f4e255c782e74a0e18fe16f7e25c7bb0bc57b83bb6762c7a - md5: b748fbf7060927a6e82df7cb5ee8f097 + size: 51846 + timestamp: 1733327599467 +- conda: https://conda.anaconda.org/conda-forge/noarch/h2-4.1.0-pyhd8ed1ab_1.conda + sha256: 843ddad410c370672a8250470697027618f104153612439076d4d7b91eeb7b5c + md5: 825927dc7b0f287ef8d4d0011bb113b1 depends: - hpack >=4.0,<5 - hyperframe >=6.0,<7 - - python >=3.6.1 + - python >=3.9 license: MIT license_family: MIT purls: - - pkg:pypi/h2?source=project-defined-mapping - size: 46754 - timestamp: 1634280590080 -- kind: conda - name: harfbuzz - version: 9.0.0 - build: h997cde5_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/harfbuzz-9.0.0-h997cde5_1.conda - sha256: 5f78f5dcbbfef59b3549ecb6cc2fa9de7b22abda7c8afaf0fa787ceea37a914f - md5: 50f6825d3c4a6fca6fefdefa98081554 + - pkg:pypi/h2?source=project-defined-mapping + size: 52000 + timestamp: 1733298867359 +- conda: https://conda.anaconda.org/conda-forge/linux-64/h5py-3.11.0-nompi_py312hedeef09_103.conda + sha256: 8a5ad781cde6df4e2d6a2a27593f44edf1986fe5a1554f3cbf8bc5e3bcdd83a9 + md5: cec32e68634e4af17ef94d56a196d6ae + depends: + - __glibc >=2.17,<3.0.a0 + - cached-property + - hdf5 >=1.14.3,<1.14.4.0a0 + - libgcc >=13 + - numpy >=1.19,<3 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/h5py?source=project-defined-mapping + size: 1376258 + timestamp: 1728976184813 +- conda: https://conda.anaconda.org/conda-forge/linux-64/h5py-3.12.1-nompi_py312hedeef09_102.conda + sha256: 5acc7c221e792c7aa9bbb2c57d5e0104d7a6e81c2cd29a47a77d574552cd4fd0 + md5: ee52559d324594141ce369c527d6d029 + depends: + - __glibc >=2.17,<3.0.a0 + - cached-property + - hdf5 >=1.14.3,<1.14.4.0a0 + - libgcc >=13 + - numpy >=1.19,<3 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/h5py?source=project-defined-mapping + size: 1380838 + timestamp: 1729617970564 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/h5py-3.11.0-nompi_py312h3cd0824_103.conda + sha256: eba937df39f1b0da2f116977de5e043a21044227058ab0013499f29218fe7ef5 + md5: 830cd76fef2c93656223a8bada8daf87 + depends: + - __osx >=11.0 + - cached-property + - hdf5 >=1.14.3,<1.14.4.0a0 + - numpy >=1.19,<3 + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/h5py?source=project-defined-mapping + size: 1177611 + timestamp: 1728976217660 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/h5py-3.12.1-nompi_py312h3cd0824_102.conda + sha256: 768e56d2ddc20c1140ab6f78bb48caa335814b902f839205081eb5f9099c70de + md5: b423e1049bda5e69a23304ac392baed5 depends: - __osx >=11.0 + - cached-property + - hdf5 >=1.14.3,<1.14.4.0a0 + - numpy >=1.19,<3 + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/h5py?source=project-defined-mapping + size: 1188438 + timestamp: 1729618653381 +- conda: https://conda.anaconda.org/conda-forge/linux-64/harfbuzz-8.5.0-hfac3d4d_0.conda + sha256: a141fc55f8bfdab7db03fe9d8e61cb0f8c8b5970ed6540eda2db7186223f4444 + md5: f5126317dd0ce0ba26945e411ecc6960 + depends: - cairo >=1.18.0,<2.0a0 - freetype >=2.12.1,<3.0a0 - graphite2 - - icu >=75.1,<76.0a0 - - libcxx >=16 - - libglib >=2.80.3,<3.0a0 + - icu >=73.2,<74.0a0 + - libgcc-ng >=12 + - libglib >=2.80.2,<3.0a0 + - libstdcxx-ng >=12 license: MIT license_family: MIT purls: [] - size: 1317509 - timestamp: 1721186764931 -- kind: conda - name: harfbuzz - version: 9.0.0 - build: hda332d3_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/harfbuzz-9.0.0-hda332d3_1.conda + size: 1598244 + timestamp: 1715701061364 +- conda: https://conda.anaconda.org/conda-forge/linux-64/harfbuzz-9.0.0-hda332d3_1.conda sha256: 973afa37840b4e55e2540018902255cfb0d953aaed6353bb83a4d120f5256767 md5: 76b32dcf243444aea9c6b804bcfa40b8 depends: @@ -6123,137 +6152,135 @@ packages: purls: [] size: 1603653 timestamp: 1721186240105 -- kind: conda - name: hdf5 - version: 1.14.3 - build: nompi_hdf9ad27_105 - build_number: 105 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/hdf5-1.14.3-nompi_hdf9ad27_105.conda - sha256: 2278fa07da6f96e807d402cd55480624d67d2dee202191aaaf278ce5ab23605a - md5: 7e1729554e209627636a0f6fabcdd115 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/harfbuzz-9.0.0-h997cde5_1.conda + sha256: 5f78f5dcbbfef59b3549ecb6cc2fa9de7b22abda7c8afaf0fa787ceea37a914f + md5: 50f6825d3c4a6fca6fefdefa98081554 + depends: + - __osx >=11.0 + - cairo >=1.18.0,<2.0a0 + - freetype >=2.12.1,<3.0a0 + - graphite2 + - icu >=75.1,<76.0a0 + - libcxx >=16 + - libglib >=2.80.3,<3.0a0 + license: MIT + license_family: MIT + purls: [] + size: 1317509 + timestamp: 1721186764931 +- conda: https://conda.anaconda.org/conda-forge/linux-64/hdf4-4.2.15-h2a13503_7.conda + sha256: 0d09b6dc1ce5c4005ae1c6a19dc10767932ef9a5e9c755cfdbb5189ac8fb0684 + md5: bd77f8da987968ec3927990495dc22e4 depends: - - libaec >=1.1.3,<2.0a0 - - libcurl >=8.8.0,<9.0a0 - libgcc-ng >=12 - - libgfortran-ng - - libgfortran5 >=12.3.0 + - libjpeg-turbo >=3.0.0,<4.0a0 - libstdcxx-ng >=12 - - libzlib >=1.2.13,<2.0a0 - - openssl >=3.3.1,<4.0a0 + - libzlib >=1.2.13,<2.0.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 756742 + timestamp: 1695661547874 +- conda: https://conda.anaconda.org/conda-forge/linux-64/hdf5-1.14.3-nompi_h2d575fe_108.conda + sha256: 340b997d57eb89c058d8f2e80d426e4716661a51efcd1d857afb2b29f59177a4 + md5: b74598031529dafb2a66f9e90f26f2dc + depends: + - __glibc >=2.17,<3.0.a0 + - libaec >=1.1.3,<2.0a0 + - libcurl >=8.10.1,<9.0a0 + - libgcc >=13 + - libgfortran + - libgfortran5 >=13.3.0 + - libstdcxx >=13 + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.4.0,<4.0a0 license: BSD-3-Clause license_family: BSD purls: [] - size: 3911675 - timestamp: 1717587866574 -- kind: conda - name: hdf5 - version: 1.14.3 - build: nompi_hec07895_105 - build_number: 105 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/hdf5-1.14.3-nompi_hec07895_105.conda - sha256: 5d87a1b63862e7da78c7bd9c17dea3526c0462c11df9004943cfa4569cc25dd3 - md5: f9c8c7304d52c8846eab5d6c34219812 + size: 3899869 + timestamp: 1733668584836 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/hdf5-1.14.3-nompi_ha698983_108.conda + sha256: b080cf87687bfb0be6f73ecf95f92525ec6fc03527b1cad3fdcedad3d9ef87d5 + md5: 5c9753c3ecfb975480ead5aa07903085 depends: - __osx >=11.0 - libaec >=1.1.3,<2.0a0 - - libcurl >=8.8.0,<9.0a0 - - libcxx >=16 + - libcurl >=8.10.1,<9.0a0 + - libcxx >=18 - libgfortran 5.* - - libgfortran5 >=12.3.0 - libgfortran5 >=13.2.0 - - libzlib >=1.2.13,<2.0a0 - - openssl >=3.3.1,<4.0a0 + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.4.0,<4.0a0 license: BSD-3-Clause license_family: BSD purls: [] - size: 3445248 - timestamp: 1717587775787 -- kind: conda - name: hpack - version: 4.0.0 - build: pyh9f0ad1d_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/hpack-4.0.0-pyh9f0ad1d_0.tar.bz2 - sha256: 5dec948932c4f740674b1afb551223ada0c55103f4c7bf86a110454da3d27cb8 - md5: 914d6646c4dbb1fd3ff539830a12fd71 + size: 3479739 + timestamp: 1733668171240 +- conda: https://conda.anaconda.org/conda-forge/noarch/hpack-4.0.0-pyhd8ed1ab_1.conda + sha256: ec89b7e5b8aa2f0219f666084446e1fb7b54545861e9caa892acb24d125761b5 + md5: 2aa5ff7fa34a81b9196532c84c10d865 depends: - - python + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/hpack?source=project-defined-mapping - size: 25341 - timestamp: 1598856368685 -- kind: conda - name: httpcore - version: 1.0.5 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/httpcore-1.0.5-pyhd8ed1ab_0.conda - sha256: 4025644200eefa0598e4600a66fd4804a57d9fd7054a5c8c45e508fd875e0b84 - md5: a6b9a0158301e697e4d0a36a3d60e133 + size: 29412 + timestamp: 1733299296857 +- conda: https://conda.anaconda.org/conda-forge/noarch/httpcore-1.0.7-pyh29332c3_1.conda + sha256: c84d012a245171f3ed666a8bf9319580c269b7843ffa79f26468842da3abd5df + md5: 2ca8e6dbc86525c8b95e3c0ffa26442e depends: - - anyio >=3.0,<5.0 - - certifi + - python >=3.8 - h11 >=0.13,<0.15 - h2 >=3,<5 - - python >=3.8 - sniffio 1.* + - anyio >=3.0,<5.0 + - certifi license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/httpcore?source=project-defined-mapping - size: 45816 - timestamp: 1711597091407 -- kind: conda - name: httpx - version: 0.27.2 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/httpx-0.27.2-pyhd8ed1ab_0.conda - sha256: 1a33f160548bf447e15c0273899d27e4473f1d5b7ca1441232ec2d9d07c56d03 - md5: 7e9ac3faeebdbd7b53b462c41891e7f7 + size: 48959 + timestamp: 1731707562362 +- conda: https://conda.anaconda.org/conda-forge/noarch/httpx-0.28.1-pyhd8ed1ab_0.conda + sha256: cd0f1de3697b252df95f98383e9edb1d00386bfdd03fdf607fa42fe5fcb09950 + md5: d6989ead454181f4f9bc987d3dc4e285 depends: - anyio - certifi - httpcore 1.* - idna - - python >=3.8 - - sniffio + - python >=3.9 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/httpx?source=project-defined-mapping - size: 65085 - timestamp: 1724778453275 -- kind: conda - name: hyperframe - version: 6.0.1 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/hyperframe-6.0.1-pyhd8ed1ab_0.tar.bz2 - sha256: e374a9d0f53149328134a8d86f5d72bca4c6dcebed3c0ecfa968c02996289330 - md5: 9f765cbfab6870c8435b9eefecd7a1f4 + size: 63082 + timestamp: 1733663449209 +- conda: https://conda.anaconda.org/conda-forge/noarch/hyperframe-6.0.1-pyhd8ed1ab_1.conda + sha256: e91c6ef09d076e1d9a02819cd00fa7ee18ecf30cdd667605c853980216584d1b + md5: 566e75c90c1d0c8c459eb0ad9833dc7a depends: - - python >=3.6 + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/hyperframe?source=project-defined-mapping - size: 14646 - timestamp: 1619110249723 -- kind: conda - name: icu - version: '75.1' - build: he02047a_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda + size: 17239 + timestamp: 1733298862681 +- conda: https://conda.anaconda.org/conda-forge/linux-64/icu-73.2-h59595ed_0.conda + sha256: e12fd90ef6601da2875ebc432452590bc82a893041473bc1c13ef29001a73ea8 + md5: cc47e1facc155f91abd89b11e48e72ff + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + license: MIT + license_family: MIT + purls: [] + size: 12089150 + timestamp: 1692900650789 +- conda: https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda sha256: 71e750d509f5fa3421087ba88ef9a7b9be11c53174af3aa4d06aff4c18b38e8e md5: 8b189310083baabfb622af68fd9d3ae3 depends: @@ -6265,12 +6292,7 @@ packages: purls: [] size: 12129203 timestamp: 1720853576813 -- kind: conda - name: icu - version: '75.1' - build: hfee45f7_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/icu-75.1-hfee45f7_0.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-75.1-hfee45f7_0.conda sha256: 9ba12c93406f3df5ab0a43db8a4b4ef67a5871dfd401010fbe29b218b2cbe620 md5: 5eb22c1d7b3fc4abb50d92d621583137 depends: @@ -6280,154 +6302,104 @@ packages: purls: [] size: 11857802 timestamp: 1720853997952 -- kind: conda - name: idna - version: '3.8' - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/idna-3.8-pyhd8ed1ab_0.conda - sha256: 8660d38b272d3713ec8ac5ae918bc3bc80e1b81e1a7d61df554bded71ada6110 - md5: 99e164522f6bdf23c177c8d9ae63f975 +- conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.10-pyhd8ed1ab_1.conda + sha256: d7a472c9fd479e2e8dcb83fb8d433fce971ea369d704ece380e876f9c3494e87 + md5: 39a4f67be3286c86d696df570b1201b7 depends: - - python >=3.6 + - python >=3.9 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/idna?source=project-defined-mapping - size: 49275 - timestamp: 1724450633325 -- kind: conda - name: imageio - version: 2.35.1 - build: pyh12aca89_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/imageio-2.35.1-pyh12aca89_0.conda - sha256: 3b7b951c6d1936d1e81ea5b89f0110bf64a3e34de25c874a171bda8ad11a0966 - md5: b03ff3631329c8ef17bae35d2bb216f7 + size: 49765 + timestamp: 1733211921194 +- conda: https://conda.anaconda.org/conda-forge/noarch/imageio-2.36.1-pyh12aca89_1.conda + sha256: 84e4c3fb7a7f11c52678a8aadfde184fb0a0d91eea9fc5b70516ccaf9f8e2551 + md5: 84d5a2f075c861a8f98afd2842f7eb6e depends: - numpy - pillow >=8.3.2 - - python >=3 + - python >=3.9 license: BSD-2-Clause license_family: BSD purls: - pkg:pypi/imageio?source=project-defined-mapping - size: 292678 - timestamp: 1724069160942 -- kind: conda - name: imath - version: 3.1.11 - build: h1059232_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/imath-3.1.11-h1059232_0.conda - sha256: cc6d59bcadde846a81d0c141af6a850f28c397a1c8b8546cee1e1c935b6f8dd6 - md5: e95ef5164e69abc370842b41438065fa + size: 292466 + timestamp: 1732815256476 +- conda: https://conda.anaconda.org/conda-forge/linux-64/imath-3.1.12-h7955e40_0.conda + sha256: 4d8d07a4d5079d198168b44556fb86d094e6a716e8979b25a9f6c9c610e9fe56 + md5: 37f5e1ab0db3691929f37dee78335d1b depends: - - libcxx >=16 - - libzlib >=1.2.13,<2.0.0a0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + - libzlib >=1.3.1,<2.0a0 license: BSD-3-Clause license_family: BSD purls: [] - size: 154276 - timestamp: 1709194436403 -- kind: conda - name: imath - version: 3.1.11 - build: hfc55251_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/imath-3.1.11-hfc55251_0.conda - sha256: b394465d3c6a9c5b17351562a87df2a5ef541d66f1a2d95d80fe28c9ca7638c3 - md5: 07268e57799c7ad50809cadc297a515e + size: 159630 + timestamp: 1725971591485 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/imath-3.1.12-h025cafa_0.conda + sha256: 8fcf6c3bf91993451412c0003b92044c9fc7980fe3f178ab3260f90ac4099072 + md5: b7e259bd81b5a7432ca045083959b83a depends: - - libgcc-ng >=12 - - libstdcxx-ng >=12 - - libzlib >=1.2.13,<2.0.0a0 + - __osx >=11.0 + - libcxx >=17 + - libzlib >=1.3.1,<2.0a0 license: BSD-3-Clause license_family: BSD purls: [] - size: 162530 - timestamp: 1709194196768 -- kind: conda - name: importlib-metadata - version: 8.4.0 - build: pyha770c72_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.4.0-pyha770c72_0.conda - sha256: 02c95f6f62675012e0b2ab945eba6fc14fa6a693c17bced3554db7b62d586f0c - md5: 6e3dbc422d3749ad72659243d6ac8b2b + size: 153017 + timestamp: 1725971790238 +- conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.5.0-pyha770c72_1.conda + sha256: 13766b88fc5b23581530d3a0287c0c58ad82f60401afefab283bf158d2be55a9 + md5: 315607a3030ad5d5227e76e0733798ff depends: - - python >=3.8 + - python >=3.9 - zipp >=0.5 license: Apache-2.0 license_family: APACHE purls: - pkg:pypi/importlib-metadata?source=project-defined-mapping - size: 28338 - timestamp: 1724187329246 -- kind: conda - name: importlib_metadata - version: 8.4.0 - build: hd8ed1ab_0 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/importlib_metadata-8.4.0-hd8ed1ab_0.conda - sha256: c9c782fdf59fb169220b69ea0bbefc3fdc7f58c9fdbdf2d6ff734aa033647b59 - md5: 01b7411c765c3d863dcc920207f258bd + size: 28623 + timestamp: 1733223207185 +- conda: https://conda.anaconda.org/conda-forge/noarch/importlib_metadata-8.5.0-hd8ed1ab_1.conda + sha256: 204fc7f02be8acda93073f5126b9707b8847b673d4c6558db208973c92f9af3c + md5: c70dd0718dbccdcc6d5828de3e71399d depends: - - importlib-metadata >=8.4.0,<8.4.1.0a0 + - importlib-metadata >=8.5.0,<8.5.1.0a0 license: Apache-2.0 license_family: APACHE purls: - pkg:pypi/importlib-metadata?source=project-defined-mapping - size: 9292 - timestamp: 1724187331653 -- kind: conda - name: importlib_resources - version: 6.4.4 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.4.4-pyhd8ed1ab_0.conda - sha256: 13e277624eaef453af3ff4d925ba1169376baa7008eabd8eaae7c5772bec9fc2 - md5: 99aa3edd3f452d61c305a30e78140513 + size: 9362 + timestamp: 1733223207817 +- conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.4.5-pyhd8ed1ab_1.conda + sha256: 461199e429a3db01f0a673f8beaac5e0be75b88895952fb9183f2ab01c5c3c24 + md5: 15798fa69312d433af690c8c42b3fb36 depends: - - python >=3.8 + - python >=3.9 - zipp >=3.1.0 constrains: - - importlib-resources >=6.4.4,<6.4.5.0a0 + - importlib-resources >=6.4.5,<6.4.6.0a0 license: Apache-2.0 license_family: APACHE purls: - pkg:pypi/importlib-resources?source=project-defined-mapping - size: 32258 - timestamp: 1724314749050 -- kind: conda - name: iniconfig - version: 2.0.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda - sha256: 38740c939b668b36a50ef455b077e8015b8c9cf89860d421b3fff86048f49666 - md5: f800d2da156d08e289b14e87e43c1ae5 + size: 32701 + timestamp: 1733231441973 +- conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_1.conda + sha256: 0ec8f4d02053cd03b0f3e63168316530949484f80e16f5e2fb199a1d117a89ca + md5: 6837f3eff7dcea42ecd714ce1ac2b108 depends: - - python >=3.7 + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/iniconfig?source=project-defined-mapping - size: 11101 - timestamp: 1673103208955 -- kind: conda - name: ipykernel - version: 6.29.5 - build: pyh3099207_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/ipykernel-6.29.5-pyh3099207_0.conda + size: 11474 + timestamp: 1733223232820 +- conda: https://conda.anaconda.org/conda-forge/noarch/ipykernel-6.29.5-pyh3099207_0.conda sha256: 33cfd339bb4efac56edf93474b37ddc049e08b1b4930cf036c893cc1f5a1f32a md5: b40131ab6a36ac2c09b7c57d4d3fbf99 depends: @@ -6451,13 +6423,7 @@ packages: - pkg:pypi/ipykernel?source=project-defined-mapping size: 119084 timestamp: 1719845605084 -- kind: conda - name: ipykernel - version: 6.29.5 - build: pyh57ce528_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/ipykernel-6.29.5-pyh57ce528_0.conda +- conda: https://conda.anaconda.org/conda-forge/noarch/ipykernel-6.29.5-pyh57ce528_0.conda sha256: 072534d4d379225b2c3a4e38bc7730b65ae171ac7f0c2d401141043336e97980 md5: 9eb15d654daa0ef5a98802f586bb4ffc depends: @@ -6482,13 +6448,25 @@ packages: - pkg:pypi/ipykernel?source=project-defined-mapping size: 119568 timestamp: 1719845667420 -- kind: conda - name: ipython - version: 8.26.0 - build: pyh707e725_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/ipython-8.26.0-pyh707e725_0.conda +- conda: https://conda.anaconda.org/conda-forge/noarch/ipympl-0.9.5-pyhd8ed1ab_0.conda + sha256: cb9ef37459aa7fcc634df5e0ce0d281f3fd6e95e56acdb9efa73dcf2f1d33669 + md5: 30406b87fecd5a3a6a27dda1f5051c87 + depends: + - ipython <9 + - ipython_genutils + - ipywidgets >=7.6.0,<9 + - matplotlib-base >=2.2.0,<4 + - numpy + - pillow + - python >=3.9 + - traitlets <6 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/ipympl?source=project-defined-mapping + size: 213374 + timestamp: 1734505637773 +- conda: https://conda.anaconda.org/conda-forge/noarch/ipython-8.26.0-pyh707e725_0.conda sha256: a40c2859a055d98ba234d67b233fb1ba55d86cbe632ec96eecb7c5019c16478b md5: f64d3520d5d00321c10f4dabb5b903f3 depends: @@ -6511,15 +6489,9 @@ packages: - pkg:pypi/ipython?source=project-defined-mapping size: 599279 timestamp: 1719582627972 -- kind: conda - name: ipython - version: 8.27.0 - build: pyh707e725_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/ipython-8.27.0-pyh707e725_0.conda - sha256: 4eaa22b1afdbd0076ab1cc8da99d9c62f5c5f14cd0a30ff99c133e22f2db5a58 - md5: 0ed09f0c0f62f50b4b7dd2744af13629 +- conda: https://conda.anaconda.org/conda-forge/noarch/ipython-8.30.0-pyh707e725_0.conda + sha256: 65cdc105e5effea2943d3979cc1592590c923a589009b484d07672faaf047af1 + md5: 5d6e5cb3a4b820f61b2073f0ad5431f1 depends: - __unix - decorator @@ -6538,54 +6510,59 @@ packages: license_family: BSD purls: - pkg:pypi/ipython?source=project-defined-mapping - size: 598878 - timestamp: 1725050237172 -- kind: conda - name: ipywidgets - version: 8.1.5 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/ipywidgets-8.1.5-pyhd8ed1ab_0.conda - sha256: ae27447f300c85a184d5d4fa08674eaa93931c12275daca981eb986f5d7795b3 - md5: a022d34163147d16b27de86dc53e93fc + size: 600248 + timestamp: 1732897026255 +- conda: https://conda.anaconda.org/conda-forge/noarch/ipython_genutils-0.2.0-pyhd8ed1ab_2.conda + sha256: 45821a8986b4cb2421f766b240dbe6998a3c3123f012dd566720c1322e9b6e18 + md5: 2f0ba4bc12af346bc6c99bdc377e8944 + depends: + - python >=3.9 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/ipython-genutils?source=project-defined-mapping + size: 28153 + timestamp: 1733399692864 +- conda: https://conda.anaconda.org/conda-forge/noarch/ipywidgets-8.1.5-pyhd8ed1ab_1.conda + sha256: f419657566e3d9bea85b288a0ce3a8e42d76cd82ac1697c6917891df3ae149ab + md5: bb19ad65196475ab6d0bb3532d7f8d96 depends: - comm >=0.1.3 - ipython >=6.1.0 - jupyterlab_widgets >=3.0.13,<3.1.0 - - python >=3.7 + - python >=3.9 - traitlets >=4.3.1 - widgetsnbextension >=4.0.13,<4.1.0 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/ipywidgets?source=project-defined-mapping - size: 113497 - timestamp: 1724334989324 -- kind: conda - name: isoduration - version: 20.11.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/isoduration-20.11.0-pyhd8ed1ab_0.tar.bz2 - sha256: 7bb5c4d994361022f47a807b5e7d101b3dce16f7dd8a0af6ffad9f479d346493 - md5: 4cb68948e0b8429534380243d063a27a + size: 113982 + timestamp: 1733493669268 +- conda: https://conda.anaconda.org/conda-forge/noarch/isoduration-20.11.0-pyhd8ed1ab_1.conda + sha256: 08e838d29c134a7684bca0468401d26840f41c92267c4126d7b43a6b533b0aed + md5: 0b0154421989637d424ccf0f104be51a depends: - arrow >=0.15.0 - - python >=3.7 + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/isoduration?source=project-defined-mapping - size: 17189 - timestamp: 1638811664194 -- kind: conda - name: jasper - version: 4.2.4 - build: h536e39c_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/jasper-4.2.4-h536e39c_0.conda + size: 19832 + timestamp: 1733493720346 +- conda: https://conda.anaconda.org/conda-forge/noarch/itsdangerous-2.2.0-pyhd8ed1ab_1.conda + sha256: 1684b7b16eec08efef5302ce298c606b163c18272b69a62b666fbaa61516f170 + md5: 7ac5f795c15f288984e32add616cdc59 + depends: + - python >=3.9 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/itsdangerous?source=project-defined-mapping + size: 19180 + timestamp: 1733308353037 +- conda: https://conda.anaconda.org/conda-forge/linux-64/jasper-4.2.4-h536e39c_0.conda sha256: 0a5ca92ea0261f435c27a3c3c5c5bc5e8b4b1af1343b21ef0cbc7c33b62f5239 md5: 9518ab7016cf4564778aef08b6bd8792 depends: @@ -6597,12 +6574,7 @@ packages: purls: [] size: 675951 timestamp: 1714298705230 -- kind: conda - name: jasper - version: 4.2.4 - build: h6c4e4ef_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/jasper-4.2.4-h6c4e4ef_0.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/jasper-4.2.4-h6c4e4ef_0.conda sha256: 9c874070f201b64d7ca02b59f1348354ae1c834e969cb83259133bb0406ee7fa md5: 9019e1298c84b0185a60c62741d720dd depends: @@ -6612,13 +6584,7 @@ packages: purls: [] size: 583310 timestamp: 1714298773123 -- kind: conda - name: jax - version: 0.4.28 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/jax-0.4.28-pyhd8ed1ab_0.conda +- conda: https://conda.anaconda.org/conda-forge/noarch/jax-0.4.28-pyhd8ed1ab_0.conda sha256: fe79157d59eba626787f5e436a28fbbd424b280bd0f2360176f6fd61d65d3baf md5: edfcf9aed0a7e02342060fb4a2f26aa5 depends: @@ -6635,39 +6601,26 @@ packages: - pkg:pypi/jax?source=project-defined-mapping size: 1277451 timestamp: 1720615792666 -- kind: conda - name: jax - version: 0.4.31 - build: pyhd8ed1ab_1 - build_number: 1 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/jax-0.4.31-pyhd8ed1ab_1.conda - sha256: cd642f411cf5286877df1cbaf7aa44e6b0d970c235bdfb2886f8efe92031fcd2 - md5: a42f5cae582f26492ec2b25c633d308a +- conda: https://conda.anaconda.org/conda-forge/noarch/jax-0.4.31-pyhd8ed1ab_2.conda + sha256: 849e3d02afb5f8bf693368ce7cc12204ddb32c9f5f4471d010af726da2114014 + md5: dae0931d69c73c67ee41b07cf7a75708 depends: - importlib-metadata >=4.6 - jaxlib >=0.4.30,<=0.4.31 - ml_dtypes >=0.2.0 - - numpy >=1.24 + - numpy >=1.26 - opt-einsum - - python >=3.9 - - scipy >=1.10 + - python >=3.10 + - scipy >=1.11.1 constrains: - cudnn >=9.2.1.18 license: Apache-2.0 license_family: APACHE purls: - pkg:pypi/jax?source=project-defined-mapping - size: 1345141 - timestamp: 1725068486559 -- kind: conda - name: jaxlib - version: 0.4.28 - build: cuda120py312h4008524_200 - build_number: 200 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/jaxlib-0.4.28-cuda120py312h4008524_200.conda + size: 1343921 + timestamp: 1728895233912 +- conda: https://conda.anaconda.org/conda-forge/linux-64/jaxlib-0.4.28-cuda120py312h4008524_200.conda sha256: c38b0c91570573ae75c431529915056304ff8014d09e1e158a67e6884f6db68c md5: 91faec839d3abd26508af9ad8c7fe230 depends: @@ -6705,27 +6658,21 @@ packages: - pkg:pypi/jaxlib?source=project-defined-mapping size: 87314826 timestamp: 1720649030129 -- kind: conda - name: jaxlib - version: 0.4.31 - build: cpu_py312h47007b3_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/jaxlib-0.4.31-cpu_py312h47007b3_1.conda - sha256: 47d0db0455192cc360ce0275f6bcd3be3de589560c8b1fd85a58a850289cbf69 - md5: 2e8faa2c74c4625bcfb8369774a24c70 +- conda: https://conda.anaconda.org/conda-forge/linux-64/jaxlib-0.4.31-cpu_py312h6b2a80f_1.conda + sha256: ee55de88a2e2fdcf80474bb5b9ca6d50b52a2c262f912d8e4094d59defc44131 + md5: 253fe0d4a1c63b70f92b3179bdb14c6d depends: - - __osx >=11.0 + - __glibc >=2.17,<3.0.a0 - libabseil * cxx17* - libabseil >=20240116.2,<20240117.0a0 - - libcxx >=17 + - libgcc >=13 - libgrpc >=1.62.2,<1.63.0a0 + - libstdcxx >=13 - libzlib >=1.3.1,<2.0a0 - ml_dtypes >=0.2.0 - numpy >=1.19,<3 - openssl >=3.3.1,<4.0a0 - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 - scipy >=1.9 constrains: @@ -6734,29 +6681,23 @@ packages: license_family: APACHE purls: - pkg:pypi/jaxlib?source=project-defined-mapping - size: 47993894 - timestamp: 1725060448444 -- kind: conda - name: jaxlib - version: 0.4.31 - build: cpu_py312h6b2a80f_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/jaxlib-0.4.31-cpu_py312h6b2a80f_1.conda - sha256: ee55de88a2e2fdcf80474bb5b9ca6d50b52a2c262f912d8e4094d59defc44131 - md5: 253fe0d4a1c63b70f92b3179bdb14c6d + size: 58871481 + timestamp: 1725057743526 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/jaxlib-0.4.31-cpu_py312h47007b3_1.conda + sha256: 47d0db0455192cc360ce0275f6bcd3be3de589560c8b1fd85a58a850289cbf69 + md5: 2e8faa2c74c4625bcfb8369774a24c70 depends: - - __glibc >=2.17,<3.0.a0 + - __osx >=11.0 - libabseil * cxx17* - libabseil >=20240116.2,<20240117.0a0 - - libgcc >=13 + - libcxx >=17 - libgrpc >=1.62.2,<1.63.0a0 - - libstdcxx >=13 - libzlib >=1.3.1,<2.0a0 - ml_dtypes >=0.2.0 - numpy >=1.19,<3 - openssl >=3.3.1,<4.0a0 - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 - scipy >=1.9 constrains: @@ -6765,94 +6706,72 @@ packages: license_family: APACHE purls: - pkg:pypi/jaxlib?source=project-defined-mapping - size: 58871481 - timestamp: 1725057743526 -- kind: pypi + size: 47993894 + timestamp: 1725060448444 +- pypi: https://files.pythonhosted.org/packages/94/99/c83c6a97f4382caf1c9bfeeeca935d3eb1f479f711665aeadf4408048107/jaxtyping-0.2.36-py3-none-any.whl name: jaxtyping - version: 0.2.34 - url: https://files.pythonhosted.org/packages/56/ae/220537f80eb82ae43a299de31edb2a91a28b8c5fb8046e9ff853ec7763cd/jaxtyping-0.2.34-py3-none-any.whl - sha256: 2f81fb6d1586e497a6ea2d28c06dcab37b108a096cbb36ea3fe4fa2e1c1f32e5 + version: 0.2.36 + sha256: b19bcbd4009df8734602203402483a4066ad2eb3382904432e370588e9c9707d requires_dist: - - typeguard==2.13.3 - requires_python: ~=3.9 -- kind: conda - name: jedi - version: 0.19.1 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/jedi-0.19.1-pyhd8ed1ab_0.conda - sha256: 362f0936ef37dfd1eaa860190e42a6ebf8faa094eaa3be6aa4d9ace95f40047a - md5: 81a3be0b2023e1ea8555781f0ad904a2 + - typing-extensions ; python_full_version < '3.10' + requires_python: '>=3.9' +- conda: https://conda.anaconda.org/conda-forge/noarch/jedi-0.19.2-pyhd8ed1ab_1.conda + sha256: 92c4d217e2dc68983f724aa983cca5464dcb929c566627b26a2511159667dba8 + md5: a4f4c5dc9b80bc50e0d3dc4e6e8f1bd9 depends: - parso >=0.8.3,<0.9.0 - - python >=3.6 - license: MIT - license_family: MIT + - python >=3.9 + license: Apache-2.0 AND MIT purls: - pkg:pypi/jedi?source=project-defined-mapping - size: 841312 - timestamp: 1696326218364 -- kind: conda - name: jinja2 - version: 3.1.4 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.4-pyhd8ed1ab_0.conda - sha256: 27380d870d42d00350d2d52598cddaf02f9505fb24be09488da0c9b8d1428f2d - md5: 7b86ecb7d3557821c649b3c31e3eb9f2 + size: 843646 + timestamp: 1733300981994 +- conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.4-pyhd8ed1ab_1.conda + sha256: 85a7169c078b8065bd9d121b0e7b99c8b88c42a411314b6ae5fcd81c48c4710a + md5: 08cce3151bde4ecad7885bd9fb647532 depends: - markupsafe >=2.0 - - python >=3.7 + - python >=3.9 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/jinja2?source=project-defined-mapping - size: 111565 - timestamp: 1715127275924 -- kind: conda - name: joblib - version: 1.4.2 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/joblib-1.4.2-pyhd8ed1ab_0.conda - sha256: 8ad719524b1039510fcbd75eb776123189d75e2c09228189257ddbcab86f5b64 - md5: 25df261d4523d9f9783bcdb7208d872f + size: 110963 + timestamp: 1733217424408 +- conda: https://conda.anaconda.org/conda-forge/noarch/joblib-1.4.2-pyhd8ed1ab_1.conda + sha256: 51cc2dc491668af0c4d9299b0ab750f16ccf413ec5e2391b924108c1fbacae9b + md5: bf8243ee348f3a10a14ed0cae323e0c1 depends: - - python >=3.8 + - python >=3.9 - setuptools license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/joblib?source=project-defined-mapping - size: 219731 - timestamp: 1714665585214 -- kind: conda - name: json5 - version: 0.9.25 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/json5-0.9.25-pyhd8ed1ab_0.conda - sha256: 0c75e428970e8bb72ba1dd3a6dc32b8d68f6534b4fe16b38e53364963fdc8e38 - md5: 5d8c241a9261e720a34a07a3e1ac4109 + size: 220252 + timestamp: 1733736157394 +- conda: https://conda.anaconda.org/conda-forge/noarch/json5-0.10.0-pyhd8ed1ab_1.conda + sha256: 61bca2dac194c44603446944745566d7b4e55407280f6f6cea8bbe4de26b558f + md5: cd170f82d8e5b355dfdea6adab23e4af depends: - - python >=3.7,<4.0 + - python >=3.9 license: Apache-2.0 license_family: APACHE purls: - pkg:pypi/json5?source=project-defined-mapping - size: 27995 - timestamp: 1712986338874 -- kind: conda - name: jsonpointer - version: 3.0.0 - build: py312h7900ff3_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/jsonpointer-3.0.0-py312h7900ff3_1.conda + size: 31573 + timestamp: 1733272196759 +- conda: https://conda.anaconda.org/conda-forge/linux-64/jsoncpp-1.9.5-h4bd325d_1.tar.bz2 + sha256: 7a5a6cdfc17849bb8000cc31b91c22f1fe0e087dfc3fd59ecc4d3b64cf0ad772 + md5: ae7f50dd1e78c7e78b5d2cf7062e559d + depends: + - libgcc-ng >=9.4.0 + - libstdcxx-ng >=9.4.0 + license: LicenseRef-Public-Domain OR MIT + purls: [] + size: 194553 + timestamp: 1640883128046 +- conda: https://conda.anaconda.org/conda-forge/linux-64/jsonpointer-3.0.0-py312h7900ff3_1.conda sha256: 76ccb7bffc7761d1d3133ffbe1f7f1710a0f0d9aaa9f7ea522652e799f3601f4 md5: 6b51f7459ea4073eeb5057207e2e1e3d depends: @@ -6864,13 +6783,7 @@ packages: - pkg:pypi/jsonpointer?source=project-defined-mapping size: 17277 timestamp: 1725303032027 -- kind: conda - name: jsonpointer - version: 3.0.0 - build: py312h81bd7bf_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/jsonpointer-3.0.0-py312h81bd7bf_1.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/jsonpointer-3.0.0-py312h81bd7bf_1.conda sha256: f6fb3734e967d1cd0cde32844ee952809f6c0a49895da7ec1c8cfdf97739b947 md5: 80f403c03290e1662be03e026fb5f8ab depends: @@ -6883,57 +6796,38 @@ packages: - pkg:pypi/jsonpointer?source=project-defined-mapping size: 17865 timestamp: 1725303130815 -- kind: conda - name: jsonschema - version: 4.23.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/jsonschema-4.23.0-pyhd8ed1ab_0.conda - sha256: 7d0c4c0346b26be9f220682b7c5c0d84606d48c6dbc36fc238e4452dda733aff - md5: da304c192ad59975202859b367d0f6a2 +- conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-4.23.0-pyhd8ed1ab_1.conda + sha256: be992a99e589146f229c58fe5083e0b60551d774511c494f91fe011931bd7893 + md5: a3cead9264b331b32fe8f0aabc967522 depends: - attrs >=22.2.0 - importlib_resources >=1.4.0 - jsonschema-specifications >=2023.03.6 - pkgutil-resolve-name >=1.3.10 - - python >=3.8 + - python >=3.9 - referencing >=0.28.4 - rpds-py >=0.7.1 license: MIT license_family: MIT purls: - pkg:pypi/jsonschema?source=project-defined-mapping - size: 74323 - timestamp: 1720529611305 -- kind: conda - name: jsonschema-specifications - version: 2023.12.1 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/jsonschema-specifications-2023.12.1-pyhd8ed1ab_0.conda - sha256: a9630556ddc3121c0be32f4cbf792dd9102bd380d5cd81d57759d172cf0c2da2 - md5: a0e4efb5f35786a05af4809a2fb1f855 + size: 74256 + timestamp: 1733472818764 +- conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-specifications-2024.10.1-pyhd8ed1ab_1.conda + sha256: 37127133837444cf0e6d1a95ff5a505f8214ed4e89e8e9343284840e674c6891 + md5: 3b519bc21bc80e60b456f1e62962a766 depends: - - importlib_resources >=1.4.0 - - python >=3.8 + - python >=3.9 - referencing >=0.31.0 license: MIT license_family: MIT purls: - pkg:pypi/jsonschema-specifications?source=project-defined-mapping - size: 16431 - timestamp: 1703778502971 -- kind: conda - name: jsonschema-with-format-nongpl - version: 4.23.0 - build: hd8ed1ab_0 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/jsonschema-with-format-nongpl-4.23.0-hd8ed1ab_0.conda - sha256: 007a0a506a0d1805b099629cb0ee743ad0afe7d9749e57339f32c168119e0139 - md5: 16b37612b3a2fd77f409329e213b530c + size: 16170 + timestamp: 1733493624968 +- conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-with-format-nongpl-4.23.0-hd8ed1ab_1.conda + sha256: 6e0184530011961a0802fda100ecdfd4b0eca634ed94c37e553b72e21c26627d + md5: a5b1a8065857cc4bd8b7a38d063bb728 depends: - fqdn - idna @@ -6947,16 +6841,9 @@ packages: license: MIT license_family: MIT purls: [] - size: 7143 - timestamp: 1720529619500 -- kind: conda - name: jupyter - version: 1.0.0 - build: pyhd8ed1ab_10 - build_number: 10 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/jupyter-1.0.0-pyhd8ed1ab_10.conda + size: 7135 + timestamp: 1733472820035 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-1.0.0-pyhd8ed1ab_10.conda sha256: 308b521b149e7a1739f717538b929bc2d87b9001b94f13ee8baa939632a86150 md5: 056b8cc3d9b03f54fc49e6d70d7dc359 depends: @@ -6973,32 +6860,20 @@ packages: - pkg:pypi/jupyter?source=project-defined-mapping size: 8620 timestamp: 1696255649672 -- kind: conda - name: jupyter-lsp - version: 2.2.5 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/jupyter-lsp-2.2.5-pyhd8ed1ab_0.conda - sha256: 2151c2c63e0442a4c69ee0ad8a634195eedab10b7b74c0ec8266471842239a93 - md5: 885867f6adab3d7ecdf8ab6ca0785f51 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-lsp-2.2.5-pyhd8ed1ab_1.conda + sha256: 1565c8b1423a37fca00fe0ab2a17cd8992c2ecf23e7867a1c9f6f86a9831c196 + md5: 0b4c3908e5a38ea22ebb98ee5888c768 depends: - importlib-metadata >=4.8.3 - jupyter_server >=1.1.2 - - python >=3.8 + - python >=3.9 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/jupyter-lsp?source=project-defined-mapping - size: 55539 - timestamp: 1712707521811 -- kind: conda - name: jupyter-ui-poll - version: 0.2.2 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/jupyter-ui-poll-0.2.2-pyhd8ed1ab_0.tar.bz2 + size: 55221 + timestamp: 1733493006611 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-ui-poll-0.2.2-pyhd8ed1ab_0.tar.bz2 sha256: 92c58806dcfa2f067d4fa489506b4918a3f5f0836148b549b5df5bcbd60d7a22 md5: 261a202711ba96680f7874ad4c6e5f51 depends: @@ -7010,19 +6885,13 @@ packages: - pkg:pypi/jupyter-ui-poll?source=project-defined-mapping size: 13222 timestamp: 1666838644399 -- kind: conda - name: jupyter_client - version: 8.6.2 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.6.2-pyhd8ed1ab_0.conda - sha256: 634f065cdd1d0aacd4bb6848ebf240dcebc8578135d65f4ad4aa42b2276c4e0c - md5: 3cdbb2fa84490e5fd44c9f9806c0d292 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.6.3-pyhd8ed1ab_1.conda + sha256: 19d8bd5bb2fde910ec59e081eeb59529491995ce0d653a5209366611023a0b3a + md5: 4ebae00eae9705b0c3d6d1018a81d047 depends: - - importlib_metadata >=4.8.3 + - importlib-metadata >=4.8.3 - jupyter_core >=4.12,!=5.0.* - - python >=3.8 + - python >=3.9 - python-dateutil >=2.8.2 - pyzmq >=23.0 - tornado >=6.2 @@ -7031,17 +6900,11 @@ packages: license_family: BSD purls: - pkg:pypi/jupyter-client?source=project-defined-mapping - size: 106248 - timestamp: 1716472312833 -- kind: conda - name: jupyter_console - version: 6.6.3 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/jupyter_console-6.6.3-pyhd8ed1ab_0.conda - sha256: 4e51764d5fe2f6e43d83bcfbcf8b4da6569721bf82eaf4d647be8717cd6be75a - md5: 7cf6f52a66f8e3cd9d8b6c231262dcab + size: 106342 + timestamp: 1733441040958 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_console-6.6.3-pyhd8ed1ab_1.conda + sha256: aee0cdd0cb2b9321d28450aec4e0fd43566efcd79e862d70ce49a68bf0539bcd + md5: 801dbf535ec26508fac6d4b24adfb76e depends: - ipykernel >=6.14 - ipython @@ -7049,66 +6912,36 @@ packages: - jupyter_core >=4.12,!=5.0.* - prompt_toolkit >=3.0.30 - pygments - - python >=3.7 + - python >=3.9 - pyzmq >=17 - traitlets >=5.4 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/jupyter-console?source=project-defined-mapping - size: 26484 - timestamp: 1678118234022 -- kind: conda - name: jupyter_core - version: 5.7.2 - build: py312h7900ff3_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/jupyter_core-5.7.2-py312h7900ff3_0.conda - sha256: 22a6259c2b139191c76ed7633d1865757b3c15007989f6c74304a80f28e5a262 - md5: eee5a2e3465220ed87196bbb5665f420 - depends: - - platformdirs >=2.5 - - python >=3.12,<3.13.0a0 - - python_abi 3.12.* *_cp312 - - traitlets >=5.3 - license: BSD-3-Clause - license_family: BSD - purls: - - pkg:pypi/jupyter-core?source=project-defined-mapping - size: 92843 - timestamp: 1710257533875 -- kind: conda - name: jupyter_core - version: 5.7.2 - build: py312h81bd7bf_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/jupyter_core-5.7.2-py312h81bd7bf_0.conda - sha256: 5ab0e75a30915d34ae27b4a76f1241c2f4cc4419b6b1c838cc1160b9ec8bfaf5 - md5: 209b9cb7159212afce5e16d7a3ee3b47 + size: 26874 + timestamp: 1733818130068 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_core-5.7.2-pyh31011fe_1.conda + sha256: 732b1e8536bc22a5a174baa79842d79db2f4956d90293dd82dc1b3f6099bcccd + md5: 0a2980dada0dd7fd0998f0342308b1b1 depends: + - __unix - platformdirs >=2.5 - - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - - python_abi 3.12.* *_cp312 + - python >=3.8 - traitlets >=5.3 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/jupyter-core?source=project-defined-mapping - size: 93829 - timestamp: 1710257916303 -- kind: conda - name: jupyter_events - version: 0.10.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/jupyter_events-0.10.0-pyhd8ed1ab_0.conda - sha256: cd3f41dc093162a41d4bae171e40a1b9b115c4d488e9bb837a8fa9d084931fb9 - md5: ed45423c41b3da15ea1df39b1f80c2ca + size: 57671 + timestamp: 1727163547058 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_events-0.11.0-pyhd8ed1ab_0.conda + sha256: eeb32aa58d37b130387628d5c151092f6d3fcf0a6964294bef06d6bac117f3c4 + md5: 2d8876ca6bda213622dfbc3d1da56ecb depends: - jsonschema-with-format-nongpl >=4.18.0 - - python >=3.8 + - packaging + - python >=3.9 - python-json-logger >=2.0.4 - pyyaml >=5.3 - referencing @@ -7119,17 +6952,11 @@ packages: license_family: BSD purls: - pkg:pypi/jupyter-events?source=project-defined-mapping - size: 21475 - timestamp: 1710805759187 -- kind: conda - name: jupyter_server - version: 2.14.2 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/jupyter_server-2.14.2-pyhd8ed1ab_0.conda - sha256: edab71a05feceac54bdb90e755a257545af7832b9911607c1a70f09be44ba985 - md5: ca23c71f70a7c7935b3d03f0f1a5801d + size: 22160 + timestamp: 1734531779868 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_server-2.14.2-pyhd8ed1ab_1.conda + sha256: 082d3517455339c8baea245a257af249758ccec26b8832d969ac928901c234cc + md5: 81ea84b3212287f926e35b9036192963 depends: - anyio >=3.1.0 - argon2-cffi >=21.1 @@ -7143,7 +6970,7 @@ packages: - overrides >=5.0 - packaging >=22.0 - prometheus_client >=0.9 - - python >=3.8 + - python >=3.9 - pyzmq >=24 - send2trash >=1.8.2 - terminado >=0.8.3 @@ -7154,40 +6981,27 @@ packages: license_family: BSD purls: - pkg:pypi/jupyter-server?source=project-defined-mapping - size: 323978 - timestamp: 1720816754998 -- kind: conda - name: jupyter_server_terminals - version: 0.5.3 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/jupyter_server_terminals-0.5.3-pyhd8ed1ab_0.conda - sha256: 038efbc7e4b2e72d49ed193cfb2bbbe9fbab2459786ce9350301f466a32567db - md5: 219b3833aa8ed91d47d1be6ca03f30be + size: 324289 + timestamp: 1733428731329 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_server_terminals-0.5.3-pyhd8ed1ab_1.conda + sha256: 0890fc79422191bc29edf17d7b42cff44ba254aa225d31eb30819f8772b775b8 + md5: 2d983ff1b82a1ccb6f2e9d8784bdd6bd depends: - - python >=3.8 + - python >=3.9 - terminado >=0.8.3 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/jupyter-server-terminals?source=project-defined-mapping - size: 19818 - timestamp: 1710262791393 -- kind: conda - name: jupyterlab - version: 4.2.5 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/jupyterlab-4.2.5-pyhd8ed1ab_0.conda - sha256: db08036a6fd846c178ebdce7327be1130bda10ac96113c17b04bce2bc4d67dda - md5: 594762eddc55b82feac6097165a88e3c + size: 19711 + timestamp: 1733428049134 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab-4.3.3-pyhd8ed1ab_0.conda + sha256: 63aa00427abd4a3e7c1738257b8e296f5e0ba04a4a1ab9ff3bc186440c8b9fdc + md5: 0707e62d944a89c365ba11da4898f8af depends: - async-lru >=1.0.0 - httpx >=0.25.0 - - importlib_metadata >=4.8.3 - - importlib_resources >=1.4 + - importlib-metadata >=4.8.3 - ipykernel >=6.5.0 - jinja2 >=3.0.3 - jupyter-lsp >=2.0.0 @@ -7196,8 +7010,8 @@ packages: - jupyterlab_server >=2.27.1,<3 - notebook-shim >=0.2 - packaging - - python >=3.8 - - setuptools >=40.1.0 + - python >=3.9 + - setuptools >=40.8.0 - tomli >=1.2.2 - tornado >=6.2.0 - traitlets @@ -7205,38 +7019,25 @@ packages: license_family: BSD purls: - pkg:pypi/jupyterlab?source=project-defined-mapping - size: 7361961 - timestamp: 1724745262468 -- kind: conda - name: jupyterlab_pygments - version: 0.3.0 - build: pyhd8ed1ab_1 - build_number: 1 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_pygments-0.3.0-pyhd8ed1ab_1.conda - sha256: 4aa622bbcf97e44cd1adf0100b7ff71b7e20268f043bdf6feae4d16152f1f242 - md5: afcd1b53bcac8844540358e33f33d28f + size: 7972675 + timestamp: 1733836496011 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_pygments-0.3.0-pyhd8ed1ab_2.conda + sha256: dc24b900742fdaf1e077d9a3458fd865711de80bca95fe3c6d46610c532c6ef0 + md5: fd312693df06da3578383232528c468d depends: - pygments >=2.4.1,<3 - - python >=3.7 + - python >=3.9 constrains: - jupyterlab >=4.0.8,<5.0.0 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/jupyterlab-pygments?source=project-defined-mapping - size: 18776 - timestamp: 1707149279640 -- kind: conda - name: jupyterlab_server - version: 2.27.3 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_server-2.27.3-pyhd8ed1ab_0.conda - sha256: a23b26d1a35bccdb91b9232119e5f402624e1e1a252b0e64cc20c6eb5b87cefb - md5: af8239bf1ba7e8c69b689f780f653488 + size: 18711 + timestamp: 1733328194037 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_server-2.27.3-pyhd8ed1ab_1.conda + sha256: d03d0b7e23fa56d322993bc9786b3a43b88ccc26e58b77c756619a921ab30e86 + md5: 9dc4b2b0f41f0de41d27f3293e319357 depends: - babel >=2.10 - importlib-metadata >=4.8.3 @@ -7245,7 +7046,7 @@ packages: - jsonschema >=4.18 - jupyter_server >=1.21,<3 - packaging >=21.3 - - python >=3.8 + - python >=3.9 - requests >=2.31 constrains: - openapi-core >=0.18.0,<0.19.0 @@ -7253,75 +7054,49 @@ packages: license_family: BSD purls: - pkg:pypi/jupyterlab-server?source=project-defined-mapping - size: 49355 - timestamp: 1721163412436 -- kind: conda - name: jupyterlab_widgets - version: 3.0.13 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_widgets-3.0.13-pyhd8ed1ab_0.conda - sha256: 0e7ec7936d766f39d5a0a8eafc63f5543f488883ad3645246bc22db6d632566e - md5: ccea946e6dce9f330fbf7fca97fe8de7 + size: 49449 + timestamp: 1733599666357 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_widgets-3.0.13-pyhd8ed1ab_1.conda + sha256: 206489e417408d2ffc2a7b245008b4735a8beb59df6c9109d4f77e7bc5969d5d + md5: b26e487434032d7f486277beb0cead3a depends: - - python >=3.7 + - python >=3.9 constrains: - jupyterlab >=3,<5 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/jupyterlab-widgets?source=project-defined-mapping - size: 186024 - timestamp: 1724331451102 -- kind: conda - name: jupytext - version: 1.16.4 - build: pyh80e38bb_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/jupytext-1.16.4-pyh80e38bb_0.conda - sha256: e0e904bcc18a3b31dc79b05f98a3fd46c9e52b27e7942856f767f0c0b815ae15 - md5: 1df7fd1594a7f2f6496ff23834a099bf + size: 186358 + timestamp: 1733428156991 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupytext-1.16.5-pyhbbac1ac_1.conda + sha256: d2a33f516a93e28827e184ec092fae8b2af5ef7e0254a6ba2815c7652d940fd4 + md5: 2a80b4989a2c02a7306dc2352470411b depends: - markdown-it-py >=1.0 - mdit-py-plugins - nbformat - packaging - - python >=3.8 + - python >=3.9 - pyyaml - tomli license: MIT license_family: MIT purls: - - pkg:pypi/jupytext?source=project-defined-mapping - size: 104513 - timestamp: 1722332096729 -- kind: conda - name: kernel-headers_linux-64 - version: 3.10.0 - build: h4a8ded7_16 - build_number: 16 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-3.10.0-h4a8ded7_16.conda - sha256: a55044e0f61058a5f6bab5e1dd7f15a1fa7a08ec41501dbfca5ab0fc50b9c0c1 - md5: ff7f38675b226cfb855aebfc32a13e31 - depends: - - _sysroot_linux-64_curr_repodata_hack 3.* + - pkg:pypi/jupytext?source=project-defined-mapping + size: 105310 + timestamp: 1734510335379 +- conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-3.10.0-he073ed8_18.conda + sha256: a922841ad80bd7b222502e65c07ecb67e4176c4fa5b03678a005f39fcc98be4b + md5: ad8527bf134a90e1c9ed35fa0b64318c constrains: - sysroot_linux-64 ==2.17 license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later AND MPL-2.0 license_family: GPL purls: [] - size: 944344 - timestamp: 1720621422017 -- kind: conda - name: keyutils - version: 1.6.1 - build: h166bdaf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.1-h166bdaf_0.tar.bz2 + size: 943486 + timestamp: 1729794504440 +- conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.1-h166bdaf_0.tar.bz2 sha256: 150c05a6e538610ca7c43beb3a40d65c90537497a4f6a5f4d15ec0451b6f5ebb md5: 30186d27e2c9fa62b45fb1476b7200e3 depends: @@ -7330,32 +7105,7 @@ packages: purls: [] size: 117831 timestamp: 1646151697040 -- kind: conda - name: kiwisolver - version: 1.4.7 - build: py312h6142ec9_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/kiwisolver-1.4.7-py312h6142ec9_0.conda - sha256: 056a2cc3b6c07c79719cb8f2eda09408fca137b49fe46f919ef14247caa6f0e9 - md5: ea8a65d24baad7ed822ab7f07f19e105 - depends: - - __osx >=11.0 - - libcxx >=17 - - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - - python_abi 3.12.* *_cp312 - license: BSD-3-Clause - license_family: BSD - purls: - - pkg:pypi/kiwisolver?source=project-defined-mapping - size: 60966 - timestamp: 1725459569843 -- kind: conda - name: kiwisolver - version: 1.4.7 - build: py312h68727a3_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/kiwisolver-1.4.7-py312h68727a3_0.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/kiwisolver-1.4.7-py312h68727a3_0.conda sha256: d752c53071ee5d712baa9742dd1629e60388c5ce4ab11d4e73a1690443e41769 md5: 444266743652a4f1538145e9362f6d3b depends: @@ -7370,31 +7120,22 @@ packages: - pkg:pypi/kiwisolver?source=project-defined-mapping size: 70922 timestamp: 1725459412788 -- kind: conda - name: krb5 - version: 1.21.3 - build: h237132a_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.21.3-h237132a_0.conda - sha256: 4442f957c3c77d69d9da3521268cad5d54c9033f1a73f99cde0a3658937b159b - md5: c6dc8a0fdec13a0565936655c33069a1 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/kiwisolver-1.4.7-py312h6142ec9_0.conda + sha256: 056a2cc3b6c07c79719cb8f2eda09408fca137b49fe46f919ef14247caa6f0e9 + md5: ea8a65d24baad7ed822ab7f07f19e105 depends: - __osx >=11.0 - - libcxx >=16 - - libedit >=3.1.20191231,<3.2.0a0 - - libedit >=3.1.20191231,<4.0a0 - - openssl >=3.3.1,<4.0a0 - license: MIT - license_family: MIT - purls: [] - size: 1155530 - timestamp: 1719463474401 -- kind: conda - name: krb5 - version: 1.21.3 - build: h659f571_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.3-h659f571_0.conda + - libcxx >=17 + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/kiwisolver?source=project-defined-mapping + size: 60966 + timestamp: 1725459569843 +- conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.3-h659f571_0.conda sha256: 99df692f7a8a5c27cd14b5fb1374ee55e756631b9c3d659ed3ee60830249b238 md5: 3f43953b7d3fb3aaa1d0d0723d91e368 depends: @@ -7409,13 +7150,21 @@ packages: purls: [] size: 1370023 timestamp: 1719463201255 -- kind: conda - name: lame - version: '3.100' - build: h166bdaf_1003 - build_number: 1003 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/lame-3.100-h166bdaf_1003.tar.bz2 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.21.3-h237132a_0.conda + sha256: 4442f957c3c77d69d9da3521268cad5d54c9033f1a73f99cde0a3658937b159b + md5: c6dc8a0fdec13a0565936655c33069a1 + depends: + - __osx >=11.0 + - libcxx >=16 + - libedit >=3.1.20191231,<3.2.0a0 + - libedit >=3.1.20191231,<4.0a0 + - openssl >=3.3.1,<4.0a0 + license: MIT + license_family: MIT + purls: [] + size: 1155530 + timestamp: 1719463474401 +- conda: https://conda.anaconda.org/conda-forge/linux-64/lame-3.100-h166bdaf_1003.tar.bz2 sha256: aad2a703b9d7b038c0f745b853c6bb5f122988fe1a7a096e0e606d9cbec4eaab md5: a8832b479f93521a9e7b5b743803be51 depends: @@ -7425,13 +7174,7 @@ packages: purls: [] size: 508258 timestamp: 1664996250081 -- kind: conda - name: lame - version: '3.100' - build: h1a8c8d9_1003 - build_number: 1003 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/lame-3.100-h1a8c8d9_1003.tar.bz2 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/lame-3.100-h1a8c8d9_1003.tar.bz2 sha256: f40ce7324b2cf5338b766d4cdb8e0453e4156a4f83c2f31bbfff750785de304c md5: bff0e851d66725f78dc2fd8b032ddb7e license: LGPL-2.0-only @@ -7439,61 +7182,42 @@ packages: purls: [] size: 528805 timestamp: 1664996399305 -- kind: conda - name: lcms2 - version: '2.16' - build: ha0e7c42_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/lcms2-2.16-ha0e7c42_0.conda - sha256: 151e0c84feb7e0747fabcc85006b8973b22f5abbc3af76a9add0b0ef0320ebe4 - md5: 66f6c134e76fe13cce8a9ea5814b5dd5 - depends: - - libjpeg-turbo >=3.0.0,<4.0a0 - - libtiff >=4.6.0,<4.7.0a0 - license: MIT - license_family: MIT - purls: [] - size: 211959 - timestamp: 1701647962657 -- kind: conda - name: lcms2 - version: '2.16' - build: hb7c19ff_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/lcms2-2.16-hb7c19ff_0.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/lcms2-2.16-hb7c19ff_0.conda sha256: 5c878d104b461b7ef922abe6320711c0d01772f4cd55de18b674f88547870041 md5: 51bb7010fc86f70eee639b4bb7a894f5 depends: - libgcc-ng >=12 - libjpeg-turbo >=3.0.0,<4.0a0 - - libtiff >=4.6.0,<4.7.0a0 + - libtiff >=4.6.0,<4.8.0a0 license: MIT license_family: MIT purls: [] size: 245247 timestamp: 1701647787198 -- kind: conda - name: ld_impl_linux-64 - version: '2.40' - build: hf3520f5_7 - build_number: 7 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.40-hf3520f5_7.conda - sha256: 764b6950aceaaad0c67ef925417594dd14cd2e22fff864aeef455ac259263d15 - md5: b80f2f396ca2c28b8c14c437a4ed1e74 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/lcms2-2.16-ha0e7c42_0.conda + sha256: 151e0c84feb7e0747fabcc85006b8973b22f5abbc3af76a9add0b0ef0320ebe4 + md5: 66f6c134e76fe13cce8a9ea5814b5dd5 + depends: + - libjpeg-turbo >=3.0.0,<4.0a0 + - libtiff >=4.6.0,<4.8.0a0 + license: MIT + license_family: MIT + purls: [] + size: 211959 + timestamp: 1701647962657 +- conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.43-h712a8e2_2.conda + sha256: 7c91cea91b13f4314d125d1bedb9d03a29ebbd5080ccdea70260363424646dbe + md5: 048b02e3962f066da18efe3a21b77672 + depends: + - __glibc >=2.17,<3.0.a0 constrains: - - binutils_impl_linux-64 2.40 + - binutils_impl_linux-64 2.43 license: GPL-3.0-only license_family: GPL purls: [] - size: 707602 - timestamp: 1718625640445 -- kind: conda - name: lerc - version: 4.0.0 - build: h27087fc_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/lerc-4.0.0-h27087fc_0.tar.bz2 + size: 669211 + timestamp: 1729655358674 +- conda: https://conda.anaconda.org/conda-forge/linux-64/lerc-4.0.0-h27087fc_0.tar.bz2 sha256: cb55f36dcd898203927133280ae1dc643368af041a48bcf7c026acb7c47b0c12 md5: 76bbff344f0134279f225174e9064c8f depends: @@ -7504,12 +7228,7 @@ packages: purls: [] size: 281798 timestamp: 1657977462600 -- kind: conda - name: lerc - version: 4.0.0 - build: h9a09cb3_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/lerc-4.0.0-h9a09cb3_0.tar.bz2 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/lerc-4.0.0-h9a09cb3_0.tar.bz2 sha256: 6f068bb53dfb6147d3147d981bb851bb5477e769407ad4e6a68edf482fdcb958 md5: de462d5aacda3b30721b512c5da4e742 depends: @@ -7519,13 +7238,37 @@ packages: purls: [] size: 215721 timestamp: 1657977558796 -- kind: conda - name: libabseil - version: '20240116.2' - build: cxx17_h00cdb27_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libabseil-20240116.2-cxx17_h00cdb27_1.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20240116.2-cxx17_he02047a_1.conda + sha256: 945396726cadae174a661ce006e3f74d71dbd719219faf7cc74696b267f7b0b5 + md5: c48fc56ec03229f294176923c3265c05 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + constrains: + - abseil-cpp =20240116.2 + - libabseil-static =20240116.2=cxx17* + license: Apache-2.0 + license_family: Apache + purls: [] + size: 1264712 + timestamp: 1720857377573 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20240722.0-cxx17_h5888daf_1.conda + sha256: 8f91429091183c26950f1e7ffa730e8632f0627ba35d2fccd71df31628c9b4e5 + md5: e1f604644fe8d78e22660e2fec6756bc + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + constrains: + - libabseil-static =20240722.0=cxx17* + - abseil-cpp =20240722.0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 1310521 + timestamp: 1727295454064 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libabseil-20240116.2-cxx17_h00cdb27_1.conda sha256: a9517c8683924f4b3b9380cdaa50fdd2009cd8d5f3918c92f64394238189d3cb md5: f16963d88aed907af8b90878b8d8a05c depends: @@ -7539,33 +7282,21 @@ packages: purls: [] size: 1136123 timestamp: 1720857649214 -- kind: conda - name: libabseil - version: '20240116.2' - build: cxx17_he02047a_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20240116.2-cxx17_he02047a_1.conda - sha256: 945396726cadae174a661ce006e3f74d71dbd719219faf7cc74696b267f7b0b5 - md5: c48fc56ec03229f294176923c3265c05 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libabseil-20240722.0-cxx17_hf9b8971_1.conda + sha256: 90bf08a75506dfcf28a70977da8ab050bcf594cd02abd3a9d84a22c9e8161724 + md5: 706da5e791c569a7b9814877098a6a0a depends: - - __glibc >=2.17,<3.0.a0 - - libgcc-ng >=12 - - libstdcxx-ng >=12 + - __osx >=11.0 + - libcxx >=17 constrains: - - abseil-cpp =20240116.2 - - libabseil-static =20240116.2=cxx17* + - libabseil-static =20240722.0=cxx17* + - abseil-cpp =20240722.0 license: Apache-2.0 license_family: Apache purls: [] - size: 1264712 - timestamp: 1720857377573 -- kind: conda - name: libaec - version: 1.1.3 - build: h59595ed_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libaec-1.1.3-h59595ed_0.conda + size: 1179072 + timestamp: 1727295571173 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libaec-1.1.3-h59595ed_0.conda sha256: 2ef420a655528bca9d269086cf33b7e90d2f54ad941b437fb1ed5eca87cee017 md5: 5e97e271911b8b2001a8b71860c32faa depends: @@ -7576,12 +7307,7 @@ packages: purls: [] size: 35446 timestamp: 1711021212685 -- kind: conda - name: libaec - version: 1.1.3 - build: hebf3989_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libaec-1.1.3-hebf3989_0.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libaec-1.1.3-hebf3989_0.conda sha256: 896189b7b48a194c46a3556ea04943ef81cbe0498521231f8eb25816a68bc8ed md5: 6f0b8e56d2e7bae12a18fc5b2cd9f310 depends: @@ -7591,12 +7317,7 @@ packages: purls: [] size: 28451 timestamp: 1711021498493 -- kind: conda - name: libarchive - version: 3.7.4 - build: hfca40fe_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libarchive-3.7.4-hfca40fe_0.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/libarchive-3.7.4-hfca40fe_0.conda sha256: c30970e5e6515c662d00bb74e7c1b09ebe0c8c92c772b952a41a5725e2dcc936 md5: 32ddb97f897740641d8d46a829ce1704 depends: @@ -7614,33 +7335,68 @@ packages: purls: [] size: 871853 timestamp: 1716394516418 -- kind: conda - name: libarrow - version: 17.0.0 - build: h20538ec_13_cpu - build_number: 13 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-17.0.0-h20538ec_13_cpu.conda - sha256: fb77709a184e934b8662388f91bf9bd51a96eb3b11c53d0453e9bc43b01b4c27 - md5: c6813f605a0fd1947e768b5f6138e0a7 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libarchive-3.7.7-h4585015_3.conda + sha256: 2466803e26ae9dbd2263de3a102b572b741c056549875c04b6ec10830bd5d338 + md5: a28808eae584c7f519943719b2a2b386 depends: - - __osx >=11.0 - - aws-crt-cpp >=0.28.2,<0.28.3.0a0 - - aws-sdk-cpp >=1.11.379,<1.11.380.0a0 + - __glibc >=2.17,<3.0.a0 + - bzip2 >=1.0.8,<2.0a0 + - libgcc >=13 + - liblzma >=5.6.3,<6.0a0 + - libxml2 >=2.13.5,<3.0a0 + - libzlib >=1.3.1,<2.0a0 + - lz4-c >=1.10.0,<1.11.0a0 + - lzo >=2.10,<3.0a0 + - openssl >=3.4.0,<4.0a0 + - zstd >=1.5.6,<1.6.0a0 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 878021 + timestamp: 1734020918345 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libarchive-3.7.7-hadbb8c3_0.conda + sha256: 68afcb4519d08cebf71845aff6038e7273f021efc04ef48246f8d41e4e462a61 + md5: 4a099677417658748239616b6ca96bb6 + depends: + - __glibc >=2.17,<3.0.a0 + - bzip2 >=1.0.8,<2.0a0 + - libgcc >=13 + - libxml2 >=2.13.5,<3.0a0 + - libzlib >=1.3.1,<2.0a0 + - lz4-c >=1.9.3,<1.10.0a0 + - lzo >=2.10,<3.0a0 + - openssl >=3.4.0,<4.0a0 + - xz >=5.2.6,<6.0a0 + - zstd >=1.5.6,<1.6.0a0 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 874221 + timestamp: 1732614239458 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-17.0.0-had3b6fe_16_cpu.conda + build_number: 16 + sha256: 9aa5598878cccc29de744ebc4b501c4a5a43332973edfdf0a19ddc521bd7248f + md5: c899e532e16be21570d32bc74ea3d34f + depends: + - __glibc >=2.17,<3.0.a0 + - aws-crt-cpp >=0.28.3,<0.28.4.0a0 + - aws-sdk-cpp >=1.11.407,<1.11.408.0a0 - azure-core-cpp >=1.13.0,<1.13.1.0a0 - azure-identity-cpp >=1.8.0,<1.8.1.0a0 - azure-storage-blobs-cpp >=12.12.0,<12.12.1.0a0 - azure-storage-files-datalake-cpp >=12.11.0,<12.11.1.0a0 - bzip2 >=1.0.8,<2.0a0 + - gflags >=2.2.2,<2.3.0a0 - glog >=0.7.1,<0.8.0a0 - libabseil * cxx17* - libabseil >=20240116.2,<20240117.0a0 - libbrotlidec >=1.1.0,<1.2.0a0 - libbrotlienc >=1.1.0,<1.2.0a0 - - libcxx >=17 - - libgoogle-cloud >=2.28.0,<2.29.0a0 - - libgoogle-cloud-storage >=2.28.0,<2.29.0a0 - - libre2-11 >=2023.9.1,<2024.0a0 + - libgcc >=13 + - libgoogle-cloud >=2.29.0,<2.30.0a0 + - libgoogle-cloud-storage >=2.29.0,<2.30.0a0 + - libre2-11 >=2023.9.1 + - libstdcxx >=13 - libutf8proc >=2.8.0,<3.0a0 - libzlib >=1.3.1,<2.0a0 - lz4-c >=1.9.3,<1.10.0a0 @@ -7648,44 +7404,78 @@ packages: - re2 - snappy >=1.2.1,<1.3.0a0 - zstd >=1.5.6,<1.6.0a0 + - libutf8proc <2.9 constrains: + - parquet-cpp <0.0a0 + - arrow-cpp <0.0a0 - apache-arrow-proc =*=cpu + license: Apache-2.0 + license_family: APACHE + purls: [] + size: 8495428 + timestamp: 1726669963852 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-18.1.0-h44a453e_6_cpu.conda + build_number: 6 + sha256: abf17e99b03356a9d6248e965826c1352ff01b00d3a62cc51393bb0744d72803 + md5: 2cf6d608d6e66506f69797d5c6944c35 + depends: + - __glibc >=2.17,<3.0.a0 + - aws-crt-cpp >=0.29.7,<0.29.8.0a0 + - aws-sdk-cpp >=1.11.458,<1.11.459.0a0 + - azure-core-cpp >=1.14.0,<1.14.1.0a0 + - azure-identity-cpp >=1.10.0,<1.10.1.0a0 + - azure-storage-blobs-cpp >=12.13.0,<12.13.1.0a0 + - azure-storage-files-datalake-cpp >=12.12.0,<12.12.1.0a0 + - bzip2 >=1.0.8,<2.0a0 + - gflags >=2.2.2,<2.3.0a0 + - glog >=0.7.1,<0.8.0a0 + - libabseil * cxx17* + - libabseil >=20240722.0,<20240723.0a0 + - libbrotlidec >=1.1.0,<1.2.0a0 + - libbrotlienc >=1.1.0,<1.2.0a0 + - libgcc >=13 + - libgoogle-cloud >=2.32.0,<2.33.0a0 + - libgoogle-cloud-storage >=2.32.0,<2.33.0a0 + - libre2-11 >=2024.7.2 + - libstdcxx >=13 + - libutf8proc >=2.9.0,<2.10.0a0 + - libzlib >=1.3.1,<2.0a0 + - lz4-c >=1.10.0,<1.11.0a0 + - orc >=2.0.3,<2.0.4.0a0 + - re2 + - snappy >=1.2.1,<1.3.0a0 + - zstd >=1.5.6,<1.6.0a0 + constrains: - parquet-cpp <0.0a0 - arrow-cpp <0.0a0 + - apache-arrow-proc =*=cpu license: Apache-2.0 license_family: APACHE purls: [] - size: 5253411 - timestamp: 1725214512114 -- kind: conda - name: libarrow - version: 17.0.0 - build: h8d2e343_13_cpu - build_number: 13 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libarrow-17.0.0-h8d2e343_13_cpu.conda - sha256: 91e639761f29ee1ca144e92110d47c8e68038f26201eef25585a48826e037fb2 - md5: dc379f362829d5df5ce6722565110029 - depends: - - __glibc >=2.17,<3.0.a0 - - aws-crt-cpp >=0.28.2,<0.28.3.0a0 - - aws-sdk-cpp >=1.11.379,<1.11.380.0a0 + size: 8786061 + timestamp: 1733810643966 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-17.0.0-hc6a7651_16_cpu.conda + build_number: 16 + sha256: 1facd5aa7140031be0f68733ab5e413ea1505da40548e27a173b2407046f36b5 + md5: 05fecc4ae5930dc548327980a4bc7a83 + depends: + - __osx >=11.0 + - aws-crt-cpp >=0.28.3,<0.28.4.0a0 + - aws-sdk-cpp >=1.11.407,<1.11.408.0a0 - azure-core-cpp >=1.13.0,<1.13.1.0a0 - azure-identity-cpp >=1.8.0,<1.8.1.0a0 - azure-storage-blobs-cpp >=12.12.0,<12.12.1.0a0 - azure-storage-files-datalake-cpp >=12.11.0,<12.11.1.0a0 - bzip2 >=1.0.8,<2.0a0 - - gflags >=2.2.2,<2.3.0a0 - glog >=0.7.1,<0.8.0a0 - libabseil * cxx17* - libabseil >=20240116.2,<20240117.0a0 - libbrotlidec >=1.1.0,<1.2.0a0 - libbrotlienc >=1.1.0,<1.2.0a0 - - libgcc >=13 - - libgoogle-cloud >=2.28.0,<2.29.0a0 - - libgoogle-cloud-storage >=2.28.0,<2.29.0a0 - - libre2-11 >=2023.9.1,<2024.0a0 - - libstdcxx >=13 + - libcxx >=17 + - libgoogle-cloud >=2.29.0,<2.30.0a0 + - libgoogle-cloud-storage >=2.29.0,<2.30.0a0 + - libre2-11 >=2023.9.1 - libutf8proc >=2.8.0,<3.0a0 - libzlib >=1.3.1,<2.0a0 - lz4-c >=1.9.3,<1.10.0a0 @@ -7693,163 +7483,245 @@ packages: - re2 - snappy >=1.2.1,<1.3.0a0 - zstd >=1.5.6,<1.6.0a0 + - libutf8proc <2.9 constrains: + - apache-arrow-proc =*=cpu - arrow-cpp <0.0a0 - parquet-cpp <0.0a0 + license: Apache-2.0 + license_family: APACHE + purls: [] + size: 5318871 + timestamp: 1726669928492 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-18.1.0-h4a2f8bd_6_cpu.conda + build_number: 6 + sha256: 9ed3ea1bc15005c0df187268ef91407afaa908cf82f36f5acbbf50ac24d7f806 + md5: 835cdd84195b84dc34d128bd5d3580b9 + depends: + - __osx >=11.0 + - aws-crt-cpp >=0.29.7,<0.29.8.0a0 + - aws-sdk-cpp >=1.11.458,<1.11.459.0a0 + - azure-core-cpp >=1.14.0,<1.14.1.0a0 + - azure-identity-cpp >=1.10.0,<1.10.1.0a0 + - azure-storage-blobs-cpp >=12.13.0,<12.13.1.0a0 + - azure-storage-files-datalake-cpp >=12.12.0,<12.12.1.0a0 + - bzip2 >=1.0.8,<2.0a0 + - glog >=0.7.1,<0.8.0a0 + - libabseil * cxx17* + - libabseil >=20240722.0,<20240723.0a0 + - libbrotlidec >=1.1.0,<1.2.0a0 + - libbrotlienc >=1.1.0,<1.2.0a0 + - libcxx >=18 + - libgoogle-cloud >=2.32.0,<2.33.0a0 + - libgoogle-cloud-storage >=2.32.0,<2.33.0a0 + - libre2-11 >=2024.7.2 + - libutf8proc >=2.9.0,<2.10.0a0 + - libzlib >=1.3.1,<2.0a0 + - lz4-c >=1.10.0,<1.11.0a0 + - orc >=2.0.3,<2.0.4.0a0 + - re2 + - snappy >=1.2.1,<1.3.0a0 + - zstd >=1.5.6,<1.6.0a0 + constrains: - apache-arrow-proc =*=cpu + - arrow-cpp <0.0a0 + - parquet-cpp <0.0a0 + license: Apache-2.0 + license_family: APACHE + purls: [] + size: 5494797 + timestamp: 1733808145854 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-acero-17.0.0-h5888daf_16_cpu.conda + build_number: 16 + sha256: 0ff4c712c7c61e60708c6ef4f8158200059e0f63c25d0a54c8e4cca7bd153d86 + md5: 18f796aae018a26a20ac51d19de69115 + depends: + - __glibc >=2.17,<3.0.a0 + - libarrow 17.0.0 had3b6fe_16_cpu + - libgcc >=13 + - libstdcxx >=13 license: Apache-2.0 license_family: APACHE purls: [] - size: 8512685 - timestamp: 1725214716301 -- kind: conda - name: libarrow-acero - version: 17.0.0 - build: h5888daf_13_cpu - build_number: 13 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libarrow-acero-17.0.0-h5888daf_13_cpu.conda - sha256: cda9e38ad7af7ba72416031b089de5048f8526ae586149ff9f6506366689d699 - md5: b654d072b8d5da807495e49b28a0b884 + size: 608267 + timestamp: 1726669999941 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-acero-18.1.0-hcb10f89_6_cpu.conda + build_number: 6 + sha256: a32fa1d71415afc02b5cf3cd4c0a6ec0af9e749308829cc65ff79689222ce479 + md5: 143f9288b64759a6427563f058c62f2b depends: - __glibc >=2.17,<3.0.a0 - - libarrow 17.0.0 h8d2e343_13_cpu + - libarrow 18.1.0 h44a453e_6_cpu - libgcc >=13 - libstdcxx >=13 license: Apache-2.0 license_family: APACHE purls: [] - size: 609649 - timestamp: 1725214754397 -- kind: conda - name: libarrow-acero - version: 17.0.0 - build: hf9b8971_13_cpu - build_number: 13 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-acero-17.0.0-hf9b8971_13_cpu.conda - sha256: ea958d1947670dc913f1a0ee631c70d8ac8d6db5f08039002b233bf896815cb2 - md5: 5d52b70e8174f52934d646bbaf0a928b + size: 611745 + timestamp: 1733810698469 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-acero-17.0.0-hf9b8971_16_cpu.conda + build_number: 16 + sha256: c9ff43babc0acbd864584ed1720cf063715589e31e9e2024b90d2094d4f20d38 + md5: 319bd2a8c30dffa54d6ad69847f16de1 depends: - __osx >=11.0 - - libarrow 17.0.0 h20538ec_13_cpu + - libarrow 17.0.0 hc6a7651_16_cpu - libcxx >=17 license: Apache-2.0 license_family: APACHE purls: [] - size: 477391 - timestamp: 1725214612356 -- kind: conda - name: libarrow-dataset - version: 17.0.0 - build: h5888daf_13_cpu - build_number: 13 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libarrow-dataset-17.0.0-h5888daf_13_cpu.conda - sha256: b3fac9bc9a399670d6993738d018324d6e1b0a85755b484204405bb72efabc4e - md5: cd2c36e8865b158b82f61c6aac28b7e1 - depends: - - __glibc >=2.17,<3.0.a0 - - libarrow 17.0.0 h8d2e343_13_cpu - - libarrow-acero 17.0.0 h5888daf_13_cpu + size: 483187 + timestamp: 1726670022814 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-acero-18.1.0-hf07054f_6_cpu.conda + build_number: 6 + sha256: e1cae46409927470439ef9ae93ed09b3493d0579501ca9ebfa79ded212ee98d8 + md5: 97fc01254714e1572624baefdd7cc898 + depends: + - __osx >=11.0 + - libarrow 18.1.0 h4a2f8bd_6_cpu + - libcxx >=18 + license: Apache-2.0 + license_family: APACHE + purls: [] + size: 483713 + timestamp: 1733808246880 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-dataset-17.0.0-h5888daf_16_cpu.conda + build_number: 16 + sha256: e500e0154cf3ebb41bed3bdf41bd0ff5e0a6b7527a46ba755c05e59c8036e442 + md5: 5400efd6bf101674e0ce170906a0f7cb + depends: + - __glibc >=2.17,<3.0.a0 + - libarrow 17.0.0 had3b6fe_16_cpu + - libarrow-acero 17.0.0 h5888daf_16_cpu + - libgcc >=13 + - libparquet 17.0.0 h39682fd_16_cpu + - libstdcxx >=13 + license: Apache-2.0 + license_family: APACHE + purls: [] + size: 585061 + timestamp: 1726670063965 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-dataset-18.1.0-hcb10f89_6_cpu.conda + build_number: 6 + sha256: 74eeb178070002842d3ed721769399320e3a68a0843319eaf899a092a31def26 + md5: 20ca46a6bc714a6ab189d5b3f46e66d8 + depends: + - __glibc >=2.17,<3.0.a0 + - libarrow 18.1.0 h44a453e_6_cpu + - libarrow-acero 18.1.0 hcb10f89_6_cpu - libgcc >=13 - - libparquet 17.0.0 h39682fd_13_cpu + - libparquet 18.1.0 h081d1f1_6_cpu - libstdcxx >=13 license: Apache-2.0 license_family: APACHE purls: [] - size: 582848 - timestamp: 1725214820464 -- kind: conda - name: libarrow-dataset - version: 17.0.0 - build: hf9b8971_13_cpu - build_number: 13 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-dataset-17.0.0-hf9b8971_13_cpu.conda - sha256: 3dac99549e4f9307bb4d35e94003f6e7c9052a957de122ec78c5d9750fd46096 - md5: 35df832aa0371c7bbe9fec5ea1c3139c + size: 586627 + timestamp: 1733810842604 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-dataset-17.0.0-hf9b8971_16_cpu.conda + build_number: 16 + sha256: e77d3c6825384c232f61fd3602a32507b66410dbe8879cd69a89b0fc49489533 + md5: 67ea0ef775de4c394c3c7db991297ffa depends: - __osx >=11.0 - - libarrow 17.0.0 h20538ec_13_cpu - - libarrow-acero 17.0.0 hf9b8971_13_cpu + - libarrow 17.0.0 hc6a7651_16_cpu + - libarrow-acero 17.0.0 hf9b8971_16_cpu - libcxx >=17 - - libparquet 17.0.0 hf0ba9ef_13_cpu + - libparquet 17.0.0 hf0ba9ef_16_cpu license: Apache-2.0 license_family: APACHE purls: [] - size: 482335 - timestamp: 1725215502662 -- kind: conda - name: libarrow-substrait - version: 17.0.0 - build: hbf8b706_13_cpu - build_number: 13 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-substrait-17.0.0-hbf8b706_13_cpu.conda - sha256: 5fd22a610e14669f0f392aaf7b61511d9a7a5f99a23a3ce4bdf5b2880ddbd244 - md5: e079f9b14e75bb3f571b1345ce8dad78 + size: 491606 + timestamp: 1726671006156 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-dataset-18.1.0-hf07054f_6_cpu.conda + build_number: 6 + sha256: 6eba942ce926419f74e6e0a7c3994a7d78ab6be47115e6bb70e02136554736be + md5: 0774276be6659aaa0007f1b0f6ee19b0 depends: - __osx >=11.0 + - libarrow 18.1.0 h4a2f8bd_6_cpu + - libarrow-acero 18.1.0 hf07054f_6_cpu + - libcxx >=18 + - libparquet 18.1.0 h636d7b7_6_cpu + license: Apache-2.0 + license_family: APACHE + purls: [] + size: 489948 + timestamp: 1733809328231 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-substrait-17.0.0-hf54134d_16_cpu.conda + build_number: 16 + sha256: 53f3d5f12c9ea557f33a4e1cf9067ce2dbb4211eff0a095574eeb7f0528bc044 + md5: 1cbc3fb1ee28c99e5f8c52920a7717a3 + depends: + - __glibc >=2.17,<3.0.a0 - libabseil * cxx17* - libabseil >=20240116.2,<20240117.0a0 - - libarrow 17.0.0 h20538ec_13_cpu - - libarrow-acero 17.0.0 hf9b8971_13_cpu - - libarrow-dataset 17.0.0 hf9b8971_13_cpu - - libcxx >=17 + - libarrow 17.0.0 had3b6fe_16_cpu + - libarrow-acero 17.0.0 h5888daf_16_cpu + - libarrow-dataset 17.0.0 h5888daf_16_cpu + - libgcc >=13 - libprotobuf >=4.25.3,<4.25.4.0a0 + - libstdcxx >=13 license: Apache-2.0 license_family: APACHE purls: [] - size: 466501 - timestamp: 1725215667169 -- kind: conda - name: libarrow-substrait - version: 17.0.0 - build: hf54134d_13_cpu - build_number: 13 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libarrow-substrait-17.0.0-hf54134d_13_cpu.conda - sha256: 01ff52d5b866f3174018c81dee808fbef1101f2cff05cc5f29c80ff68cc8796c - md5: 46f41533959eee8826c09e55976b8c06 + size: 550960 + timestamp: 1726670093831 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-substrait-18.1.0-h3ee7192_6_cpu.conda + build_number: 6 + sha256: bda6728db019dd0c409b1996ad9ef6ab0bcee3a94dc66a8045e8c1049c566055 + md5: aa313b3168caf98d00b3753f5ba27650 depends: - __glibc >=2.17,<3.0.a0 - libabseil * cxx17* - - libabseil >=20240116.2,<20240117.0a0 - - libarrow 17.0.0 h8d2e343_13_cpu - - libarrow-acero 17.0.0 h5888daf_13_cpu - - libarrow-dataset 17.0.0 h5888daf_13_cpu + - libabseil >=20240722.0,<20240723.0a0 + - libarrow 18.1.0 h44a453e_6_cpu + - libarrow-acero 18.1.0 hcb10f89_6_cpu + - libarrow-dataset 18.1.0 hcb10f89_6_cpu - libgcc >=13 - - libprotobuf >=4.25.3,<4.25.4.0a0 + - libprotobuf >=5.28.2,<5.28.3.0a0 - libstdcxx >=13 license: Apache-2.0 license_family: APACHE purls: [] - size: 550883 - timestamp: 1725214851656 -- kind: conda - name: libasprintf - version: 0.22.5 - build: h8414b35_3 - build_number: 3 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libasprintf-0.22.5-h8414b35_3.conda - sha256: 819bf95543470658f48db53a267a3fabe1616797c4031cf88e63f451c5029e6f - md5: 472b673c083175195965a48f2f4808f8 + size: 519989 + timestamp: 1733810903274 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-substrait-17.0.0-hbf8b706_16_cpu.conda + build_number: 16 + sha256: 6880b3c8fb88ee6c0bbae34b0efea86567ccec1b8cd8a3662b8b8c6dfeb5e87a + md5: b739c909163c38f85f40f5650ab2aeb2 depends: - __osx >=11.0 - - libcxx >=16 - license: LGPL-2.1-or-later + - libabseil * cxx17* + - libabseil >=20240116.2,<20240117.0a0 + - libarrow 17.0.0 hc6a7651_16_cpu + - libarrow-acero 17.0.0 hf9b8971_16_cpu + - libarrow-dataset 17.0.0 hf9b8971_16_cpu + - libcxx >=17 + - libprotobuf >=4.25.3,<4.25.4.0a0 + license: Apache-2.0 + license_family: APACHE purls: [] - size: 40657 - timestamp: 1723626937704 -- kind: conda - name: libasprintf - version: 0.22.5 - build: he8f35ee_3 - build_number: 3 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libasprintf-0.22.5-he8f35ee_3.conda + size: 472812 + timestamp: 1726671149860 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libarrow-substrait-18.1.0-h86344ea_6_cpu.conda + build_number: 6 + sha256: bafd9ca59ebb5ad34b77aff316ef7b59c5fb1eb8a7b6a15de8dcbdf3ce37556d + md5: c1c162f5bf569cff8bed6def705a899f + depends: + - __osx >=11.0 + - libabseil * cxx17* + - libabseil >=20240722.0,<20240723.0a0 + - libarrow 18.1.0 h4a2f8bd_6_cpu + - libarrow-acero 18.1.0 hf07054f_6_cpu + - libarrow-dataset 18.1.0 hf07054f_6_cpu + - libcxx >=18 + - libprotobuf >=5.28.2,<5.28.3.0a0 + license: Apache-2.0 + license_family: APACHE + purls: [] + size: 451623 + timestamp: 1733809487176 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libasprintf-0.22.5-he8f35ee_3.conda sha256: 2da5c735811cbf38c7f7844ab457ff8b25046bbf5fe5ebd5dc1c2fafdf4fbe1c md5: 4fab9799da9571266d05ca5503330655 depends: @@ -7860,45 +7732,45 @@ packages: purls: [] size: 42817 timestamp: 1723626012203 -- kind: conda - name: libasprintf-devel - version: 0.22.5 - build: h8414b35_3 - build_number: 3 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libasprintf-devel-0.22.5-h8414b35_3.conda - sha256: ca7322f7c3f1a68cb36630eaa88a44c774261150d42d70a4be3d77bc9ed28d5d - md5: a03ca97f9fabf5626660697c2e0b8850 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libasprintf-0.22.5-h8414b35_3.conda + sha256: 819bf95543470658f48db53a267a3fabe1616797c4031cf88e63f451c5029e6f + md5: 472b673c083175195965a48f2f4808f8 depends: - __osx >=11.0 - - libasprintf 0.22.5 h8414b35_3 + - libcxx >=16 license: LGPL-2.1-or-later purls: [] - size: 34648 - timestamp: 1723626983419 -- kind: conda - name: libasprintf-devel - version: 0.22.5 - build: he8f35ee_3 - build_number: 3 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libasprintf-devel-0.22.5-he8f35ee_3.conda + size: 40657 + timestamp: 1723626937704 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libasprintf-devel-0.22.5-he8f35ee_3.conda sha256: ccc7967e298ddf3124c8ad9741c7180dc6f778ae4135ec87978214f7b3c64dc2 md5: 1091193789bb830127ed067a9e01ac57 depends: - __glibc >=2.17,<3.0.a0 - libasprintf 0.22.5 he8f35ee_3 - libgcc-ng >=12 - license: LGPL-2.1-or-later + license: LGPL-2.1-or-later + purls: [] + size: 34172 + timestamp: 1723626026096 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libass-0.17.1-h8fe9dca_1.conda + sha256: 1bc3e44239a11613627488b7a9b6c021ec6b52c5925abd666832db0cb2a59f05 + md5: c306fd9cc90c0585171167d09135a827 + depends: + - fontconfig >=2.14.2,<3.0a0 + - fonts-conda-ecosystem + - freetype >=2.12.1,<3.0a0 + - fribidi >=1.0.10,<2.0a0 + - harfbuzz >=8.1.1,<9.0a0 + - libexpat >=2.5.0,<3.0a0 + - libgcc-ng >=12 + - libzlib >=1.2.13,<2.0.0a0 + license: ISC + license_family: OTHER purls: [] - size: 34172 - timestamp: 1723626026096 -- kind: conda - name: libass - version: 0.17.3 - build: h1dc1e6a_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libass-0.17.3-h1dc1e6a_0.conda + size: 126896 + timestamp: 1693027051367 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libass-0.17.3-h1dc1e6a_0.conda sha256: 52afd5e79681185ea33da0e7548aa3721be7e9a153a90f004c5adc33d61f7a14 md5: 2a66267ba586dadd110cc991063cfff7 depends: @@ -7916,12 +7788,7 @@ packages: purls: [] size: 133110 timestamp: 1719985879751 -- kind: conda - name: libass - version: 0.17.3 - build: hf20b609_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libass-0.17.3-hf20b609_0.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libass-0.17.3-hf20b609_0.conda sha256: 2c03d080b48e65e4c488b4824b817fbdce5b79e18f49fc4e823819268b74bb7d md5: 50f6b3ead2c75c7c4009a8ed477d8142 depends: @@ -7938,57 +7805,59 @@ packages: purls: [] size: 116755 timestamp: 1719986027249 -- kind: conda - name: libblas - version: 3.9.0 - build: 23_linux64_openblas - build_number: 23 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-23_linux64_openblas.conda - sha256: edb1cee5da3ac4936940052dcab6969673ba3874564f90f5110f8c11eed789c2 - md5: 96c8450a40aa2b9733073a9460de972c - depends: - - libopenblas >=0.3.27,<0.3.28.0a0 - - libopenblas >=0.3.27,<1.0a0 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-26_linux64_openblas.conda + build_number: 26 + sha256: 30bd658682b124243f8e52d8edf8a19e7be1bc31e4fe4baec30a64002dc8cd0c + md5: ac52800af2e0c0e7dac770b435ce768a + depends: + - libopenblas >=0.3.28,<0.3.29.0a0 + - libopenblas >=0.3.28,<1.0a0 constrains: - - liblapacke 3.9.0 23_linux64_openblas - - libcblas 3.9.0 23_linux64_openblas - - liblapack 3.9.0 23_linux64_openblas + - libcblas 3.9.0 26_linux64_openblas + - liblapack 3.9.0 26_linux64_openblas + - liblapacke 3.9.0 26_linux64_openblas - blas * openblas license: BSD-3-Clause license_family: BSD purls: [] - size: 14880 - timestamp: 1721688759937 -- kind: conda - name: libblas - version: 3.9.0 - build: 23_osxarm64_openblas - build_number: 23 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-23_osxarm64_openblas.conda - sha256: 1c30da861e306a25fac8cd30ce0c1b31c9238d04e7768c381cf4d431b4361e6c - md5: acae9191e8772f5aff48ab5232d4d2a3 - depends: - - libopenblas >=0.3.27,<0.3.28.0a0 - - libopenblas >=0.3.27,<1.0a0 + size: 16393 + timestamp: 1734432564346 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-26_osxarm64_openblas.conda + build_number: 26 + sha256: 597f9c3779caa979c8c6abbb3ba8c7191b84e1a910d6b0d10e5faf35284c450c + md5: 21be102c9ae80a67ba7de23b129aa7f6 + depends: + - libopenblas >=0.3.28,<0.3.29.0a0 + - libopenblas >=0.3.28,<1.0a0 constrains: - - liblapack 3.9.0 23_osxarm64_openblas + - liblapack 3.9.0 26_osxarm64_openblas + - liblapacke 3.9.0 26_osxarm64_openblas + - libcblas 3.9.0 26_osxarm64_openblas - blas * openblas - - liblapacke 3.9.0 23_osxarm64_openblas - - libcblas 3.9.0 23_osxarm64_openblas license: BSD-3-Clause license_family: BSD purls: [] - size: 15103 - timestamp: 1721688997980 -- kind: conda - name: libbrotlicommon - version: 1.1.0 - build: hb9d3cd8_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libbrotlicommon-1.1.0-hb9d3cd8_2.conda + size: 16714 + timestamp: 1734433054681 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.86.0-hf299e74_1.conda + sha256: 51fef57eba500f0c2a762d29479fd9511b5ecc26a44e4bfbf6d0e86038fd538e + md5: d618391221a0ad71981308c955344370 + depends: + - __glibc >=2.17,<3.0.a0 + - bzip2 >=1.0.8,<2.0a0 + - icu >=73.2,<74.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - libzlib >=1.3.1,<2.0a0 + - xz >=5.2.6,<6.0a0 + - zstd >=1.5.6,<1.6.0a0 + constrains: + - boost-cpp <0.0a0 + license: BSL-1.0 + purls: [] + size: 2949687 + timestamp: 1723927834883 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlicommon-1.1.0-hb9d3cd8_2.conda sha256: d9db2de60ea917298e658143354a530e9ca5f9c63471c65cf47ab39fd2f429e3 md5: 41b599ed2b02abcfdd84302bff174b23 depends: @@ -7999,13 +7868,7 @@ packages: purls: [] size: 68851 timestamp: 1725267660471 -- kind: conda - name: libbrotlicommon - version: 1.1.0 - build: hd74edd7_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlicommon-1.1.0-hd74edd7_2.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlicommon-1.1.0-hd74edd7_2.conda sha256: 839dacb741bdbb25e58f42088a2001b649f4f12195aeb700b5ddfca3267749e5 md5: d0bf1dff146b799b319ea0434b93f779 depends: @@ -8015,13 +7878,7 @@ packages: purls: [] size: 68426 timestamp: 1725267943211 -- kind: conda - name: libbrotlidec - version: 1.1.0 - build: hb9d3cd8_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libbrotlidec-1.1.0-hb9d3cd8_2.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlidec-1.1.0-hb9d3cd8_2.conda sha256: 2892d512cad096cb03f1b66361deeab58b64e15ba525d6592bb6d609e7045edf md5: 9566f0bd264fbd463002e759b8a82401 depends: @@ -8033,13 +7890,7 @@ packages: purls: [] size: 32696 timestamp: 1725267669305 -- kind: conda - name: libbrotlidec - version: 1.1.0 - build: hd74edd7_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlidec-1.1.0-hd74edd7_2.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlidec-1.1.0-hd74edd7_2.conda sha256: 6c6862eb274f21a7c0b60e5345467a12e6dda8b9af4438c66d496a2c1a538264 md5: 55e66e68ce55523a6811633dd1ac74e2 depends: @@ -8050,13 +7901,7 @@ packages: purls: [] size: 28378 timestamp: 1725267980316 -- kind: conda - name: libbrotlienc - version: 1.1.0 - build: hb9d3cd8_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libbrotlienc-1.1.0-hb9d3cd8_2.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlienc-1.1.0-hb9d3cd8_2.conda sha256: 779f58174e99de3600e939fa46eddb453ec5d3c60bb46cdaa8b4c127224dbf29 md5: 06f70867945ea6a84d35836af780f1de depends: @@ -8068,13 +7913,7 @@ packages: purls: [] size: 281750 timestamp: 1725267679782 -- kind: conda - name: libbrotlienc - version: 1.1.0 - build: hd74edd7_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlienc-1.1.0-hd74edd7_2.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlienc-1.1.0-hd74edd7_2.conda sha256: eeb1eb0d58b9d02bc1b98dc0a058f104ab168eb2f7d1c7bfa0570a12cfcdb7b7 md5: 4f3a434504c67b2c42565c0b85c1885c depends: @@ -8085,55 +7924,64 @@ packages: purls: [] size: 279644 timestamp: 1725268003553 -- kind: conda - name: libcblas - version: 3.9.0 - build: 23_linux64_openblas - build_number: 23 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-23_linux64_openblas.conda - sha256: 3e7a3236e7e03e308e1667d91d0aa70edd0cba96b4b5563ef4adde088e0881a5 - md5: eede29b40efa878cbe5bdcb767e97310 - depends: - - libblas 3.9.0 23_linux64_openblas +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-26_linux64_openblas.conda + build_number: 26 + sha256: 9c74e536c9bc868e356ffd43f81c2cb398aec84b40fcadc312315b164a5500ee + md5: ebcc5f37a435aa3c19640533c82f8d76 + depends: + - libblas 3.9.0 26_linux64_openblas constrains: - - liblapacke 3.9.0 23_linux64_openblas - - liblapack 3.9.0 23_linux64_openblas + - liblapack 3.9.0 26_linux64_openblas + - liblapacke 3.9.0 26_linux64_openblas - blas * openblas license: BSD-3-Clause license_family: BSD purls: [] - size: 14798 - timestamp: 1721688767584 -- kind: conda - name: libcblas - version: 3.9.0 - build: 23_osxarm64_openblas - build_number: 23 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-23_osxarm64_openblas.conda - sha256: c39d944909d0608bd0333398be5e0051045c9451bfd6cc6320732d33375569c8 - md5: bad6ee9b7d5584efc2bc5266137b5f0d - depends: - - libblas 3.9.0 23_osxarm64_openblas + size: 16336 + timestamp: 1734432570482 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-26_osxarm64_openblas.conda + build_number: 26 + sha256: 27a29ef6b2fd2179bc3a0bb9db351f078ba140ca10485dca147c399639f84c93 + md5: a0e9980fe12d42f6d0c0ec009f67e948 + depends: + - libblas 3.9.0 26_osxarm64_openblas constrains: - - liblapack 3.9.0 23_osxarm64_openblas - - liblapacke 3.9.0 23_osxarm64_openblas + - liblapack 3.9.0 26_osxarm64_openblas + - liblapacke 3.9.0 26_osxarm64_openblas - blas * openblas license: BSD-3-Clause license_family: BSD purls: [] - size: 14991 - timestamp: 1721689017803 -- kind: conda - name: libclang-cpp18.1 - version: 18.1.8 - build: default_hf981a13_4 - build_number: 4 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp18.1-18.1.8-default_hf981a13_4.conda - sha256: ec7ed3003f4b1507043f7a4ad85339c7a20898ff213e8f77f51f69c30d76780a - md5: 7b72d74b57e681251536094b96ba9c46 + size: 16628 + timestamp: 1734433061517 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libccd-double-2.1-h59595ed_3.conda + sha256: 4695ce68eda595b4f53146bea1096a9f2e0d33290618ba83a246b5ed8871ebc9 + md5: 6a3d962d34385e0a511b859d679f6ea2 + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + constrains: + - libccd <1 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 36171 + timestamp: 1687341825064 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libccd-double-2.1-h9a09cb3_2.tar.bz2 + sha256: eaba0b8153f4346229a0c52916a13fbedd689a3d3b31f4196bac65ece9050b8e + md5: 4d27a7d50c8d4bcafe33c9215e66251c + depends: + - libcxx >=13.0.1 + constrains: + - libccd <1 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 29852 + timestamp: 1654586481871 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp18.1-18.1.8-default_hf981a13_5.conda + sha256: ffcd09fe3e346fe33abaeb02fd07679310ffab7d35c837ef7c553431f3cdb94b + md5: f9b854fee7cc67a4cd27a930926344f1 depends: - __glibc >=2.17,<3.0.a0 - libgcc >=12 @@ -8142,33 +7990,49 @@ packages: license: Apache-2.0 WITH LLVM-exception license_family: Apache purls: [] - size: 19176386 - timestamp: 1725430019231 -- kind: conda - name: libclang13 - version: 18.1.8 - build: default_h9def88c_4 - build_number: 4 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libclang13-18.1.8-default_h9def88c_4.conda - sha256: 606c82d902a6d343b1b21967d30d73f6d54b8340fe180f2b0641fb775fba91e9 - md5: 7e3f831d4ae9820999418821be65ff67 + size: 19176405 + timestamp: 1726866675823 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp19.1-19.1.6-default_hb5137d0_0.conda + sha256: 978320cb6107b9bc11d127783918500a330646ed825dc6c9da897941989d7d09 + md5: 9caebd39281536bf6bcb32f665dd4fbf depends: - __glibc >=2.17,<3.0.a0 - - libgcc >=12 - - libllvm18 >=18.1.8,<18.2.0a0 - - libstdcxx >=12 + - libgcc >=13 + - libllvm19 >=19.1.6,<19.2.0a0 + - libstdcxx >=13 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + purls: + - pkg:pypi/libclang-cpp19-1 + size: 20531147 + timestamp: 1734506894098 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libclang13-19.1.2-default_h9c6a7e4_1.conda + sha256: 8a38fb764bf65cc18f03006db6aeb345d390102182db2e46fd3f452a1b2dcfcc + md5: cb5c5ff12b37aded00d9aaa7b9a86a78 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libllvm19 >=19.1.2,<19.2.0a0 + - libstdcxx >=13 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + purls: [] + size: 11819644 + timestamp: 1729290739883 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libclang13-19.1.6-default_h9c6a7e4_0.conda + sha256: 54a7fabfba7dee2caebe5e6a7538e3aba0a8f4c11e7366f65592aee4fdaa7519 + md5: e1d2936c320083f1c520c3a17372521c + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libllvm19 >=19.1.6,<19.2.0a0 + - libstdcxx >=13 license: Apache-2.0 WITH LLVM-exception license_family: Apache purls: [] - size: 11017079 - timestamp: 1725430212320 -- kind: conda - name: libcrc32c - version: 1.1.2 - build: h9c3ff4c_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libcrc32c-1.1.2-h9c3ff4c_0.tar.bz2 + size: 11819857 + timestamp: 1734507076759 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcrc32c-1.1.2-h9c3ff4c_0.tar.bz2 sha256: fd1d153962764433fe6233f34a72cdeed5dcf8a883a85769e8295ce940b5b0c5 md5: c965a5aa0d5c1c37ffc62dff36e28400 depends: @@ -8179,12 +8043,7 @@ packages: purls: [] size: 20440 timestamp: 1633683576494 -- kind: conda - name: libcrc32c - version: 1.1.2 - build: hbdafb3b_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libcrc32c-1.1.2-hbdafb3b_0.tar.bz2 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcrc32c-1.1.2-hbdafb3b_0.tar.bz2 sha256: 58477b67cc719060b5b069ba57161e20ba69b8695d154a719cb4b60caf577929 md5: 32bd82a6a625ea6ce090a81c3d34edeb depends: @@ -8194,125 +8053,89 @@ packages: purls: [] size: 18765 timestamp: 1633683992603 -- kind: conda - name: libcublas - version: 12.6.1.4 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libcublas-12.6.1.4-h5888daf_0.conda - sha256: e8349a5c72abf5ae3332dbbab87c4fb4ef08b0bd40c632cdca7eb6bad67af5ff - md5: 29f88556b831cd494657a306c9172fcb +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcublas-12.5.2.13-he02047a_0.conda + sha256: 0c78188a83f749e4ee0cc88a8b9cf61f9672d06e67010fb70277e47381462558 + md5: 47c59ede9bb1cf846e3b30e3b04bcabb depends: - __glibc >=2.17,<3.0.a0 - cuda-nvrtc - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 260716679 - timestamp: 1724961405395 -- kind: conda - name: libcublas-dev - version: 12.6.1.4 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libcublas-dev-12.6.1.4-h5888daf_0.conda - sha256: ed70890de0f9ba3d8ba05d30fb7df8756d9e018d40bf141d3e652b234608e641 - md5: fd0897e461e4af84626ade68ea968ae0 + size: 251929375 + timestamp: 1716326870507 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcublas-dev-12.5.2.13-he02047a_0.conda + sha256: 3b901550564737a70c96076b6a6958fe0bbf675d6dbe382bb1b902f1b07e4971 + md5: d08b1ac50aadaf8118d2e2b3d63241e8 depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libcublas 12.6.1.4 h5888daf_0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libcublas 12.5.2.13 he02047a_0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 constrains: - - libcublas-static >=12.6.1.4 + - libcublas-static >=12.5.2.13 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 87655 - timestamp: 1724962106918 -- kind: conda - name: libcufft - version: 11.2.6.59 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libcufft-11.2.6.59-h5888daf_0.conda - sha256: b5d2357eb9cfe67fb6bfaa2b63f5bd18cc323fe621f1f34afcdd1e2204423b0e - md5: f69dfc1e96ce1cb20324a59dabe8d0b6 + size: 89157 + timestamp: 1716327546285 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcufft-11.2.3.18-he02047a_0.conda + sha256: 27dfd69356da46db389e69890fdb84a4d6f983483126a7fde6375e62ee3e25e8 + md5: d7a177f866e0cefcd7156cef5b679f8e depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 155839617 - timestamp: 1724958128278 -- kind: conda - name: libcufft-dev - version: 11.2.6.59 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libcufft-dev-11.2.6.59-h5888daf_0.conda - sha256: 71788b9b665c96930fb84cb0552b542ac2996d6f2f769b6b7e64ae8b35f992a3 - md5: 56809429ded16749040ae9cb0b2d53c4 + size: 155965051 + timestamp: 1716319852201 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcufft-dev-11.2.3.18-he02047a_0.conda + sha256: 9909928743321f1661eadea311d4d964dce8d085e840fd97d7ecdadb8e848afe + md5: 021046fda7438fdfb452c8ccefd9d2f9 depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libcufft 11.2.6.59 h5888daf_0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libcufft 11.2.3.18 he02047a_0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 constrains: - - libcufft-static >=11.2.6.59 + - libcufft-static >=11.2.3.18 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 33310 - timestamp: 1724958464124 -- kind: conda - name: libcufile - version: 1.11.1.6 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libcufile-1.11.1.6-h5888daf_0.conda - sha256: 8f1f22d1b831e57b0876fecbf88c3eaf62cea8b444b3c13d0c849527745543da - md5: a1c8641cf845b8ca368c894859d712bd + size: 33455 + timestamp: 1716320323771 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-1.10.0.4-he02047a_0.conda + sha256: bdf50ec61ebe1bba20c73306ac5d31dc0052db42b74607ad45c527d6917a34e5 + md5: 58c318f349a5a3c5fe2e1e48bdd037f4 depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 917141 - timestamp: 1724957756211 -- kind: conda - name: libcufile-dev - version: 1.11.1.6 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libcufile-dev-1.11.1.6-h5888daf_0.conda - sha256: 27672daccd3e1e9233433dea951cee86eca29752ba4c529a66b5662ea9205c40 - md5: 38304ce73245d4684149ef485cfc6f5b + size: 924109 + timestamp: 1716319278480 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-dev-1.10.0.4-he02047a_0.conda + sha256: ab2faa9a5ed0fe00f0cd6a84f247ff59dab5f7c43a597936dd4d3ba7aed9bd3e + md5: 2367a0501690b6aa0192b59750fb4bd2 depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libcufile 1.11.1.6 h5888daf_0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libcufile 1.10.0.4 he02047a_0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 constrains: - - libcufile-static >=1.11.1.6 + - libcufile-static >=1.10.0.4 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 34107 - timestamp: 1724957778128 -- kind: conda - name: libcups - version: 2.3.3 - build: h4637d8d_4 - build_number: 4 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libcups-2.3.3-h4637d8d_4.conda + size: 34272 + timestamp: 1716319316606 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcups-2.3.3-h4637d8d_4.conda sha256: bc67b9b21078c99c6bd8595fe7e1ed6da1f721007726e717f0449de7032798c4 md5: d4529f4dff3057982a7617c7ac58fde3 depends: @@ -8325,267 +8148,179 @@ packages: purls: [] size: 4519402 timestamp: 1689195353551 -- kind: conda - name: libcurand - version: 10.3.7.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libcurand-10.3.7.68-h5888daf_0.conda - sha256: c45e163631068a1f6496678e3052724ccad299833c733b9ebdd8dfee0994de3f - md5: b4bc47b6b9b3526e88195f8c916de22e +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcurand-10.3.6.39-he02047a_0.conda + sha256: e2f4fb2ce71686f801b9e9577639427160b2d4b023d561a6f82da1a6cbc24021 + md5: 8705dc9824147e22b424ec2e7d3e0ba6 depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 41748894 - timestamp: 1724958008453 -- kind: conda - name: libcurand-dev - version: 10.3.7.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libcurand-dev-10.3.7.68-h5888daf_0.conda - sha256: fd190ee38bdb8a5723d13fa23ab69c1435f99b692272b99a5fcdd241e8213395 - md5: 7091a84f75e44c2c21e66da1886e0785 + size: 41586702 + timestamp: 1716319576494 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcurand-dev-10.3.6.39-he02047a_0.conda + sha256: 5d1b13419c031cc590b698509e4806f5fd4e1cee16405f2e4e3ea1d032678c41 + md5: 4241738fda6b54c3dfacd7b707ac8d09 depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libcurand 10.3.7.68 h5888daf_0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libcurand 10.3.6.39 he02047a_0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 constrains: - - libcurand-static >=10.3.7.68 + - libcurand-static >=10.3.6.39 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 263510 - timestamp: 1724958105442 -- kind: conda - name: libcurl - version: 8.9.1 - build: hdb1bdb2_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.9.1-hdb1bdb2_0.conda - sha256: 0ba60f83709068e9ec1ab543af998cb5a201c8379c871205447684a34b5abfd8 - md5: 7da1d242ca3591e174a3c7d82230d3c0 + size: 250040 + timestamp: 1716319661315 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.11.1-h332b0f4_0.conda + sha256: 3cd4075b2a7b5562e46c8ec626f6f9ca57aeecaa94ff7df57eca26daa94c9906 + md5: 2b3e0081006dc21e8bf53a91c83a055c depends: + - __glibc >=2.17,<3.0.a0 - krb5 >=1.21.3,<1.22.0a0 - - libgcc-ng >=12 - - libnghttp2 >=1.58.0,<2.0a0 - - libssh2 >=1.11.0,<2.0a0 + - libgcc >=13 + - libnghttp2 >=1.64.0,<2.0a0 + - libssh2 >=1.11.1,<2.0a0 - libzlib >=1.3.1,<2.0a0 - - openssl >=3.3.1,<4.0a0 + - openssl >=3.4.0,<4.0a0 - zstd >=1.5.6,<1.6.0a0 license: curl license_family: MIT purls: [] - size: 416057 - timestamp: 1722439924963 -- kind: conda - name: libcurl - version: 8.9.1 - build: hfd8ffcc_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.9.1-hfd8ffcc_0.conda - sha256: 4d6006c866844a39fb835436a48407f54f2310111a6f1d3e89efb16cf5c4d81b - md5: be0f46c6362775504d8894bd788a45b2 + size: 423011 + timestamp: 1733999897624 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.11.1-h73640d1_0.conda + sha256: f47c35938144c23278987c7d12096f6a42d7c850ffc277222b032073412383b6 + md5: 46d7524cabfdd199bffe63f8f19a552b depends: + - __osx >=11.0 - krb5 >=1.21.3,<1.22.0a0 - - libnghttp2 >=1.58.0,<2.0a0 - - libssh2 >=1.11.0,<2.0a0 + - libnghttp2 >=1.64.0,<2.0a0 + - libssh2 >=1.11.1,<2.0a0 - libzlib >=1.3.1,<2.0a0 - - openssl >=3.3.1,<4.0a0 + - openssl >=3.4.0,<4.0a0 - zstd >=1.5.6,<1.6.0a0 license: curl license_family: MIT purls: [] - size: 374937 - timestamp: 1722440523552 -- kind: conda - name: libcusolver - version: 11.6.4.69 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libcusolver-11.6.4.69-h5888daf_0.conda - sha256: 45027f9dcb11a983ffd644a330c4e0271b7614ebe0692922a9568ac2f302e913 - md5: fc9e14a670f0cb32620fbaa120220caa - depends: - - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libcublas >=12.6.1.4,<12.7.0a0 - - libcusparse >=12.5.3.3,<12.6.0a0 - - libgcc >=13 - - libnvjitlink >=12.6.68,<12.7.0a0 - - libstdcxx >=13 + size: 385098 + timestamp: 1734000160270 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcusolver-11.6.2.40-he02047a_0.conda + sha256: 5770a3c605218c0f51e1a80589170ca84f9e54fc4b8e202f0b12e5d60d3b01ca + md5: 8b1f3865c5e6b84fd198b30b2f13e445 + depends: + - __glibc >=2.17,<3.0.a0 + - cuda-version >=12.5,<12.6.0a0 + - libcublas >=12.5.2.13,<12.6.0a0 + - libcusparse >=12.4.1.24,<12.5.0a0 + - libgcc-ng >=12 + - libnvjitlink >=12.5.40,<12.6.0a0 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 83297629 - timestamp: 1724973412148 -- kind: conda - name: libcusolver-dev - version: 11.6.4.69 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libcusolver-dev-11.6.4.69-h5888daf_0.conda - sha256: bb96f93416ef9ce76e745975a065a5544fe0e0b121abbf2e9c54a328c24f1f8c - md5: a39da499c1ee374710e8c7bb605cd2a8 + size: 83060867 + timestamp: 1716356949171 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcusolver-dev-11.6.2.40-he02047a_0.conda + sha256: 7655143ee489f3f6ebf088b98146b7df0879eeab2da1c5e0e9ffe5fd79a8420f + md5: aadd152a5082213fd58c7dd729907fb7 depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libcusolver 11.6.4.69 h5888daf_0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libcusolver 11.6.2.40 he02047a_0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 constrains: - - libcusolver-static >=11.6.4.69 + - libcusolver-static >=11.6.2.40 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 61808 - timestamp: 1724973561609 -- kind: conda - name: libcusparse - version: 12.5.3.3 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libcusparse-12.5.3.3-h5888daf_0.conda - sha256: d976ee9d2501c118d016de6abb24e69ea791d458369a188d80892afd88f6dca3 - md5: c8fbcb107e6259e608f09be0e594bb7f + size: 60890 + timestamp: 1716357107864 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcusparse-12.4.1.24-he02047a_0.conda + sha256: 757f0bb987358a4eb38412d1886f518009edb1ac948de1b0b5e1e1b61f020bbf + md5: da5b8143844ef965f8482392cbe03cae depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libnvjitlink >=12.6.68,<12.7.0a0 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libnvjitlink >=12.5.40,<12.6.0a0 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 124383362 - timestamp: 1724962392645 -- kind: conda - name: libcusparse-dev - version: 12.5.3.3 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libcusparse-dev-12.5.3.3-h5888daf_0.conda - sha256: c7ed35c5e18e219998dcf5f57df2903dc4946ce0c601bf7d740ec99bde95da36 - md5: 438afdc7442fc3f1f18456d9620b44d0 + size: 118998350 + timestamp: 1716326918183 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcusparse-dev-12.4.1.24-he02047a_0.conda + sha256: cec532457bd6e5e95d1a694cdd03df21b06df342bf290642866b797776f61d00 + md5: 486b5ce7a47611a038892bcd412b1d7e depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libcusparse 12.5.3.3 h5888daf_0 - - libgcc >=13 - - libnvjitlink >=12.6.68,<12.7.0a0 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libcusparse 12.4.1.24 he02047a_0 + - libgcc-ng >=12 + - libnvjitlink >=12.5.40,<12.6.0a0 + - libstdcxx-ng >=12 constrains: - - libcusparse-static >=12.5.3.3 + - libcusparse-static >=12.4.1.24 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 51913 - timestamp: 1724962644354 -- kind: conda - name: libcxx - version: 18.1.8 - build: h3ed4263_7 - build_number: 7 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-18.1.8-h3ed4263_7.conda - sha256: 15b4abaa249f0965ce42aeb4a1a2b1b5df9a1f402e7c5bd8156272fd6cad2878 - md5: e0e7d9a2ec0f9509ffdfd5f48da522fb + size: 52159 + timestamp: 1716327186210 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-19.1.6-ha82da77_1.conda + sha256: 2b2443404503cd862385fd2f2a2c73f9624686fd1e5a45050b4034cfc06904ec + md5: ce5252d8db110cdb4ae4173d0a63c7c5 depends: - __osx >=11.0 license: Apache-2.0 WITH LLVM-exception license_family: Apache purls: [] - size: 436921 - timestamp: 1725403628507 -- kind: conda - name: libdeflate - version: '1.21' - build: h4bc722e_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.21-h4bc722e_0.conda - sha256: 728c24ce835700bfdfdf106bf04233fdb040a61ca4ecfd3f41b46fa90cd4f971 - md5: 36ce76665bf67f5aac36be7a0d21b7f3 + size: 520992 + timestamp: 1734494699681 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.23-h4ddbbb0_0.conda + sha256: 511d801626d02f4247a04fff957cc6e9ec4cc7e8622bd9acd076bcdc5de5fe66 + md5: 8dfae1d2e74767e9ce36d5fa0d8605db depends: - __glibc >=2.17,<3.0.a0 - - libgcc-ng >=12 + - libgcc >=13 license: MIT license_family: MIT purls: [] - size: 71163 - timestamp: 1722820138782 -- kind: conda - name: libdeflate - version: '1.21' - build: h99b78c6_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libdeflate-1.21-h99b78c6_0.conda - sha256: 243ca6d733954df9522eb9da24f5fe58da7ac19a2ca9438fd4abef5bb2cd1f83 - md5: 67d666c1516be5a023c3aaa85867099b + size: 72255 + timestamp: 1734373823254 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libdeflate-1.23-hec38601_0.conda + sha256: 887c02deaed6d583459eba6367023e36d8761085b2f7126e389424f57155da53 + md5: 1d8b9588be14e71df38c525767a1ac30 depends: - __osx >=11.0 license: MIT license_family: MIT purls: [] - size: 54533 - timestamp: 1722820240854 -- kind: conda - name: libdrm - version: 2.4.123 - build: hb9d3cd8_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libdrm-2.4.123-hb9d3cd8_0.conda - sha256: 5f274243fc7480b721a4ed6623c72d07b86a508a1363a85f0f16451ab655ace8 - md5: ee605e794bdc14e2b7f84c4faa0d8c2c + size: 54132 + timestamp: 1734373971372 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libdrm-2.4.124-hb9d3cd8_0.conda + sha256: f0d5ffbdf3903a7840184d14c14154b503e1a96767c328f61d99ad24b6963e52 + md5: 8bc89311041d7fcb510238cf0848ccae depends: - __glibc >=2.17,<3.0.a0 - - libgcc-ng >=13 + - libgcc >=13 - libpciaccess >=0.18,<0.19.0a0 license: MIT license_family: MIT purls: [] - size: 303108 - timestamp: 1724719521496 -- kind: conda - name: libdrm-cos7-x86_64 - version: 2.4.97 - build: h9b0a68f_1105 - build_number: 1105 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/libdrm-cos7-x86_64-2.4.97-h9b0a68f_1105.tar.bz2 - sha256: 9ccd7b539ec164ebe3ff8a511fa301ab7e6604f40d95a5f0b0bc5682267a8b8e - md5: 93b48dbb59766bddc742be8b9709961b + size: 242533 + timestamp: 1733424409299 +- conda: https://conda.anaconda.org/conda-forge/noarch/libdrm-cos7-x86_64-2.4.97-ha675448_1106.tar.bz2 + sha256: 3808b928522954d1b7847e4a654b4d0f6531c75d8b50489cf0e255d2ef1914e0 + md5: ed8be9ac257f340580c5820be02785ae depends: - sysroot_linux-64 2.17.* license: MIT license_family: MIT purls: [] - size: 161138 - timestamp: 1627494907863 -- kind: conda - name: libedit - version: 3.1.20191231 - build: hc8eb9b7_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20191231-hc8eb9b7_2.tar.bz2 - sha256: 3912636197933ecfe4692634119e8644904b41a58f30cad9d1fc02f6ba4d9fca - md5: 30e4362988a2623e9eb34337b83e01f9 - depends: - - ncurses >=6.2,<7.0.0a0 - license: BSD-2-Clause - license_family: BSD - purls: [] - size: 96607 - timestamp: 1597616630749 -- kind: conda - name: libedit - version: 3.1.20191231 - build: he28a2e2_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20191231-he28a2e2_2.tar.bz2 + size: 161991 + timestamp: 1726577302456 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20191231-he28a2e2_2.tar.bz2 sha256: a57d37c236d8f7c886e01656f4949d9dcca131d2a0728609c6f7fa338b65f1cf md5: 4d331e44109e3f0e19b4cb8f9b82f3e1 depends: @@ -8596,12 +8331,17 @@ packages: purls: [] size: 123878 timestamp: 1597616541093 -- kind: conda - name: libegl - version: 1.7.0 - build: ha4b6fd6_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libegl-1.7.0-ha4b6fd6_0.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20191231-hc8eb9b7_2.tar.bz2 + sha256: 3912636197933ecfe4692634119e8644904b41a58f30cad9d1fc02f6ba4d9fca + md5: 30e4362988a2623e9eb34337b83e01f9 + depends: + - ncurses >=6.2,<7.0.0a0 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 96607 + timestamp: 1597616630749 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libegl-1.7.0-ha4b6fd6_0.conda sha256: d577ab061760e631c2980eb88d6970e43391c461a89fc7cd6f98e2999d626d44 md5: 35e52d19547cb3265a09c49de146a5ae depends: @@ -8611,27 +8351,17 @@ packages: purls: [] size: 44492 timestamp: 1723473193819 -- kind: conda - name: libev - version: '4.33' - build: h93a5062_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda - sha256: 95cecb3902fbe0399c3a7e67a5bed1db813e5ab0e22f4023a5e0f722f2cc214f - md5: 36d33e440c31857372a72137f78bacf5 - license: BSD-2-Clause - license_family: BSD +- conda: https://conda.anaconda.org/conda-forge/linux-64/libegl-1.7.0-ha4b6fd6_2.conda + sha256: 7fd5408d359d05a969133e47af580183fbf38e2235b562193d427bb9dad79723 + md5: c151d5eb730e9b7480e6d48c0fc44048 + depends: + - __glibc >=2.17,<3.0.a0 + - libglvnd 1.7.0 ha4b6fd6_2 + license: LicenseRef-libglvnd purls: [] - size: 107458 - timestamp: 1702146414478 -- kind: conda - name: libev - version: '4.33' - build: hd590300_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda + size: 44840 + timestamp: 1731330973553 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda sha256: 1cd6048169fa0395af74ed5d8f1716e22c19a81a8a36f934c110ca3ad4dd27b4 md5: 172bf1cd1ff8629f2b1179945ed45055 depends: @@ -8641,29 +8371,15 @@ packages: purls: [] size: 112766 timestamp: 1702146165126 -- kind: conda - name: libevent - version: 2.1.12 - build: h2757513_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libevent-2.1.12-h2757513_1.conda - sha256: 8c136d7586259bb5c0d2b913aaadc5b9737787ae4f40e3ad1beaf96c80b919b7 - md5: 1a109764bff3bdc7bdd84088347d71dc - depends: - - openssl >=3.1.1,<4.0a0 - license: BSD-3-Clause +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda + sha256: 95cecb3902fbe0399c3a7e67a5bed1db813e5ab0e22f4023a5e0f722f2cc214f + md5: 36d33e440c31857372a72137f78bacf5 + license: BSD-2-Clause license_family: BSD purls: [] - size: 368167 - timestamp: 1685726248899 -- kind: conda - name: libevent - version: 2.1.12 - build: hf998b51_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libevent-2.1.12-hf998b51_1.conda + size: 107458 + timestamp: 1702146414478 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libevent-2.1.12-hf998b51_1.conda sha256: 2e14399d81fb348e9d231a82ca4d816bf855206923759b69ad006ba482764131 md5: a1cfcc585f0c42bf8d5546bb1dfb668d depends: @@ -8674,62 +8390,42 @@ packages: purls: [] size: 427426 timestamp: 1685725977222 -- kind: conda - name: libexpat - version: 2.6.3 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.6.3-h5888daf_0.conda - sha256: 4bb47bb2cd09898737a5211e2992d63c555d63715a07ba56eae0aff31fb89c22 - md5: 59f4c43bb1b5ef1c71946ff2cbf59524 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libevent-2.1.12-h2757513_1.conda + sha256: 8c136d7586259bb5c0d2b913aaadc5b9737787ae4f40e3ad1beaf96c80b919b7 + md5: 1a109764bff3bdc7bdd84088347d71dc + depends: + - openssl >=3.1.1,<4.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 368167 + timestamp: 1685726248899 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.6.4-h5888daf_0.conda + sha256: 56541b98447b58e52d824bd59d6382d609e11de1f8adf20b23143e353d2b8d26 + md5: db833e03127376d461e1e13e76f09b6c depends: - __glibc >=2.17,<3.0.a0 - libgcc >=13 constrains: - - expat 2.6.3.* + - expat 2.6.4.* license: MIT license_family: MIT purls: [] - size: 73616 - timestamp: 1725568742634 -- kind: conda - name: libexpat - version: 2.6.3 - build: hf9b8971_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.6.3-hf9b8971_0.conda - sha256: 5cbe5a199fba14ade55457a468ce663aac0b54832c39aa54470b3889b4c75c4a - md5: 5f22f07c2ab2dea8c66fe9585a062c96 + size: 73304 + timestamp: 1730967041968 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.6.4-h286801f_0.conda + sha256: e42ab5ace927ee7c84e3f0f7d813671e1cf3529f5f06ee5899606630498c2745 + md5: 38d2656dd914feb0cab8c629370768bf depends: - __osx >=11.0 constrains: - - expat 2.6.3.* - license: MIT - license_family: MIT - purls: [] - size: 63895 - timestamp: 1725568783033 -- kind: conda - name: libffi - version: 3.4.2 - build: h3422bc3_5 - build_number: 5 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.4.2-h3422bc3_5.tar.bz2 - sha256: 41b3d13efb775e340e4dba549ab5c029611ea6918703096b2eaa9c015c0750ca - md5: 086914b672be056eb70fd4285b6783b6 + - expat 2.6.4.* license: MIT license_family: MIT purls: [] - size: 39020 - timestamp: 1636488587153 -- kind: conda - name: libffi - version: 3.4.2 - build: h7f98852_5 - build_number: 5 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.2-h7f98852_5.tar.bz2 + size: 64693 + timestamp: 1730967175868 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.2-h7f98852_5.tar.bz2 sha256: ab6e9856c21709b7b517e940ae7028ae0737546122f83c2aa5d692860c3b149e md5: d645c6d2ac96843a2bfaccd2d62b3ac3 depends: @@ -8739,34 +8435,29 @@ packages: purls: [] size: 58292 timestamp: 1636488182923 -- kind: conda - name: libgcc - version: 14.1.0 - build: h77fa898_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libgcc-14.1.0-h77fa898_1.conda - sha256: 10fa74b69266a2be7b96db881e18fa62cfa03082b65231e8d652e897c4b335a3 - md5: 002ef4463dd1e2b44a94a4ace468f5d2 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.4.2-h3422bc3_5.tar.bz2 + sha256: 41b3d13efb775e340e4dba549ab5c029611ea6918703096b2eaa9c015c0750ca + md5: 086914b672be056eb70fd4285b6783b6 + license: MIT + license_family: MIT + purls: [] + size: 39020 + timestamp: 1636488587153 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-14.2.0-h77fa898_1.conda + sha256: 53eb8a79365e58849e7b1a068d31f4f9e718dc938d6f2c03e960345739a03569 + md5: 3cb76c3f10d3bc7f1105b2fc9db984df depends: - _libgcc_mutex 0.1 conda_forge - _openmp_mutex >=4.5 constrains: - - libgomp 14.1.0 h77fa898_1 - - libgcc-ng ==14.1.0=*_1 + - libgomp 14.2.0 h77fa898_1 + - libgcc-ng ==14.2.0=*_1 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL purls: [] - size: 846380 - timestamp: 1724801836552 -- kind: conda - name: libgcc-devel_linux-64 - version: 12.4.0 - build: ha4f9413_101 - build_number: 101 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-12.4.0-ha4f9413_101.conda + size: 848745 + timestamp: 1729027721139 +- conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-12.4.0-ha4f9413_101.conda sha256: a8b3f294ec43b249e4161b418dc64502a54de696740e7a2ce909af5651deb494 md5: 3a7914461d9072f25801a49770780cd4 depends: @@ -8776,64 +8467,17 @@ packages: purls: [] size: 2556252 timestamp: 1724801659892 -- kind: conda - name: libgcc-devel_linux-64 - version: 14.1.0 - build: h5d3d1c9_101 - build_number: 101 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-14.1.0-h5d3d1c9_101.conda - sha256: 3fead56fd86c615e69f96e033394504dbf5f1dec7de6ac4b7eb2d296bde5eacf - md5: 713834677de996ac1bc1b0b305ba46ba - depends: - - __unix - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL - purls: [] - size: 2753460 - timestamp: 1724801729615 -- kind: conda - name: libgcc-ng - version: 14.1.0 - build: h69a702a_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-14.1.0-h69a702a_1.conda - sha256: b91f7021e14c3d5c840fbf0dc75370d6e1f7c7ff4482220940eaafb9c64613b7 - md5: 1efc0ad219877a73ef977af7dbb51f17 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-14.2.0-h69a702a_1.conda + sha256: 3a76969c80e9af8b6e7a55090088bc41da4cffcde9e2c71b17f44d37b7cb87f7 + md5: e39480b9ca41323497b05492a63bc35b depends: - - libgcc 14.1.0 h77fa898_1 + - libgcc 14.2.0 h77fa898_1 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL purls: [] - size: 52170 - timestamp: 1724801842101 -- kind: conda - name: libgettextpo - version: 0.22.5 - build: h8414b35_3 - build_number: 3 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libgettextpo-0.22.5-h8414b35_3.conda - sha256: bc446fad58155e96a01b28e99254415c2151bdddf57f9a2c00c44e6f0298bb62 - md5: c8cd7295cfb7bda5cbabea4fef904349 - depends: - - __osx >=11.0 - - libiconv >=1.17,<2.0a0 - - libintl 0.22.5 h8414b35_3 - license: GPL-3.0-or-later - license_family: GPL - purls: [] - size: 159800 - timestamp: 1723627007035 -- kind: conda - name: libgettextpo - version: 0.22.5 - build: he02047a_3 - build_number: 3 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libgettextpo-0.22.5-he02047a_3.conda + size: 54142 + timestamp: 1729027726517 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgettextpo-0.22.5-he02047a_3.conda sha256: 7f2d1f4d69973e2c3c3d2b6420d5eb989982baba97d63ab2d7a2b25a92d886b4 md5: efab66b82ec976930b96d62a976de8e7 depends: @@ -8844,32 +8488,19 @@ packages: purls: [] size: 170646 timestamp: 1723626019265 -- kind: conda - name: libgettextpo-devel - version: 0.22.5 - build: h8414b35_3 - build_number: 3 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libgettextpo-devel-0.22.5-h8414b35_3.conda - sha256: ea3ca757bf11ed25965b39466b50411c7c2a43f3b90ab4a36fc0ef43f7ab98ac - md5: 7074dc1c9aae1bb5d7bccb4ff03746ca +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgettextpo-0.22.5-h8414b35_3.conda + sha256: bc446fad58155e96a01b28e99254415c2151bdddf57f9a2c00c44e6f0298bb62 + md5: c8cd7295cfb7bda5cbabea4fef904349 depends: - __osx >=11.0 - - libgettextpo 0.22.5 h8414b35_3 - libiconv >=1.17,<2.0a0 - libintl 0.22.5 h8414b35_3 license: GPL-3.0-or-later license_family: GPL purls: [] - size: 37153 - timestamp: 1723627048279 -- kind: conda - name: libgettextpo-devel - version: 0.22.5 - build: he02047a_3 - build_number: 3 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libgettextpo-devel-0.22.5-he02047a_3.conda + size: 159800 + timestamp: 1723627007035 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgettextpo-devel-0.22.5-he02047a_3.conda sha256: 0a66cdd46d1cd5201061252535cd91905b3222328a9294c1a5bcd32e85531545 md5: 9aba7960731e6b4547b3a52f812ed801 depends: @@ -8881,13 +8512,19 @@ packages: purls: [] size: 36790 timestamp: 1723626032786 -- kind: conda - name: libgfortran - version: 5.0.0 - build: 13_2_0_hd922786_3 - build_number: 3 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-5.0.0-13_2_0_hd922786_3.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-14.2.0-h69a702a_1.conda + sha256: fc9e7f22a17faf74da904ebfc4d88699013d2992e55505e4aa0eb01770290977 + md5: f1fd30127802683586f768875127a987 + depends: + - libgfortran5 14.2.0 hd5240d6_1 + constrains: + - libgfortran-ng ==14.2.0=*_1 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + size: 53997 + timestamp: 1729027752995 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-5.0.0-13_2_0_hd922786_3.conda sha256: 44e541b4821c96b28b27fef5630883a60ce4fee91fd9c79f25a199f8f73f337b md5: 4a55d9e169114b2b90d3ec4604cd7bbf depends: @@ -8897,47 +8534,19 @@ packages: purls: [] size: 110233 timestamp: 1707330749033 -- kind: conda - name: libgfortran - version: 14.1.0 - build: h69a702a_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-14.1.0-h69a702a_1.conda - sha256: ed77f04f873e43a26e24d443dd090631eedc7d0ace3141baaefd96a123e47535 - md5: 591e631bc1ae62c64f2ab4f66178c097 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-14.2.0-hd5240d6_1.conda + sha256: d149a37ca73611e425041f33b9d8dbed6e52ec506fe8cc1fc0ee054bddeb6d5d + md5: 9822b874ea29af082e5d36098d25427d depends: - - libgfortran5 14.1.0 hc5f4f2c_1 + - libgcc >=14.2.0 constrains: - - libgfortran-ng ==14.1.0=*_1 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL - purls: [] - size: 52142 - timestamp: 1724801872472 -- kind: conda - name: libgfortran-ng - version: 14.1.0 - build: h69a702a_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-14.1.0-h69a702a_1.conda - sha256: a2dc35cb7f87bb5beebf102d4085574c6a740e1df58e743185d4434cc5e4e0ae - md5: 16cec94c5992d7f42ae3f9fa8b25df8d - depends: - - libgfortran 14.1.0 h69a702a_1 + - libgfortran 14.2.0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL purls: [] - size: 52212 - timestamp: 1724802086021 -- kind: conda - name: libgfortran5 - version: 13.2.0 - build: hf226fd6_3 - build_number: 3 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-13.2.0-hf226fd6_3.conda + size: 1462645 + timestamp: 1729027735353 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-13.2.0-hf226fd6_3.conda sha256: bafc679eedb468a86aa4636061c55966186399ee0a04b605920d208d97ac579a md5: 66ac81d54e95c534ae488726c1f698ea depends: @@ -8949,30 +8558,7 @@ packages: purls: [] size: 997381 timestamp: 1707330687590 -- kind: conda - name: libgfortran5 - version: 14.1.0 - build: hc5f4f2c_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-14.1.0-hc5f4f2c_1.conda - sha256: c40d7db760296bf9c776de12597d2f379f30e890b9ae70c1de962ff2aa1999f6 - md5: 10a0cef64b784d6ab6da50ebca4e984d - depends: - - libgcc >=14.1.0 - constrains: - - libgfortran 14.1.0 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL - purls: [] - size: 1459939 - timestamp: 1724801851300 -- kind: conda - name: libgl - version: 1.7.0 - build: ha4b6fd6_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_0.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_0.conda sha256: 993f3bfe04e16c58fceab108bf54f1522ff93a657a22a4ced8c56658001d55fa md5: 3deca8c25851196c28d1c84dd4ae9149 depends: @@ -8983,37 +8569,51 @@ packages: purls: [] size: 132746 timestamp: 1723473216625 -- kind: conda - name: libglib - version: 2.80.3 - build: h315aac3_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.80.3-h315aac3_2.conda - sha256: 7470e664b780b91708bed356cc634874dfc3d6f17cbf884a1d6f5d6d59c09f91 - md5: b0143a3e98136a680b728fdf9b42a258 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_2.conda + sha256: dc2752241fa3d9e40ce552c1942d0a4b5eeb93740c9723873f6fcf8d39ef8d2d + md5: 928b8be80851f5d8ffb016f9c81dae7a depends: - __glibc >=2.17,<3.0.a0 + - libglvnd 1.7.0 ha4b6fd6_2 + - libglx 1.7.0 ha4b6fd6_2 + license: LicenseRef-libglvnd + purls: [] + size: 134712 + timestamp: 1731330998354 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.80.2-hf974151_0.conda + sha256: 93e03b6cf4765bc06d64fa3dac65f22c53ae4a30247bb0e2dea0bd9c47a3fb26 + md5: 72724f6a78ecb15559396966226d5838 + depends: - libffi >=3.4,<4.0a0 - libgcc-ng >=12 - libiconv >=1.17,<2.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - pcre2 >=10.43,<10.44.0a0 + constrains: + - glib 2.80.2 *_0 + license: LGPL-2.1-or-later + purls: [] + size: 3912673 + timestamp: 1715252654366 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.82.2-h2ff4ddf_0.conda + sha256: 49ee9401d483a76423461c50dcd37f91d070efaec7e4dc2828d8cdd2ce694231 + md5: 13e8e54035ddd2b91875ba399f0f7c04 + depends: + - __glibc >=2.17,<3.0.a0 + - libffi >=3.4,<4.0a0 + - libgcc >=13 + - libiconv >=1.17,<2.0a0 - libzlib >=1.3.1,<2.0a0 - pcre2 >=10.44,<10.45.0a0 constrains: - - glib 2.80.3 *_2 + - glib 2.82.2 *_0 license: LGPL-2.1-or-later purls: [] - size: 3922900 - timestamp: 1723208802469 -- kind: conda - name: libglib - version: 2.80.3 - build: h59d46d9_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.80.3-h59d46d9_2.conda - sha256: 15cc86d7d91fb78a76e3e2b965e5d6e8b7c79cc4f4ec3322d48fb712d792eff6 - md5: 17ac2bac18ec707efc8575fae2f09990 + size: 3931898 + timestamp: 1729191404130 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.82.2-h07bd6cf_0.conda + sha256: 101fb31c509d6a69ac5d612b51d4088ddbc675fca18cf0c3589cfee26cd01ca0 + md5: 890783f64502fa6bfcdc723cfbf581b4 depends: - __osx >=11.0 - libffi >=3.4,<4.0a0 @@ -9022,37 +8622,45 @@ packages: - libzlib >=1.3.1,<2.0a0 - pcre2 >=10.44,<10.45.0a0 constrains: - - glib 2.80.3 *_2 + - glib 2.82.2 *_0 license: LGPL-2.1-or-later purls: [] - size: 3632316 - timestamp: 1723209072976 -- kind: conda - name: libglu - version: 9.0.0 - build: ha6d2627_1004 - build_number: 1004 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libglu-9.0.0-ha6d2627_1004.conda - sha256: c4a14878c2be8c18b7e89a19917f0f6c964dd962c91a079fe5e0c6e8b8b1bbd4 - md5: df069bea331c8486ac21814969301c1f + size: 3635416 + timestamp: 1729191799117 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libglu-9.0.0-hac7e632_1003.conda + sha256: 8368435c41105dc3e1c02896a02ecaa21b77d0b0d67fc8b06a16ba885c86f917 + md5: 50c389a09b6b7babaef531eb7cb5e0ca depends: - libgcc-ng >=12 - libstdcxx-ng >=12 - - libxcb >=1.16,<1.17.0a0 - - xorg-libx11 >=1.8.9,<2.0a0 + - libxcb >=1.15,<1.16.0a0 + - xorg-libx11 >=1.8.6,<2.0a0 - xorg-libxext >=1.3.4,<2.0a0 - xorg-xextproto >=7.3.0,<8.0a0 license: SGI-2 purls: [] - size: 325824 - timestamp: 1718880563533 -- kind: conda - name: libglvnd - version: 1.7.0 - build: ha4b6fd6_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_0.conda + size: 331249 + timestamp: 1694431884320 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libglu-9.0.3-h03adeef_0.conda + sha256: cabd78b5ede1f3f161037d3a6cfb6b8a262ec474f9408859c364ef55ba778097 + md5: b1df5affe904efe82ef890826b68881d + depends: + - __glibc >=2.17,<3.0.a0 + - libdrm >=2.4.123,<2.5.0a0 + - libegl >=1.7.0,<2.0a0 + - libgcc >=13 + - libgl >=1.7.0,<2.0a0 + - libstdcxx >=13 + - libxcb >=1.17.0,<2.0a0 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxdamage >=1.1.6,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + - xorg-libxxf86vm >=1.1.5,<2.0a0 + license: SGI-2 + purls: [] + size: 325361 + timestamp: 1731470892413 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_0.conda sha256: ce35ceca19110ba9d27cb0058e55c62ea0489b3dfad76d016df2d0bf4f027998 md5: e46b5ae31282252e0525713e34ffbe2b depends: @@ -9061,142 +8669,97 @@ packages: purls: [] size: 129500 timestamp: 1723473188457 -- kind: conda - name: libglvnd-core-devel-cos7-x86_64 - version: 1.0.1 - build: h9b0a68f_1105 - build_number: 1105 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/libglvnd-core-devel-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - sha256: 6ed9aeb6d5b475cb02d2b9f28fca231ce1c3141c2b086442d49dd581291da20c - md5: d0bc379b8c2fec83d136ac36676147db +- conda: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_2.conda + sha256: 1175f8a7a0c68b7f81962699751bb6574e6f07db4c9f72825f978e3016f46850 + md5: 434ca7e50e40f4918ab701e3facd59a0 + depends: + - __glibc >=2.17,<3.0.a0 + license: LicenseRef-libglvnd + purls: [] + size: 132463 + timestamp: 1731330968309 +- conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-core-devel-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + sha256: 23bb37df2c6d9b2dcc1eb10c5a39a3b946ea139c06087f0b1f334bc1b5d97def + md5: 750f74db4e7d53b16b96e9bd61b4167e depends: - sysroot_linux-64 2.17.* license: MIT license_family: MIT purls: [] - size: 22309 - timestamp: 1627496763566 -- kind: conda - name: libglvnd-cos7-x86_64 - version: 1.0.1 - build: h9b0a68f_1105 - build_number: 1105 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/libglvnd-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - sha256: c40dde62d3046779472abec5508f0d5b905bfc31696cfb7d3fb1e36fdee2a022 - md5: 53cddbcee69dbec56e1ff6fd315bb411 + size: 23123 + timestamp: 1726574666979 +- conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + sha256: a1c8f2323fd6264c87099aba24a88594756e661bbe1dca00cadd89c25b358c8a + md5: 5b6f90a0c8dbdfee4562c01a61d00074 depends: - sysroot_linux-64 2.17.* license: MIT license_family: MIT purls: [] - size: 133420 - timestamp: 1627496448251 -- kind: conda - name: libglvnd-devel-cos7-x86_64 - version: 1.0.1 - build: h9b0a68f_1105 - build_number: 1105 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/libglvnd-devel-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - sha256: 14ba9da004f23a9d2483cdff54abe6f8a9982ef25388129aca6afb49dbc7f817 - md5: 62b944caeb3346378370eba2f0d69974 - depends: - - libglvnd-core-devel-cos7-x86_64 ==1.0.1 *_1105 - - libglvnd-cos7-x86_64 ==1.0.1 *_1105 - - libglvnd-egl-cos7-x86_64 ==1.0.1 *_1105 - - libglvnd-gles-cos7-x86_64 ==1.0.1 *_1105 - - libglvnd-glx-cos7-x86_64 ==1.0.1 *_1105 - - libglvnd-opengl-cos7-x86_64 ==1.0.1 *_1105 + size: 134338 + timestamp: 1726576996513 +- conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-devel-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + sha256: 66af9e4f56170324527ad39c38a1079006b34352f81958ca669132f8d21acb80 + md5: e1875704f03bef14dea17a0c808a41c7 + depends: + - libglvnd-core-devel-cos7-x86_64 ==1.0.1 *_1106 + - libglvnd-cos7-x86_64 ==1.0.1 *_1106 + - libglvnd-egl-cos7-x86_64 ==1.0.1 *_1106 + - libglvnd-gles-cos7-x86_64 ==1.0.1 *_1106 + - libglvnd-glx-cos7-x86_64 ==1.0.1 *_1106 + - libglvnd-opengl-cos7-x86_64 ==1.0.1 *_1106 - sysroot_linux-64 2.17.* license: MIT license_family: MIT purls: [] - size: 14814 - timestamp: 1627507120616 -- kind: conda - name: libglvnd-egl-cos7-x86_64 - version: 1.0.1 - build: h9b0a68f_1105 - build_number: 1105 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/libglvnd-egl-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - sha256: 0c920339496e8261169ae4dcff643eebd698743805e39a16e7b29b98a09f4ce7 - md5: f6c25c37939d1f82a98594176a1e881f + size: 15517 + timestamp: 1726588486645 +- conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-egl-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + sha256: 54e90883ca6c68fea93731f5d119b5959d0c66399d746f8f25a03b7e56df1e04 + md5: 597630f2fed3ca321579f15ab4213721 depends: - - libglvnd-cos7-x86_64 ==1.0.1 *_1105 - - mesa-libegl-cos7-x86_64 >=13.0.4 *_1105 + - libglvnd-cos7-x86_64 ==1.0.1 *_1106 + - mesa-libegl-cos7-x86_64 >=13.0.4 *_1106 - sysroot_linux-64 2.17.* license: MIT license_family: MIT purls: [] - size: 52905 - timestamp: 1627505938919 -- kind: conda - name: libglvnd-gles-cos7-x86_64 - version: 1.0.1 - build: h9b0a68f_1105 - build_number: 1105 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/libglvnd-gles-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - sha256: 16e3147cae64d2c5f45f13a51a96d79776bbad1e0aaad74b67e746387ea49ea8 - md5: 4feeadd256e6afd6a20111ce8f595132 + size: 53792 + timestamp: 1726586479886 +- conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-gles-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + sha256: 1eb34a5d1275badb105bc67fd104a9cffdc186a62f4c8a58d0cd0d2b9f32f932 + md5: e00c2da421fd410396fd508dfb144cbd depends: - - libglvnd-cos7-x86_64 ==1.0.1 *_1105 + - libglvnd-cos7-x86_64 ==1.0.1 *_1106 - sysroot_linux-64 2.17.* license: MIT license_family: MIT purls: [] - size: 46370 - timestamp: 1627498179356 -- kind: conda - name: libglvnd-glx-cos7-x86_64 - version: 1.0.1 - build: h9b0a68f_1105 - build_number: 1105 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/libglvnd-glx-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - sha256: a8e94f9278b1688bb7cfe3625ed1ce5ae798bd31b3ca3cfdf5863f6283816be0 - md5: f2ab4d3bd5f80ea4a30d5e35b90b6656 + size: 47186 + timestamp: 1726579158773 +- conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-glx-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + sha256: 63ee08630476f1704020aec9dd11a246b49cf08f2eb60152a806518bdc045c13 + md5: 8e9f797d73fe13e17495474c253f8771 depends: - - libglvnd-cos7-x86_64 ==1.0.1 *_1105 + - libglvnd-cos7-x86_64 ==1.0.1 *_1106 - sysroot_linux-64 2.17.* license: MIT license_family: MIT purls: [] - size: 180318 - timestamp: 1627502249243 -- kind: conda - name: libglvnd-opengl-cos7-x86_64 - version: 1.0.1 - build: h9b0a68f_1105 - build_number: 1105 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/libglvnd-opengl-cos7-x86_64-1.0.1-h9b0a68f_1105.tar.bz2 - sha256: 8cf3adc7eec55af6c7fdd87b379c71d5b74a6adc6f0dc91930c5c1f673f6a518 - md5: c81196f3a5364e7e982b0286dc3ca02e + size: 181258 + timestamp: 1726580316705 +- conda: https://conda.anaconda.org/conda-forge/noarch/libglvnd-opengl-cos7-x86_64-1.0.1-ha675448_1106.tar.bz2 + sha256: 22af7a48f46e1a37c36966a78dcd4469d2eab9bab0de0c62a9e5353d39de3e33 + md5: c280745326e21c50f650100a3ae06605 depends: - - libglvnd-cos7-x86_64 ==1.0.1 *_1105 + - libglvnd-cos7-x86_64 ==1.0.1 *_1106 - sysroot_linux-64 2.17.* license: MIT license_family: MIT purls: [] - size: 62116 - timestamp: 1627499423237 -- kind: conda - name: libglx - version: 1.7.0 - build: ha4b6fd6_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_0.conda + size: 63006 + timestamp: 1726579374514 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_0.conda sha256: 72ba2a55de3d8902b40359433bbc51f50574067eaf2ae4081a2347d3735e30bb md5: b470cc353c5b852e0d830e8d5d23e952 depends: @@ -9207,122 +8770,176 @@ packages: purls: [] size: 79343 timestamp: 1723473207891 -- kind: conda - name: libgomp - version: 14.1.0 - build: h77fa898_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libgomp-14.1.0-h77fa898_1.conda - sha256: c96724c8ae4ee61af7674c5d9e5a3fbcf6cd887a40ad5a52c99aa36f1d4f9680 - md5: 23c255b008c4f2ae008f81edcabaca89 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_2.conda + sha256: 2d35a679624a93ce5b3e9dd301fff92343db609b79f0363e6d0ceb3a6478bfa7 + md5: c8013e438185f33b13814c5c488acd5c + depends: + - __glibc >=2.17,<3.0.a0 + - libglvnd 1.7.0 ha4b6fd6_2 + - xorg-libx11 >=1.8.10,<2.0a0 + license: LicenseRef-libglvnd + purls: [] + size: 75504 + timestamp: 1731330988898 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-14.2.0-h77fa898_1.conda + sha256: 1911c29975ec99b6b906904040c855772ccb265a1c79d5d75c8ceec4ed89cd63 + md5: cc3573974587f12dda90d96e3e55a702 depends: - _libgcc_mutex 0.1 conda_forge license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL purls: [] - size: 460218 - timestamp: 1724801743478 -- kind: conda - name: libgoogle-cloud - version: 2.28.0 - build: h26d7fe4_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-2.28.0-h26d7fe4_0.conda - sha256: d87b83d91a9fed749b80dea915452320598035949804db3be616b8c3d694c743 - md5: 2c51703b4d775f8943c08a361788131b + size: 460992 + timestamp: 1729027639220 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-2.29.0-h435de7b_0.conda + sha256: c8ee42a4acce5227d220ec6500f6872d52d82e478c76648b9ff57dd2d86429bd + md5: 5d95d9040c4319997644f68e9aefbe70 depends: - __glibc >=2.17,<3.0.a0 - libabseil * cxx17* - libabseil >=20240116.2,<20240117.0a0 - libcurl >=8.9.1,<9.0a0 - - libgcc-ng >=12 + - libgcc >=13 - libgrpc >=1.62.2,<1.63.0a0 - libprotobuf >=4.25.3,<4.25.4.0a0 - - libstdcxx-ng >=12 - - openssl >=3.3.1,<4.0a0 + - libstdcxx >=13 + - openssl >=3.3.2,<4.0a0 + constrains: + - libgoogle-cloud 2.29.0 *_0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 1241649 + timestamp: 1725640926284 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-2.32.0-h804f50b_0.conda + sha256: 126856add750013390dff664a3c3cd0f6f0cbbc683b0025a7ce9d1618968bc70 + md5: 3d96df4d6b1c88455e05b94ce8a14a53 + depends: + - __glibc >=2.17,<3.0.a0 + - libabseil * cxx17* + - libabseil >=20240722.0,<20240723.0a0 + - libcurl >=8.10.1,<9.0a0 + - libgcc >=13 + - libgrpc >=1.67.1,<1.68.0a0 + - libprotobuf >=5.28.2,<5.28.3.0a0 + - libstdcxx >=13 + - openssl >=3.4.0,<4.0a0 constrains: - - libgoogle-cloud 2.28.0 *_0 + - libgoogle-cloud 2.32.0 *_0 license: Apache-2.0 license_family: Apache purls: [] - size: 1226849 - timestamp: 1723370075980 -- kind: conda - name: libgoogle-cloud - version: 2.28.0 - build: hfe08963_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libgoogle-cloud-2.28.0-hfe08963_0.conda - sha256: 8ac585e360937aaf9f323e7414c710bf00eec6cf742c15b521fd502e6e3abf2b - md5: 68fb9b247b79e8ac3be37c2923a0cf8a + size: 1249557 + timestamp: 1733512191906 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgoogle-cloud-2.29.0-hfa33a2f_0.conda + sha256: 1f42048702d773a355d276d24313ac63781a331959fc3662c6be36e979d7845c + md5: f78c7bd435ee45f4661daae9e81ddf13 depends: - __osx >=11.0 - libabseil * cxx17* - libabseil >=20240116.2,<20240117.0a0 - libcurl >=8.9.1,<9.0a0 - - libcxx >=16 + - libcxx >=17 - libgrpc >=1.62.2,<1.63.0a0 - libprotobuf >=4.25.3,<4.25.4.0a0 - - openssl >=3.3.1,<4.0a0 + - openssl >=3.3.2,<4.0a0 constrains: - - libgoogle-cloud 2.28.0 *_0 + - libgoogle-cloud 2.29.0 *_0 license: Apache-2.0 license_family: Apache purls: [] - size: 848880 - timestamp: 1723369224404 -- kind: conda - name: libgoogle-cloud-storage - version: 2.28.0 - build: h1466eeb_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libgoogle-cloud-storage-2.28.0-h1466eeb_0.conda - sha256: c62d08339e98fd56d65390df1184d8c2929de2713d431a910c3bb59750daccac - md5: 16874ac519f64d2199fab04fd9bd821d + size: 866727 + timestamp: 1725640714587 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgoogle-cloud-2.32.0-h8d8be31_0.conda + sha256: 722e49dbdc4486105d9f5b79a7ba4f9064602fe20c4015e97684c898ab8d3386 + md5: d7ab9e0eb7d55eac4943913073de61d7 depends: - __osx >=11.0 + - libabseil * cxx17* + - libabseil >=20240722.0,<20240723.0a0 + - libcurl >=8.10.1,<9.0a0 + - libcxx >=18 + - libgrpc >=1.67.1,<1.68.0a0 + - libprotobuf >=5.28.2,<5.28.3.0a0 + - openssl >=3.4.0,<4.0a0 + constrains: + - libgoogle-cloud 2.32.0 *_0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 876210 + timestamp: 1733512539476 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-storage-2.29.0-h0121fbd_0.conda + sha256: 2847c9e940b742275a7068e0a742bdabf211bf0b2bbb1453592d6afb47c7e17e + md5: 06dfd5208170b56eee943d9ac674a533 + depends: + - __glibc >=2.17,<3.0.a0 - libabseil - libcrc32c >=1.1.2,<1.2.0a0 - libcurl - - libcxx >=16 - - libgoogle-cloud 2.28.0 hfe08963_0 + - libgcc >=13 + - libgoogle-cloud 2.29.0 h435de7b_0 + - libstdcxx >=13 - libzlib >=1.3.1,<2.0a0 - openssl license: Apache-2.0 license_family: Apache purls: [] - size: 522700 - timestamp: 1723370053755 -- kind: conda - name: libgoogle-cloud-storage - version: 2.28.0 - build: ha262f82_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-storage-2.28.0-ha262f82_0.conda - sha256: 3237bc1ee88dab8d8fea0a1886e12a0262ff5e471944a234c314aa1da411588e - md5: 9e7960f0b9ab3895ef73d92477c47dae + size: 781655 + timestamp: 1725641060970 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-storage-2.32.0-h0121fbd_0.conda + sha256: d1b53d17df38b52a4bc6d1fe6af0e611d6480ce10b0af570c84bd38c8aa83b91 + md5: 877a5ec0431a5af83bf0cd0522bfe661 depends: - __glibc >=2.17,<3.0.a0 - libabseil - libcrc32c >=1.1.2,<1.2.0a0 - libcurl - - libgcc-ng >=12 - - libgoogle-cloud 2.28.0 h26d7fe4_0 - - libstdcxx-ng >=12 + - libgcc >=13 + - libgoogle-cloud 2.32.0 h804f50b_0 + - libstdcxx >=13 + - libzlib >=1.3.1,<2.0a0 + - openssl + license: Apache-2.0 + license_family: Apache + purls: [] + size: 782108 + timestamp: 1733512329104 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgoogle-cloud-storage-2.29.0-h90fd6fa_0.conda + sha256: ec80383fbb6fae95d2ff7d04ba46b282ab48219b7ce85b3cd5ee7d0d8bae74e1 + md5: baee0b9cb1c5319f370a534ca5a16267 + depends: + - __osx >=11.0 + - libabseil + - libcrc32c >=1.1.2,<1.2.0a0 + - libcurl + - libcxx >=17 + - libgoogle-cloud 2.29.0 hfa33a2f_0 - libzlib >=1.3.1,<2.0a0 - openssl license: Apache-2.0 license_family: Apache purls: [] - size: 769298 - timestamp: 1723370220027 -- kind: conda - name: libgrpc - version: 1.62.2 - build: h15f2491_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libgrpc-1.62.2-h15f2491_0.conda + size: 535346 + timestamp: 1725641618955 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgoogle-cloud-storage-2.32.0-h7081f7f_0.conda + sha256: 609df2cf376ba66460f40143f835fc567cae4458df80705587cd2efd59c09bf1 + md5: 28f5ab5cf95170dfacd05d2bb301e573 + depends: + - __osx >=11.0 + - libabseil + - libcrc32c >=1.1.2,<1.2.0a0 + - libcurl + - libcxx >=18 + - libgoogle-cloud 2.32.0 h8d8be31_0 + - libzlib >=1.3.1,<2.0a0 + - openssl + license: Apache-2.0 + license_family: Apache + purls: [] + size: 526895 + timestamp: 1733513644846 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgrpc-1.62.2-h15f2491_0.conda sha256: 28241ed89335871db33cb6010e9ccb2d9e9b6bb444ddf6884f02f0857363c06a md5: 8dabe607748cb3d7002ad73cd06f1325 depends: @@ -9331,7 +8948,7 @@ packages: - libabseil >=20240116.1,<20240117.0a0 - libgcc-ng >=12 - libprotobuf >=4.25.3,<4.25.4.0a0 - - libre2-11 >=2023.9.1,<2024.0a0 + - libre2-11 >=2023.9.1 - libstdcxx-ng >=12 - libzlib >=1.2.13,<2.0.0a0 - openssl >=3.2.1,<4.0a0 @@ -9343,12 +8960,29 @@ packages: purls: [] size: 7316832 timestamp: 1713390645548 -- kind: conda - name: libgrpc - version: 1.62.2 - build: h9c18a4f_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libgrpc-1.62.2-h9c18a4f_0.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgrpc-1.67.1-hc2c308b_0.conda + sha256: 870550c1faf524e9a695262cd4c31441b18ad542f16893bd3c5dbc93106705f7 + md5: 4606a4647bfe857e3cfe21ca12ac3afb + depends: + - __glibc >=2.17,<3.0.a0 + - c-ares >=1.32.3,<2.0a0 + - libabseil * cxx17* + - libabseil >=20240722.0,<20240723.0a0 + - libgcc >=13 + - libprotobuf >=5.28.2,<5.28.3.0a0 + - libre2-11 >=2024.7.2 + - libstdcxx >=13 + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.3.2,<4.0a0 + - re2 + constrains: + - grpc-cpp =1.67.1 + license: Apache-2.0 + license_family: APACHE + purls: [] + size: 7362336 + timestamp: 1730236333879 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgrpc-1.62.2-h9c18a4f_0.conda sha256: d2c5b5a828f6f1242c11e8c91968f48f64446f7dd5cbfa1197545e465eb7d47a md5: e624fc11026dbb84c549435eccd08623 depends: @@ -9357,7 +8991,7 @@ packages: - libabseil >=20240116.1,<20240117.0a0 - libcxx >=16 - libprotobuf >=4.25.3,<4.25.4.0a0 - - libre2-11 >=2023.9.1,<2024.0a0 + - libre2-11 >=2023.9.1 - libzlib >=1.2.13,<2.0.0a0 - openssl >=3.2.1,<4.0a0 - re2 @@ -9368,63 +9002,66 @@ packages: purls: [] size: 5016525 timestamp: 1713392846329 -- kind: conda - name: libhwloc - version: 2.11.1 - build: default_h7685b71_1000 - build_number: 1000 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libhwloc-2.11.1-default_h7685b71_1000.conda - sha256: ffe883123f06a7398fdb5039a52f03e3e0ee2a55ed64133580446cda62d11d16 - md5: 4c4f204c15fdc91ee75cd0449a08b87a +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgrpc-1.67.1-hc70892a_0.conda + sha256: d2393fcd3c3584e5d58da4122f48bcf297567d2f6f14b3d1fcbd34fdd5040694 + md5: 624e27571fde34f8acc2afec840ac435 depends: - __osx >=11.0 - - libcxx >=16 - - libxml2 >=2.12.7,<3.0a0 + - c-ares >=1.34.2,<2.0a0 + - libabseil * cxx17* + - libabseil >=20240722.0,<20240723.0a0 + - libcxx >=17 + - libprotobuf >=5.28.2,<5.28.3.0a0 + - libre2-11 >=2024.7.2 + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.3.2,<4.0a0 + - re2 + constrains: + - grpc-cpp =1.67.1 + license: Apache-2.0 + license_family: APACHE + purls: [] + size: 4882208 + timestamp: 1730236299095 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libhwloc-2.11.2-default_h0d58e46_1001.conda + sha256: d14c016482e1409ae1c50109a9ff933460a50940d2682e745ab1c172b5282a69 + md5: 804ca9e91bcaea0824a341d55b1684f2 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + - libxml2 >=2.13.4,<3.0a0 license: BSD-3-Clause license_family: BSD purls: [] - size: 2325644 - timestamp: 1720460737568 -- kind: conda - name: libhwloc - version: 2.11.1 - build: default_hecaa2ac_1000 - build_number: 1000 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libhwloc-2.11.1-default_hecaa2ac_1000.conda - sha256: 8473a300e10b79557ce0ac81602506b47146aff3df4cc3568147a7dd07f480a2 - md5: f54aeebefb5c5ff84eca4fb05ca8aa3a + size: 2423200 + timestamp: 1731374922090 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libhwloc-2.11.2-default_he43201b_1000.conda + sha256: 75be8732e6f94ff2faa129f44ec4970275e1d977559b0c2fb75b7baa5347e16b + md5: 36247217c4e1018085bd9db41eb3526a depends: - __glibc >=2.17,<3.0.a0 - - libgcc-ng >=12 - - libstdcxx-ng >=12 + - libgcc >=13 + - libstdcxx >=13 - libxml2 >=2.12.7,<3.0a0 license: BSD-3-Clause license_family: BSD purls: [] - size: 2417964 - timestamp: 1720460562447 -- kind: conda - name: libiconv - version: '1.17' - build: h0d3ecfb_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.17-h0d3ecfb_2.conda - sha256: bc7de5097b97bcafcf7deaaed505f7ce02f648aac8eccc0d5a47cc599a1d0304 - md5: 69bda57310071cf6d2b86caf11573d2d - license: LGPL-2.1-only + size: 2425405 + timestamp: 1727379398547 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libhwloc-2.11.2-default_hbce5d74_1001.conda + sha256: dcac7144ad93cf3f276ec14c5553aa34de07443a9b1db6b3cd8d2e117b173c40 + md5: ff6438cf47cff4899ae9900bf9253c41 + depends: + - __osx >=11.0 + - libcxx >=18 + - libxml2 >=2.13.4,<3.0a0 + license: BSD-3-Clause + license_family: BSD purls: [] - size: 676469 - timestamp: 1702682458114 -- kind: conda - name: libiconv - version: '1.17' - build: hd590300_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.17-hd590300_2.conda + size: 2332319 + timestamp: 1731375088576 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.17-hd590300_2.conda sha256: 8ac2f6a9f186e76539439e50505d98581472fedb347a20e7d1f36429849f05c9 md5: d66573916ffcf376178462f1b61c941e depends: @@ -9433,27 +9070,14 @@ packages: purls: [] size: 705775 timestamp: 1702682170569 -- kind: conda - name: libidn2 - version: 2.3.7 - build: h93a5062_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libidn2-2.3.7-h93a5062_0.conda - sha256: ae6be1c42fa18cb76fb1d17093f5b467b7a9bcf402da91081a9126c8843c004d - md5: 6e4a21ef7a8e4c0cc65381854848e232 - depends: - - gettext >=0.21.1,<1.0a0 - - libunistring >=0,<1.0a0 - license: LGPLv2 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.17-h0d3ecfb_2.conda + sha256: bc7de5097b97bcafcf7deaaed505f7ce02f648aac8eccc0d5a47cc599a1d0304 + md5: 69bda57310071cf6d2b86caf11573d2d + license: LGPL-2.1-only purls: [] - size: 134491 - timestamp: 1706368362998 -- kind: conda - name: libidn2 - version: 2.3.7 - build: hd590300_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libidn2-2.3.7-hd590300_0.conda + size: 676469 + timestamp: 1702682458114 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libidn2-2.3.7-hd590300_0.conda sha256: 253f9be445c58bf07b39d8f67ac08bccc5010c75a8c2070cddfb6c20e1ca4f4f md5: 2b7b0d827c6447cc1d85dc06d5b5de46 depends: @@ -9464,13 +9088,7 @@ packages: purls: [] size: 126515 timestamp: 1706368269716 -- kind: conda - name: libintl - version: 0.22.5 - build: h8414b35_3 - build_number: 3 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.22.5-h8414b35_3.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.22.5-h8414b35_3.conda sha256: 7c1d238d4333af385e594c89ebcb520caad7ed83a735c901099ec0970a87a891 md5: 3b98ec32e91b3b59ad53dbb9c96dd334 depends: @@ -9480,30 +9098,18 @@ packages: purls: [] size: 81171 timestamp: 1723626968270 -- kind: conda - name: libintl-devel - version: 0.22.5 - build: h8414b35_3 - build_number: 3 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-devel-0.22.5-h8414b35_3.conda - sha256: c9d1d4fdfb5775828e54bc9fb443b1a6de9319a04b81d1bac52c26114a763154 - md5: 271646de11b018c66e81eb4c4717b291 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.0.0-hd590300_1.conda + sha256: b954e09b7e49c2f2433d6f3bb73868eda5e378278b0f8c1dd10a7ef090e14f2f + md5: ea25936bb4080d843790b586850f82b8 depends: - - __osx >=11.0 - - libiconv >=1.17,<2.0a0 - - libintl 0.22.5 h8414b35_3 - license: LGPL-2.1-or-later + - libgcc-ng >=12 + constrains: + - jpeg <0.0.0a + license: IJG AND BSD-3-Clause AND Zlib purls: [] - size: 38584 - timestamp: 1723627022409 -- kind: conda - name: libjpeg-turbo - version: 3.0.0 - build: hb547adb_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libjpeg-turbo-3.0.0-hb547adb_1.conda + size: 618575 + timestamp: 1694474974816 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libjpeg-turbo-3.0.0-hb547adb_1.conda sha256: a42054eaa38e84fc1e5ab443facac4bbc9d1b6b6f23f54b7bf4f1eb687e1d993 md5: 3ff1e053dc3a2b8e36b9bfa4256a58d1 constrains: @@ -9512,110 +9118,67 @@ packages: purls: [] size: 547541 timestamp: 1694475104253 -- kind: conda - name: libjpeg-turbo - version: 3.0.0 - build: hd590300_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.0.0-hd590300_1.conda - sha256: b954e09b7e49c2f2433d6f3bb73868eda5e378278b0f8c1dd10a7ef090e14f2f - md5: ea25936bb4080d843790b586850f82b8 +- conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-26_linux64_openblas.conda + build_number: 26 + sha256: b76458c36331376911e0f98fa68109e02f4d5e5ebfffa79587ac69cef748bba1 + md5: 3792604c43695d6a273bc5faaac47d48 depends: - - libgcc-ng >=12 - constrains: - - jpeg <0.0.0a - license: IJG AND BSD-3-Clause AND Zlib - purls: [] - size: 618575 - timestamp: 1694474974816 -- kind: conda - name: liblapack - version: 3.9.0 - build: 23_linux64_openblas - build_number: 23 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-23_linux64_openblas.conda - sha256: 25c7aef86c8a1d9db0e8ee61aa7462ba3b46b482027a65d66eb83e3e6f949043 - md5: 2af0879961951987e464722fd00ec1e0 - depends: - - libblas 3.9.0 23_linux64_openblas + - libblas 3.9.0 26_linux64_openblas constrains: - - liblapacke 3.9.0 23_linux64_openblas - - libcblas 3.9.0 23_linux64_openblas + - libcblas 3.9.0 26_linux64_openblas + - liblapacke 3.9.0 26_linux64_openblas - blas * openblas license: BSD-3-Clause license_family: BSD purls: [] - size: 14823 - timestamp: 1721688775172 -- kind: conda - name: liblapack - version: 3.9.0 - build: 23_osxarm64_openblas - build_number: 23 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-23_osxarm64_openblas.conda - sha256: 13799a137ffc80786725e7e2820d37d4c0d59dbb76013a14c21771415b0a4263 - md5: 754ef44f72ab80fd14eaa789ac393a27 - depends: - - libblas 3.9.0 23_osxarm64_openblas + size: 16338 + timestamp: 1734432576650 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-26_osxarm64_openblas.conda + build_number: 26 + sha256: dd6d9a21e672aee4332f019c8229ce70cf5eaf6c2f4cbd1443b105fb66c00dc5 + md5: cebad79038a75cfd28fa90d147a2d34d + depends: + - libblas 3.9.0 26_osxarm64_openblas constrains: + - liblapacke 3.9.0 26_osxarm64_openblas + - libcblas 3.9.0 26_osxarm64_openblas - blas * openblas - - liblapacke 3.9.0 23_osxarm64_openblas - - libcblas 3.9.0 23_osxarm64_openblas license: BSD-3-Clause license_family: BSD purls: [] - size: 14999 - timestamp: 1721689026268 -- kind: conda - name: liblapacke - version: 3.9.0 - build: 23_linux64_openblas - build_number: 23 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/liblapacke-3.9.0-23_linux64_openblas.conda - sha256: 071384c9023997abc53111ec4dd71c27d68cb355b0a5c684f7cb7ba90a5ae830 - md5: 89d7bcdb1e9a72a73e36d8e29d2a2beb - depends: - - libblas 3.9.0 23_linux64_openblas - - libcblas 3.9.0 23_linux64_openblas - - liblapack 3.9.0 23_linux64_openblas + size: 16624 + timestamp: 1734433068120 +- conda: https://conda.anaconda.org/conda-forge/linux-64/liblapacke-3.9.0-26_linux64_openblas.conda + build_number: 26 + sha256: 90807199c20500d959cc37ca666f74286b20637d9d1de53cb0730802ed459c9a + md5: 7b8b7732fb4786c00cf9b67d1d69445c + depends: + - libblas 3.9.0 26_linux64_openblas + - libcblas 3.9.0 26_linux64_openblas + - liblapack 3.9.0 26_linux64_openblas constrains: - blas * openblas license: BSD-3-Clause license_family: BSD purls: [] - size: 14831 - timestamp: 1721688782834 -- kind: conda - name: liblapacke - version: 3.9.0 - build: 23_osxarm64_openblas - build_number: 23 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/liblapacke-3.9.0-23_osxarm64_openblas.conda - sha256: 22444840b0fb88db268dd526e2852eabf0c025718e3550056b1eb47d68ab1afd - md5: 9f9411f6b0296f39737433efe99ba1a2 - depends: - - libblas 3.9.0 23_osxarm64_openblas - - libcblas 3.9.0 23_osxarm64_openblas - - liblapack 3.9.0 23_osxarm64_openblas + size: 16332 + timestamp: 1734432582792 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapacke-3.9.0-26_osxarm64_openblas.conda + build_number: 26 + sha256: f81ec3a29ca0c373e380fe4070008027e1006b0e4e084240bb37a50747ea1ab1 + md5: d1214450bafaf193f2bc5696e673d8d4 + depends: + - libblas 3.9.0 26_osxarm64_openblas + - libcblas 3.9.0 26_osxarm64_openblas + - liblapack 3.9.0 26_osxarm64_openblas constrains: - blas * openblas license: BSD-3-Clause license_family: BSD purls: [] - size: 14963 - timestamp: 1721689034740 -- kind: conda - name: libllvm18 - version: 18.1.8 - build: h8b73ec9_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libllvm18-18.1.8-h8b73ec9_2.conda + size: 16642 + timestamp: 1734433074754 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm18-18.1.8-h8b73ec9_2.conda sha256: 41993f35731d8f24e4f91f9318d6d68a3cfc4b5cf5d54f193fbb3ffd246bf2b7 md5: 2e25bb2f53e4a48873a936f8ef53e592 depends: @@ -9630,13 +9193,94 @@ packages: purls: [] size: 38233031 timestamp: 1723208627477 -- kind: conda - name: libmagma - version: 2.7.2 - build: h173bb3b_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libmagma-2.7.2-h173bb3b_2.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm19-19.1.2-ha7bfdaf_0.conda + sha256: 8c0eb8f753ef2a449acd846bc5853f7f11d319819bb5bbdf721c8ac0d8db875a + md5: 128e74a4f8f4fef4dc5130a8bbccc15d + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + - libxml2 >=2.12.7,<3.0a0 + - libzlib >=1.3.1,<2.0a0 + - zstd >=1.5.6,<1.6.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + purls: + - pkg:pypi/libllvm19 + size: 40136241 + timestamp: 1729031844469 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm19-19.1.6-ha7bfdaf_0.conda + sha256: 1d9d4657179d74dcbd429a17555e13c9e1253cc7c9aa1244cf5c5bca2cb46c25 + md5: ec6abc65eefc96cba8443b2716dcc43b + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + - libxml2 >=2.13.5,<3.0a0 + - libzlib >=1.3.1,<2.0a0 + - zstd >=1.5.6,<1.6.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + purls: + - pkg:pypi/libllvm19 + size: 40121731 + timestamp: 1734486321896 +- conda: https://conda.anaconda.org/conda-forge/linux-64/liblzf-3.6-hb9d3cd8_3.conda + sha256: f4a4c1a0945dc97e22ddf495cbd38bc230b76a5fe6cec9f54ba0b00960329fb5 + md5: 5fff3766d959c2a6fd424ad325602383 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 18687 + timestamp: 1728095215498 +- conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.6.3-hb9d3cd8_1.conda + sha256: e6e425252f3839e2756e4af1ea2074dffd3396c161bf460629f9dfd6a65f15c6 + md5: 2ecf2f1c7e4e21fcfe6423a51a992d84 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + license: 0BSD + purls: + - pkg:pypi/liblzma + size: 111132 + timestamp: 1733407410083 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.6.3-h39f12f2_1.conda + sha256: d863b8257406918ffdc50ae65502f2b2d6cede29404d09a094f59509d6a0aaf1 + md5: b2553114a7f5e20ccd02378a77d836aa + depends: + - __osx >=11.0 + license: 0BSD + purls: + - pkg:pypi/liblzma + size: 99129 + timestamp: 1733407496073 +- conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-devel-5.6.3-hb9d3cd8_1.conda + sha256: ca17f037a0a7137874597866a171166677e4812a9a8a853007f0f582e3ff6d1d + md5: cc4687e1814ed459f3bd6d8e05251ab2 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - liblzma 5.6.3 hb9d3cd8_1 + license: 0BSD + purls: + - pkg:pypi/liblzma-devel + size: 376794 + timestamp: 1733407421190 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-devel-5.6.3-h39f12f2_1.conda + sha256: c785d43d4758e18153b502c7d7d3a9181f3c95b2ae64a389fe49af5bf3a53f05 + md5: 692ccac07529215d42c051c6a60bc5a5 + depends: + - __osx >=11.0 + - liblzma 5.6.3 h39f12f2_1 + license: 0BSD + purls: + - pkg:pypi/liblzma-devel + size: 113099 + timestamp: 1733407511832 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libmagma-2.7.2-h173bb3b_2.conda sha256: 02bee6d6412c1f1d010ad4feaefee6020088233df31b0ad1a972ee7f2bce7d53 md5: c21393bb780150d5a269e7158802e5dc depends: @@ -9654,13 +9298,7 @@ packages: purls: [] size: 241078898 timestamp: 1702608570218 -- kind: conda - name: libmagma_sparse - version: 2.7.2 - build: h173bb3b_3 - build_number: 3 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libmagma_sparse-2.7.2-h173bb3b_3.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/libmagma_sparse-2.7.2-h173bb3b_3.conda sha256: 4a4405e99335d8863340ffde31e9c582f953b5610f28ffcce2b674085bb866f5 md5: 59b4f8f84e04330824aff4a281777857 depends: @@ -9680,13 +9318,18 @@ packages: purls: [] size: 6751069 timestamp: 1710285801797 -- kind: conda - name: libmicrohttpd - version: 1.0.1 - build: hbc5bc17_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libmicrohttpd-1.0.1-hbc5bc17_1.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/libmicrohttpd-1.0.1-h97afed2_0.conda + sha256: 8b93e0870b48fe452ba692b5c709e13fa526fee75524efe1dfe197838a99efa2 + md5: 00bd7406d24d6574f2de3839b60e0925 + depends: + - gnutls >=3.7.9,<3.8.0a0 + - libgcc-ng >=12 + license: LGPL-2.0-or-later + license_family: GPL + purls: [] + size: 257509 + timestamp: 1708719251842 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libmicrohttpd-1.0.1-hbc5bc17_1.conda sha256: 0aa6287ec8698090d09def3416c38e5975fd2b76cd24ff5dac97edcdd6e1fbd4 md5: c384e4dcd3c345b54bfb79d9ff712349 depends: @@ -9698,93 +9341,90 @@ packages: purls: [] size: 258095 timestamp: 1724050165443 -- kind: conda - name: libnghttp2 - version: 1.58.0 - build: h47da74e_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.58.0-h47da74e_1.conda - sha256: 1910c5306c6aa5bcbd623c3c930c440e9c77a5a019008e1487810e3c1d3716cb - md5: 700ac6ea6d53d5510591c4344d5c989a +- conda: https://conda.anaconda.org/conda-forge/linux-64/libnetcdf-4.9.2-nompi_h135f659_114.conda + sha256: 055572a4c8a1c3f9ac60071ee678f5ea49cfd7ac60a636d817988a6f9d6de6ae + md5: a908e463c710bd6b10a9eaa89fdf003c depends: - - c-ares >=1.23.0,<2.0a0 - - libev >=4.33,<4.34.0a0 - - libev >=4.33,<5.0a0 + - blosc >=1.21.5,<2.0a0 + - bzip2 >=1.0.8,<2.0a0 + - hdf4 >=4.2.15,<4.2.16.0a0 + - hdf5 >=1.14.3,<1.14.4.0a0 + - libaec >=1.1.3,<2.0a0 + - libcurl >=8.8.0,<9.0a0 - libgcc-ng >=12 - libstdcxx-ng >=12 - - libzlib >=1.2.13,<2.0.0a0 - - openssl >=3.2.0,<4.0a0 + - libxml2 >=2.12.7,<3.0a0 + - libzip >=1.10.1,<2.0a0 + - libzlib >=1.2.13,<2.0a0 + - openssl >=3.3.1,<4.0a0 + - zlib + - zstd >=1.5.6,<1.6.0a0 license: MIT license_family: MIT purls: [] - size: 631936 - timestamp: 1702130036271 -- kind: conda - name: libnghttp2 - version: 1.58.0 - build: ha4dd798_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.58.0-ha4dd798_1.conda - sha256: fc97aaaf0c6d0f508be313d86c2705b490998d382560df24be918b8e977802cd - md5: 1813e066bfcef82de579a0be8a766df4 - depends: - - __osx >=10.9 - - c-ares >=1.23.0,<2.0a0 - - libcxx >=16.0.6 + size: 849172 + timestamp: 1717671645362 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.64.0-h161d5f1_0.conda + sha256: b0f2b3695b13a989f75d8fd7f4778e1c7aabe3b36db83f0fe80b2cd812c0e975 + md5: 19e57602824042dfd0446292ef90488b + depends: + - __glibc >=2.17,<3.0.a0 + - c-ares >=1.32.3,<2.0a0 - libev >=4.33,<4.34.0a0 - libev >=4.33,<5.0a0 - - libzlib >=1.2.13,<2.0.0a0 - - openssl >=3.2.0,<4.0a0 + - libgcc >=13 + - libstdcxx >=13 + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.3.2,<4.0a0 + license: MIT + license_family: MIT + purls: [] + size: 647599 + timestamp: 1729571887612 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.64.0-h6d7220d_0.conda + sha256: 00cc685824f39f51be5233b54e19f45abd60de5d8847f1a56906f8936648b72f + md5: 3408c02539cee5f1141f9f11450b6a51 + depends: + - __osx >=11.0 + - c-ares >=1.34.2,<2.0a0 + - libcxx >=17 + - libev >=4.33,<4.34.0a0 + - libev >=4.33,<5.0a0 + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.3.2,<4.0a0 license: MIT license_family: MIT purls: [] - size: 565451 - timestamp: 1702130473930 -- kind: conda - name: libnpp - version: 12.3.1.54 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libnpp-12.3.1.54-h5888daf_0.conda - sha256: b533050ab7f294a5f82e8438f45fdfa9d56ffd32e0e03288f95b116a890fdf8c - md5: f1c723a97c4c8f82429df5a7b9b96382 + size: 566719 + timestamp: 1729572385640 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libnpp-12.3.0.116-he02047a_0.conda + sha256: 548d0c5f4d23a31c5984255815e3be8860ec86460bce1f73d33ccfc8e36badef + md5: f019cad715f7656ff90a4b544884272e depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 97901519 - timestamp: 1724958141776 -- kind: conda - name: libnpp-dev - version: 12.3.1.54 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libnpp-dev-12.3.1.54-h5888daf_0.conda - sha256: 03ed70464cfe69a24bad071abf21becf33fb33cbf212b120dbb45ed4e71fa984 - md5: 37c3d406ec286cfae716868c2915026c + size: 99562073 + timestamp: 1716320150279 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libnpp-dev-12.3.0.116-he02047a_0.conda + sha256: 0a431e6a257efa05e6637cf00f0955e52cee63007d42ca7c351f3e4b12fcca35 + md5: fc4dd4e516d275029857658f25dd272e depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libnpp 12.3.1.54 h5888daf_0 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libnpp 12.3.0.116 he02047a_0 + - libstdcxx-ng >=12 constrains: - - libnpp-static >=12.3.1.54 + - libnpp-static >=12.3.0.116 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 451697 - timestamp: 1724958320192 -- kind: conda - name: libnsl - version: 2.0.1 - build: hd590300_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hd590300_0.conda + size: 470648 + timestamp: 1716320345051 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hd590300_0.conda sha256: 26d77a3bb4dceeedc2a41bd688564fe71bf2d149fdcf117049970bc02ff1add6 md5: 30fd6e37fe21f86f4bd26d6ee73eeec7 depends: @@ -9794,250 +9434,219 @@ packages: purls: [] size: 33408 timestamp: 1697359010159 -- kind: conda - name: libnvfatbin - version: 12.6.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libnvfatbin-12.6.68-h5888daf_0.conda - sha256: ebf2522124e1a4869fa3f6e1b6d5952cec4f11095329fd24fc6903cb4f449bbf - md5: 42ce7f4f68263f033daf089594e6a169 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libntlm-1.4-h7f98852_1002.tar.bz2 + sha256: 63244b73156033ea3b7c2a1581526e79b4670349d64b15f645dcdb12de441d1a + md5: e728e874159b042d92b90238a3cb0dc2 + depends: + - libgcc-ng >=9.3.0 + license: LGPL-2.1-or-later + purls: [] + size: 33201 + timestamp: 1609781914458 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libnvfatbin-12.5.39-he02047a_0.conda + sha256: c650f22346e4bf51c7a732ba443f15bb74a16566e7f517fec5385f7edf2566b6 + md5: 44bba65a136710d7b188d0003a6602e8 depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 801740 - timestamp: 1724958116328 -- kind: conda - name: libnvfatbin-dev - version: 12.6.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libnvfatbin-dev-12.6.68-h5888daf_0.conda - sha256: 93e4da6296b545b2f62aecbf5b3e1cd50deb410c6ad71804da4ef3169dc01166 - md5: 1be8383b1494c1617d0048533bcd5dd4 + size: 801497 + timestamp: 1716319856018 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libnvfatbin-dev-12.5.39-he02047a_0.conda + sha256: 73ea5faf2f8d1f315de9cfac23cc8a38c6493c26a4f765a59f0e443388079898 + md5: dec3b503865da7f9441a0bb0ead158b2 depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libnvfatbin 12.6.68 h5888daf_0 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libnvfatbin 12.5.39 he02047a_0 + - libstdcxx-ng >=12 constrains: - - liblibnvfatbin-static >=12.6.68 + - liblibnvfatbin-static >=12.5.39 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 26191 - timestamp: 1724958132547 -- kind: conda - name: libnvjitlink - version: 12.6.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libnvjitlink-12.6.68-h5888daf_0.conda - sha256: 2e52bbcd8d31f46e878bb43d437e646643ac24ee3e675cca98a16ea78671b9e2 - md5: c9859a923e50c538e2b06f9ce8898ce9 + size: 26392 + timestamp: 1716319890540 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libnvjitlink-12.5.40-he02047a_0.conda + sha256: b17d0f44d4f11133048e874f992085ac2b6c2d3d8406b33d3fa855bdd5745855 + md5: 7bab371da1232dc97962f8cc632c77dc depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 15599585 - timestamp: 1724958549847 -- kind: conda - name: libnvjitlink-dev - version: 12.6.68 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libnvjitlink-dev-12.6.68-h5888daf_0.conda - sha256: dc04efc50be33e8839939fdcfafac4a68286ebec868d6f15fcd3a067c297da6e - md5: 127b53d8bc2e2bcec967f1b2238d1f38 + size: 16769398 + timestamp: 1716320188803 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libnvjitlink-dev-12.5.40-he02047a_0.conda + sha256: 2fff1d3c0c8820fb6a65a38e5d214ee4de32cf3a8baeb899e4901100d5729a1d + md5: a0b509ab95df6fb80b516f29d53d7faa depends: - - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libnvjitlink 12.6.68 h5888daf_0 - - libstdcxx >=13 + - __glibc >=2.17,<3.0.a0 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libnvjitlink 12.5.40 he02047a_0 + - libstdcxx-ng >=12 constrains: - - libnvjitlink-static >=12.6.68 + - libnvjitlink-static >=12.5.40 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 25739 - timestamp: 1724958630774 -- kind: conda - name: libnvjpeg - version: 12.3.3.54 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libnvjpeg-12.3.3.54-h5888daf_0.conda - sha256: 6697036f462cce63f15b98104348228e60e33301d805a097720b6d2b05e9dfa7 - md5: 56a2750239be4499dd6c9a27cebfb4b4 + size: 25701 + timestamp: 1716320291190 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libnvjpeg-12.3.2.38-he02047a_0.conda + sha256: 70a07dddd378120f34f014d860f9173599775bfb2f9b56d752dbe93ab0f3d332 + md5: a1ade0ecd43845f191b48de39e86d7cc depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.6,<12.7.0a0 - - libgcc >=13 - - libstdcxx >=13 + - cuda-version >=12.5,<12.6.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 2491046 - timestamp: 1724960283705 -- kind: conda - name: libnvjpeg-dev - version: 12.3.3.54 - build: ha770c72_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libnvjpeg-dev-12.3.3.54-ha770c72_0.conda - sha256: ee6bdd0936aa066f44fc5d469e9c88c30dcf1063cfe97287b7d1291563c774fb - md5: 38ab71f4fadbd66e9421a6b62342ad69 + size: 2497104 + timestamp: 1716400070489 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libnvjpeg-dev-12.3.2.38-ha770c72_0.conda + sha256: 8afb8a421e16730f5a6c65905106942c6c1686757cd52bef654a764838de515d + md5: 1b472f1060ec9bbc23a4ad91ea6188c0 depends: - cuda-cudart-dev - - cuda-version >=12.6,<12.7.0a0 - - libnvjpeg 12.3.3.54 h5888daf_0 + - cuda-version >=12.5,<12.6.0a0 + - libnvjpeg 12.3.2.38 he02047a_0 constrains: - - libnvjpeg-static >=12.3.3.54 + - libnvjpeg-static >=12.3.2.38 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 31824 - timestamp: 1724960295229 -- kind: conda - name: libopenblas - version: 0.3.27 - build: openmp_h517c56d_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.27-openmp_h517c56d_1.conda - sha256: 46cfcc592b5255262f567cd098be3c61da6bca6c24d640e878dc8342b0f6d069 - md5: 71b8a34d70aa567a990162f327e81505 + size: 32304 + timestamp: 1716400097877 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libogg-1.3.5-h4ab18f5_0.conda + sha256: 5eda3fe92b99b25dd4737226a9485078ab405672d9f621be75edcb68f1e9026d + md5: 601bfb4b3c6f0b844443bb81a56651e0 depends: - - __osx >=11.0 - - libgfortran 5.* - - libgfortran5 >=12.3.0 - - llvm-openmp >=16.0.6 - constrains: - - openblas >=0.3.27,<0.3.28.0a0 + - libgcc-ng >=12 license: BSD-3-Clause license_family: BSD purls: [] - size: 2925328 - timestamp: 1720425811743 -- kind: conda - name: libopenblas - version: 0.3.27 - build: pthreads_hac2b453_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.27-pthreads_hac2b453_1.conda - sha256: 714cb82d7c4620ea2635a92d3df263ab841676c9b183d0c01992767bb2451c39 - md5: ae05ece66d3924ac3d48b4aa3fa96cec + size: 205914 + timestamp: 1719301575771 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.28-pthreads_h94d23a6_1.conda + sha256: 99ba271d8a80a1af2723f2e124ffd91d850074c0389c067e6d96d72a2dbfeabe + md5: 62857b389e42b36b686331bec0922050 depends: - - libgcc-ng >=12 - - libgfortran-ng - - libgfortran5 >=12.3.0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libgfortran + - libgfortran5 >=14.2.0 constrains: - - openblas >=0.3.27,<0.3.28.0a0 + - openblas >=0.3.28,<0.3.29.0a0 license: BSD-3-Clause license_family: BSD purls: [] - size: 5563053 - timestamp: 1720426334043 -- kind: conda - name: libopencv - version: 4.10.0 - build: headless_py312h7bc6ef4_3 - build_number: 3 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libopencv-4.10.0-headless_py312h7bc6ef4_3.conda - sha256: e459c07aad5504219d84dc85b5424ef79d3d1c501d6fd1bd8e3f95374083cffe - md5: 3326a89908c2e00e29224c7b1b573d0d + size: 5578513 + timestamp: 1730772671118 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.28-openmp_hf332438_1.conda + sha256: 62bb669c37a845129096f73d446cdb6bb170e4927f2fea2b661329680dbbc373 + md5: 40803a48d947c8639da6704e9a44d3ce depends: - __osx >=11.0 - - ffmpeg >=6.1.2,<7.0a0 + - libgfortran 5.* + - libgfortran5 >=13.2.0 + - llvm-openmp >=18.1.8 + constrains: + - openblas >=0.3.28,<0.3.29.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 4165774 + timestamp: 1730772154295 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopencv-4.10.0-qt6_py312h01efb12_604.conda + sha256: 225ab5671f54cb7a26b9d6c363b38d8008e9877de0d7711a7ad4e86f595b8f97 + md5: cdd893396d2c2ea91a87d269fbe2ae5e + depends: + - __glibc >=2.17,<3.0.a0 + - _openmp_mutex >=4.5 + - ffmpeg >=7.0.2,<8.0a0 - freetype >=2.12.1,<3.0a0 - harfbuzz >=9.0.0,<10.0a0 - hdf5 >=1.14.3,<1.14.4.0a0 - jasper >=4.2.4,<5.0a0 - libasprintf >=0.22.5,<1.0a0 - libcblas >=3.9.0,<4.0a0 - - libcxx >=16 + - libgcc >=13 - libgettextpo >=0.22.5,<1.0a0 - libglib >=2.80.3,<3.0a0 - libiconv >=1.17,<2.0a0 - - libintl >=0.22.5,<1.0a0 - libjpeg-turbo >=3.0.0,<4.0a0 - liblapack >=3.9.0,<4.0a0 - liblapacke >=3.9.0,<4.0a0 - - libopenvino >=2024.3.0,<2024.3.1.0a0 - - libopenvino-arm-cpu-plugin >=2024.3.0,<2024.3.1.0a0 - - libopenvino-auto-batch-plugin >=2024.3.0,<2024.3.1.0a0 - - libopenvino-auto-plugin >=2024.3.0,<2024.3.1.0a0 - - libopenvino-hetero-plugin >=2024.3.0,<2024.3.1.0a0 - - libopenvino-ir-frontend >=2024.3.0,<2024.3.1.0a0 - - libopenvino-onnx-frontend >=2024.3.0,<2024.3.1.0a0 - - libopenvino-paddle-frontend >=2024.3.0,<2024.3.1.0a0 - - libopenvino-pytorch-frontend >=2024.3.0,<2024.3.1.0a0 - - libopenvino-tensorflow-frontend >=2024.3.0,<2024.3.1.0a0 - - libopenvino-tensorflow-lite-frontend >=2024.3.0,<2024.3.1.0a0 - - libpng >=1.6.43,<1.7.0a0 + - libopenvino >=2024.4.0,<2024.4.1.0a0 + - libopenvino-auto-batch-plugin >=2024.4.0,<2024.4.1.0a0 + - libopenvino-auto-plugin >=2024.4.0,<2024.4.1.0a0 + - libopenvino-hetero-plugin >=2024.4.0,<2024.4.1.0a0 + - libopenvino-intel-cpu-plugin >=2024.4.0,<2024.4.1.0a0 + - libopenvino-intel-gpu-plugin >=2024.4.0,<2024.4.1.0a0 + - libopenvino-intel-npu-plugin >=2024.4.0,<2024.4.1.0a0 + - libopenvino-ir-frontend >=2024.4.0,<2024.4.1.0a0 + - libopenvino-onnx-frontend >=2024.4.0,<2024.4.1.0a0 + - libopenvino-paddle-frontend >=2024.4.0,<2024.4.1.0a0 + - libopenvino-pytorch-frontend >=2024.4.0,<2024.4.1.0a0 + - libopenvino-tensorflow-frontend >=2024.4.0,<2024.4.1.0a0 + - libopenvino-tensorflow-lite-frontend >=2024.4.0,<2024.4.1.0a0 + - libpng >=1.6.44,<1.7.0a0 - libprotobuf >=4.25.3,<4.25.4.0a0 - - libtiff >=4.6.0,<4.7.0a0 + - libstdcxx >=13 + - libtiff >=4.7.0,<4.8.0a0 - libwebp-base >=1.4.0,<2.0a0 - libzlib >=1.3.1,<2.0a0 - numpy >=1.19,<3 - openexr >=3.2.2,<3.3.0a0 - - python >=3.12,<3.13.0a0 *_cpython + - qt6-main >=6.7.2,<6.8.0a0 license: Apache-2.0 license_family: Apache purls: - pkg:pypi/opencv-python?source=project-defined-mapping - size: 21816750 - timestamp: 1723437420883 -- kind: conda - name: libopencv - version: 4.10.0 - build: qt6_py312h6ebf6f7_603 - build_number: 603 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libopencv-4.10.0-qt6_py312h6ebf6f7_603.conda - sha256: 1236cf0a8087822475ad773dbe5c06ff77312e11c1e75e86e4b69cddbbf76a7c - md5: ec62936b199ec07a713c6b7f9c0f76f3 + size: 30825773 + timestamp: 1726969093815 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopencv-4.10.0-qt6_py312h131ea51_601.conda + sha256: 1c87e9c6fa7153cbe86308b770a834eb06ba3bd3dba685cda955f0a5a359724f + md5: 096c82ac3dba3010a99b04b2c11f6edd depends: - __glibc >=2.17,<3.0.a0 - _openmp_mutex >=4.5 - - ffmpeg >=6.1.2,<7.0a0 + - ffmpeg >=6.1.1,<7.0a0 - freetype >=2.12.1,<3.0a0 - - harfbuzz >=9.0.0,<10.0a0 + - harfbuzz >=8.5.0,<9.0a0 - hdf5 >=1.14.3,<1.14.4.0a0 - jasper >=4.2.4,<5.0a0 - libasprintf >=0.22.5,<1.0a0 - libcblas >=3.9.0,<4.0a0 - libgcc-ng >=12 - libgettextpo >=0.22.5,<1.0a0 - - libglib >=2.80.3,<3.0a0 + - libglib >=2.80.2,<3.0a0 - libiconv >=1.17,<2.0a0 - libjpeg-turbo >=3.0.0,<4.0a0 - liblapack >=3.9.0,<4.0a0 - liblapacke >=3.9.0,<4.0a0 - - libopenvino >=2024.3.0,<2024.3.1.0a0 - - libopenvino-auto-batch-plugin >=2024.3.0,<2024.3.1.0a0 - - libopenvino-auto-plugin >=2024.3.0,<2024.3.1.0a0 - - libopenvino-hetero-plugin >=2024.3.0,<2024.3.1.0a0 - - libopenvino-intel-cpu-plugin >=2024.3.0,<2024.3.1.0a0 - - libopenvino-intel-gpu-plugin >=2024.3.0,<2024.3.1.0a0 - - libopenvino-intel-npu-plugin >=2024.3.0,<2024.3.1.0a0 - - libopenvino-ir-frontend >=2024.3.0,<2024.3.1.0a0 - - libopenvino-onnx-frontend >=2024.3.0,<2024.3.1.0a0 - - libopenvino-paddle-frontend >=2024.3.0,<2024.3.1.0a0 - - libopenvino-pytorch-frontend >=2024.3.0,<2024.3.1.0a0 - - libopenvino-tensorflow-frontend >=2024.3.0,<2024.3.1.0a0 - - libopenvino-tensorflow-lite-frontend >=2024.3.0,<2024.3.1.0a0 + - libopenvino >=2024.2.0,<2024.2.1.0a0 + - libopenvino-auto-batch-plugin >=2024.2.0,<2024.2.1.0a0 + - libopenvino-auto-plugin >=2024.2.0,<2024.2.1.0a0 + - libopenvino-hetero-plugin >=2024.2.0,<2024.2.1.0a0 + - libopenvino-intel-cpu-plugin >=2024.2.0,<2024.2.1.0a0 + - libopenvino-intel-gpu-plugin >=2024.2.0,<2024.2.1.0a0 + - libopenvino-intel-npu-plugin >=2024.2.0,<2024.2.1.0a0 + - libopenvino-ir-frontend >=2024.2.0,<2024.2.1.0a0 + - libopenvino-onnx-frontend >=2024.2.0,<2024.2.1.0a0 + - libopenvino-paddle-frontend >=2024.2.0,<2024.2.1.0a0 + - libopenvino-pytorch-frontend >=2024.2.0,<2024.2.1.0a0 + - libopenvino-tensorflow-frontend >=2024.2.0,<2024.2.1.0a0 + - libopenvino-tensorflow-lite-frontend >=2024.2.0,<2024.2.1.0a0 - libpng >=1.6.43,<1.7.0a0 - libprotobuf >=4.25.3,<4.25.4.0a0 - libstdcxx-ng >=12 - - libtiff >=4.6.0,<4.7.0a0 + - libtiff >=4.6.0,<4.8.0a0 - libwebp-base >=1.4.0,<2.0a0 - libzlib >=1.3.1,<2.0a0 - numpy >=1.19,<3 @@ -10047,16 +9656,76 @@ packages: license_family: Apache purls: - pkg:pypi/opencv-python?source=project-defined-mapping - size: 30358816 - timestamp: 1723433882910 -- kind: conda - name: libopenvino - version: 2024.3.0 - build: h2da1b83_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-2024.3.0-h2da1b83_0.conda - sha256: cb36e07337df16731b6aeb52422e4f37748d785d2d0ff425c0a06300ce2aeb64 - md5: bb7a2589859c7475e38c1af677e16698 + size: 30544819 + timestamp: 1718896722864 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopencv-4.10.0-headless_py312haa779ad_6.conda + sha256: 50c0fcdcb3806e44cceea0121d358bb6aeaa10a65da742fda5089549320bcd1a + md5: fc836d17a9db57cca90aca3c8636096c + depends: + - __osx >=11.0 + - ffmpeg >=6.1.2,<7.0a0 + - freetype >=2.12.1,<3.0a0 + - harfbuzz >=9.0.0,<10.0a0 + - hdf5 >=1.14.3,<1.14.4.0a0 + - jasper >=4.2.4,<5.0a0 + - libasprintf >=0.22.5,<1.0a0 + - libcblas >=3.9.0,<4.0a0 + - libcxx >=17 + - libgettextpo >=0.22.5,<1.0a0 + - libglib >=2.82.1,<3.0a0 + - libiconv >=1.17,<2.0a0 + - libintl >=0.22.5,<1.0a0 + - libjpeg-turbo >=3.0.0,<4.0a0 + - liblapack >=3.9.0,<4.0a0 + - liblapacke >=3.9.0,<4.0a0 + - libopenvino >=2024.4.0,<2024.4.1.0a0 + - libopenvino-arm-cpu-plugin >=2024.4.0,<2024.4.1.0a0 + - libopenvino-auto-batch-plugin >=2024.4.0,<2024.4.1.0a0 + - libopenvino-auto-plugin >=2024.4.0,<2024.4.1.0a0 + - libopenvino-hetero-plugin >=2024.4.0,<2024.4.1.0a0 + - libopenvino-ir-frontend >=2024.4.0,<2024.4.1.0a0 + - libopenvino-onnx-frontend >=2024.4.0,<2024.4.1.0a0 + - libopenvino-paddle-frontend >=2024.4.0,<2024.4.1.0a0 + - libopenvino-pytorch-frontend >=2024.4.0,<2024.4.1.0a0 + - libopenvino-tensorflow-frontend >=2024.4.0,<2024.4.1.0a0 + - libopenvino-tensorflow-lite-frontend >=2024.4.0,<2024.4.1.0a0 + - libpng >=1.6.44,<1.7.0a0 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - libtiff >=4.7.0,<4.8.0a0 + - libwebp-base >=1.4.0,<2.0a0 + - libzlib >=1.3.1,<2.0a0 + - numpy >=1.19,<3 + - openexr >=3.2.2,<3.3.0a0 + - python >=3.12,<3.13.0a0 *_cpython + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/opencv-python?source=project-defined-mapping + size: 21798408 + timestamp: 1727651523445 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopengl-1.7.0-ha4b6fd6_0.conda + sha256: 6807eff238bbd19680184aad70c90c9c14824fca8b52b791b6669e37e0e963a7 + md5: 8e5037cbb79e56e4eba250cba7fcc784 + depends: + - __glibc >=2.17,<3.0.a0 + - libglvnd 1.7.0 ha4b6fd6_0 + license: LicenseRef-libglvnd + purls: [] + size: 50785 + timestamp: 1723473212137 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopengl-1.7.0-ha4b6fd6_2.conda + sha256: 215086c108d80349e96051ad14131b751d17af3ed2cb5a34edd62fa89bfe8ead + md5: 7df50d44d4a14d6c31a2c54f2cd92157 + depends: + - __glibc >=2.17,<3.0.a0 + - libglvnd 1.7.0 ha4b6fd6_2 + license: LicenseRef-libglvnd + purls: [] + size: 50757 + timestamp: 1731330993524 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-2024.2.0-h2da1b83_1.conda + sha256: 32ce474983e78acb8636e580764e3d28899a7b0a2a61a538677e9bca09e95415 + md5: 9511859bf5221238a2d3fb5322af01d5 depends: - __glibc >=2.17,<3.0.a0 - libgcc-ng >=12 @@ -10064,416 +9733,440 @@ packages: - pugixml >=1.14,<1.15.0a0 - tbb >=2021.12.0 purls: [] - size: 5329666 - timestamp: 1722425597194 -- kind: conda - name: libopenvino - version: 2024.3.0 - build: h5c9529b_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-2024.3.0-h5c9529b_0.conda - sha256: ae2ac78dc10c73874a8275e448a33a8a626e1c0220f8296bc605404a32927127 - md5: 3aafc8cfe563f97c2e41e6cf6e709331 + size: 5191832 + timestamp: 1718739293583 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-2024.4.0-hac27bb2_0.conda + sha256: 34579cc1ce59efe1560d17e6ec86fe07936b10858d2883f3a66f2bb496163a1b + md5: a9048b1af0374fe0b5fa4c25bb8d22ca + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + - pugixml >=1.14,<1.15.0a0 + - tbb >=2021.13.0 + purls: [] + size: 5360769 + timestamp: 1726766179227 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-2024.4.0-h49f535f_0.conda + sha256: 8d1b6b64de14bcca8a540f8879e7d67918de06d277b56b1d033fd8dbac9bbd89 + md5: 5eb7eb6eb1bfac1c0aa217580b08a91a depends: - __osx >=11.0 - - libcxx >=16 + - libcxx >=17 - pugixml >=1.14,<1.15.0a0 - - tbb >=2021.12.0 + - tbb >=2021.13.0 purls: [] - size: 3852725 - timestamp: 1722423268736 -- kind: conda - name: libopenvino-arm-cpu-plugin - version: 2024.3.0 - build: h5c9529b_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-arm-cpu-plugin-2024.3.0-h5c9529b_0.conda - sha256: c2408237e453194ac3c3e73236fd5c9f19336348d4451608278aca224ddde578 - md5: bd9e9fdb80863f99d3d24d5cc5c4a6ee + size: 3942341 + timestamp: 1726763749725 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-arm-cpu-plugin-2024.4.0-h49f535f_0.conda + sha256: a1670c8c5554d6152d09e238ea713917795358255c44e1ffd630fde887d20ab5 + md5: 4465615ce019e1185853f333dceb0cd5 depends: - __osx >=11.0 - - libcxx >=16 - - libopenvino 2024.3.0 h5c9529b_0 + - libcxx >=17 + - libopenvino 2024.4.0 h49f535f_0 - pugixml >=1.14,<1.15.0a0 - - tbb >=2021.12.0 + - tbb >=2021.13.0 purls: [] - size: 6746180 - timestamp: 1722423313285 -- kind: conda - name: libopenvino-auto-batch-plugin - version: 2024.3.0 - build: hb045406_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-auto-batch-plugin-2024.3.0-hb045406_0.conda - sha256: 1dae17b5d4c512f38cd83d0a059a75c82cf2b7033a82ca6533750d81169a329a - md5: 2a18663e879095118cb851620b175436 + size: 7426860 + timestamp: 1726763782204 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-auto-batch-plugin-2024.2.0-hb045406_1.conda + sha256: 083e72464866b857ff272242f887b46a5527e20e41d292db55a4fa10aa0808c6 + md5: 70d82a64e6d07f4d6e07cae6b0bd4bd1 depends: - __glibc >=2.17,<3.0.a0 - libgcc-ng >=12 - - libopenvino 2024.3.0 h2da1b83_0 + - libopenvino 2024.2.0 h2da1b83_1 - libstdcxx-ng >=12 - tbb >=2021.12.0 purls: [] - size: 110353 - timestamp: 1722425618025 -- kind: conda - name: libopenvino-auto-batch-plugin - version: 2024.3.0 - build: hcd65546_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-auto-batch-plugin-2024.3.0-hcd65546_0.conda - sha256: ed6093256eed023c371382799d1ddf046a83a7ff4e8c6a8bed3eeccc8996b6af - md5: 8254f4afbad3d3b9810ed2d48208addf + size: 110040 + timestamp: 1718739326748 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-auto-batch-plugin-2024.4.0-h4d9b6c2_0.conda + sha256: 976a5e703d2d3f94daa3aa9c00a8f47c28b038d20f421bf21114abfd8e0cbf58 + md5: 52c847d170f613afb0841c5ec1f87b78 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libopenvino 2024.4.0 hac27bb2_0 + - libstdcxx >=13 + - tbb >=2021.13.0 + purls: [] + size: 110734 + timestamp: 1726766198969 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-auto-batch-plugin-2024.4.0-h8a2fcec_0.conda + sha256: 213726d6906f40afe8ac56defd1579fe3929890451a78b0ac176d87570bac02f + md5: 1fd5e82c211214234691ad9e8f20ac7e depends: - __osx >=11.0 - - libcxx >=16 - - libopenvino 2024.3.0 h5c9529b_0 - - tbb >=2021.12.0 + - libcxx >=17 + - libopenvino 2024.4.0 h49f535f_0 + - tbb >=2021.13.0 purls: [] - size: 102795 - timestamp: 1722423370742 -- kind: conda - name: libopenvino-auto-plugin - version: 2024.3.0 - build: hb045406_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-auto-plugin-2024.3.0-hb045406_0.conda - sha256: b90c8f048276265be71fa9fdfbf183916704495884b2ffcc9d45eda13c928dbe - md5: 45bf3996fcd0caf69a3dd63b7fc7cd9e + size: 103326 + timestamp: 1726763827379 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-auto-plugin-2024.2.0-hb045406_1.conda + sha256: db945b8a8d716d0c6f80cc5f07fd79692c8a941a9ee653aab6f7d2496f6f163b + md5: f1e2a8ded23cef03804c4edb2edfb986 depends: - __glibc >=2.17,<3.0.a0 - libgcc-ng >=12 - - libopenvino 2024.3.0 h2da1b83_0 + - libopenvino 2024.2.0 h2da1b83_1 - libstdcxx-ng >=12 - tbb >=2021.12.0 purls: [] - size: 231835 - timestamp: 1722425631536 -- kind: conda - name: libopenvino-auto-plugin - version: 2024.3.0 - build: hcd65546_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-auto-plugin-2024.3.0-hcd65546_0.conda - sha256: 1d3bf8bf4207cb4ecd0a08aefe5953b25bc6d108e8e5dbf5ee1b80b287b7bd1c - md5: de2e242d54befa6f43d0734b26a0c12c + size: 231603 + timestamp: 1718739339702 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-auto-plugin-2024.4.0-h4d9b6c2_0.conda + sha256: 605faab60844c8e044005dc80a4e18e3d6ca98c905d4e6065606a34220bcce0c + md5: f6335f9d947ba550ada90cf101b6232c + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libopenvino 2024.4.0 hac27bb2_0 + - libstdcxx >=13 + - tbb >=2021.13.0 + purls: [] + size: 236459 + timestamp: 1726766212555 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-auto-plugin-2024.4.0-h8a2fcec_0.conda + sha256: 24966b323787948507ee66ef36f6e90912781d20895c2a57c9c4c7d1e1792996 + md5: 9acf00ceff8360c68dc9769dbb9f9d86 depends: - __osx >=11.0 - - libcxx >=16 - - libopenvino 2024.3.0 h5c9529b_0 - - tbb >=2021.12.0 + - libcxx >=17 + - libopenvino 2024.4.0 h49f535f_0 + - tbb >=2021.13.0 purls: [] - size: 208182 - timestamp: 1722423393060 -- kind: conda - name: libopenvino-hetero-plugin - version: 2024.3.0 - build: h5c03a75_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-hetero-plugin-2024.3.0-h5c03a75_0.conda - sha256: bc357324849ec4d13fb9dcc328e0c776a59d49ca9fd4e5bef0c74c4874e93585 - md5: 030fd5b2ce0b19c2c4db10890e121970 + size: 210081 + timestamp: 1726763845506 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-hetero-plugin-2024.2.0-h5c03a75_1.conda + sha256: 6924426d9f88a54bfcc8aa2f5d9d7aeb69c839f308cd3b37aedc667157fc90f1 + md5: 95d2d3baaa1e456ef65c713a5d99b815 depends: - __glibc >=2.17,<3.0.a0 - libgcc-ng >=12 - - libopenvino 2024.3.0 h2da1b83_0 + - libopenvino 2024.2.0 h2da1b83_1 - libstdcxx-ng >=12 - pugixml >=1.14,<1.15.0a0 purls: [] - size: 192978 - timestamp: 1722425643471 -- kind: conda - name: libopenvino-hetero-plugin - version: 2024.3.0 - build: h88cb26a_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-hetero-plugin-2024.3.0-h88cb26a_0.conda - sha256: f632023cdc9917052e524a2e06b39caecffe3563cbe4169eed165b63e661a2a9 - md5: eb024db8221c7f3a0a2e790ecb7b83f5 + size: 192455 + timestamp: 1718739351249 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-hetero-plugin-2024.4.0-h3f63f65_0.conda + sha256: af9c55da6c25f921973c9001c8893d643ddad399c8da81342ff2033a297055be + md5: cc7f76fdcc00ecb9aab668b8c956cc8d + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libopenvino 2024.4.0 hac27bb2_0 + - libstdcxx >=13 + - pugixml >=1.14,<1.15.0a0 + purls: [] + size: 196759 + timestamp: 1726766222703 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-hetero-plugin-2024.4.0-h868cbb4_0.conda + sha256: 1256faa46d1283b0c3c9ad6f0a70aafa3d8431c1180fd12433ab958bd4c41436 + md5: c9098bbdcbaad391ba10ce81723ba186 depends: - __osx >=11.0 - - libcxx >=16 - - libopenvino 2024.3.0 h5c9529b_0 + - libcxx >=17 + - libopenvino 2024.4.0 h49f535f_0 - pugixml >=1.14,<1.15.0a0 purls: [] - size: 173035 - timestamp: 1722423413708 -- kind: conda - name: libopenvino-intel-cpu-plugin - version: 2024.3.0 - build: h2da1b83_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-cpu-plugin-2024.3.0-h2da1b83_0.conda - sha256: d01f012be1263688c5ee412b1fce86702c1e26d53f6bfb692c6c6faffd335318 - md5: 98d9fdbb32d375ba877166737430afc4 + size: 172816 + timestamp: 1726763863713 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-cpu-plugin-2024.2.0-h2da1b83_1.conda + sha256: f2a4f0705e56ad8e25e4b20929e74ab0c7d5867cd52f315510dff37ea6508c38 + md5: 9e49f87d8f99dc9724f52b3fac904106 depends: - __glibc >=2.17,<3.0.a0 - libgcc-ng >=12 - - libopenvino 2024.3.0 h2da1b83_0 + - libopenvino 2024.2.0 h2da1b83_1 - libstdcxx-ng >=12 - pugixml >=1.14,<1.15.0a0 - tbb >=2021.12.0 purls: [] - size: 11113833 - timestamp: 1722425655998 -- kind: conda - name: libopenvino-intel-gpu-plugin - version: 2024.3.0 - build: h2da1b83_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-gpu-plugin-2024.3.0-h2da1b83_0.conda - sha256: 1060bfed8fed0234224f2f8ed59a98af76d07b3776fc9076f551d3aaa0bc04a0 - md5: c0957603b82ec549c119f7103968c62d + size: 11128404 + timestamp: 1718739363353 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-cpu-plugin-2024.4.0-hac27bb2_0.conda + sha256: c8676331577475bd2602a898fed2d4855695723fbb602fa554b34873b694a7ed + md5: 9b47c0e151ce7e2b6169ab8e3d18f9d8 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libopenvino 2024.4.0 hac27bb2_0 + - libstdcxx >=13 + - pugixml >=1.14,<1.15.0a0 + - tbb >=2021.13.0 + purls: [] + size: 12103820 + timestamp: 1726766233576 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-gpu-plugin-2024.2.0-h2da1b83_1.conda + sha256: c15a90baed7c3ad46c51d2ec70087cc3fb947dbeaea7e4bc93f785e9d12af092 + md5: a9712fae44d01d906e228c49235e3b89 depends: - __glibc >=2.17,<3.0.a0 - libgcc-ng >=12 - - libopenvino 2024.3.0 h2da1b83_0 + - libopenvino 2024.2.0 h2da1b83_1 - libstdcxx-ng >=12 - ocl-icd >=2.3.2,<3.0a0 - pugixml >=1.14,<1.15.0a0 - tbb >=2021.12.0 purls: [] - size: 8727772 - timestamp: 1722425694121 -- kind: conda - name: libopenvino-intel-npu-plugin - version: 2024.3.0 - build: h2da1b83_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-npu-plugin-2024.3.0-h2da1b83_0.conda - sha256: 23fb63effe2a0a056288028771ea6eec6face768fc5480f8820ed55a75917d7e - md5: 81879bcb0d246113118ab274965f11be + size: 8546709 + timestamp: 1718739400593 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-gpu-plugin-2024.4.0-hac27bb2_0.conda + sha256: d37210cbcb345b95ffd246c9b04669beaa31740c57bf1e9ff131588dec2bbafa + md5: 5b85313c114e1e681b5878c4fbf640b3 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libopenvino 2024.4.0 hac27bb2_0 + - libstdcxx >=13 + - ocl-icd >=2.3.2,<3.0a0 + - pugixml >=1.14,<1.15.0a0 + - tbb >=2021.13.0 + purls: [] + size: 8891017 + timestamp: 1726766271595 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-npu-plugin-2024.2.0-he02047a_1.conda + sha256: c2f4f1685b3662b0f18f6647fe7a46a0c061f78e017e3d9815e326171f342ba6 + md5: 5c2d064181e686cf5cfac6f1a1ee4e91 depends: - __glibc >=2.17,<3.0.a0 - libgcc-ng >=12 - - libopenvino 2024.3.0 h2da1b83_0 + - libopenvino 2024.2.0 h2da1b83_1 - libstdcxx-ng >=12 + purls: [] + size: 343901 + timestamp: 1718739430333 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-npu-plugin-2024.4.0-hac27bb2_0.conda + sha256: bf74978afa331b27079f0973081c2a1cd3e12ebcee0cc1545b7e400770130879 + md5: 2f4a881f43dd916fe71be85848440584 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libopenvino 2024.4.0 hac27bb2_0 + - libstdcxx >=13 - pugixml >=1.14,<1.15.0a0 - - tbb >=2021.12.0 + - tbb >=2021.13.0 purls: [] - size: 712050 - timestamp: 1722425726425 -- kind: conda - name: libopenvino-ir-frontend - version: 2024.3.0 - build: h5c03a75_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-ir-frontend-2024.3.0-h5c03a75_0.conda - sha256: a0619f2b73a01c8b8220d376cae6b446bccb380a81134e228ee171a526e741d1 - md5: a512abca9b69f972671ff03f818b93f7 + size: 798313 + timestamp: 1726766301211 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-ir-frontend-2024.2.0-h5c03a75_1.conda + sha256: eb183fa65b43cc944ad3d1528cdb5c533d3b4ccdd8ed44612e2c89f962a020ce + md5: 89addf0fc0f489fa0c076f1c8c0d62bf depends: - __glibc >=2.17,<3.0.a0 - libgcc-ng >=12 - - libopenvino 2024.3.0 h2da1b83_0 + - libopenvino 2024.2.0 h2da1b83_1 - libstdcxx-ng >=12 - pugixml >=1.14,<1.15.0a0 purls: [] - size: 201812 - timestamp: 1722425738880 -- kind: conda - name: libopenvino-ir-frontend - version: 2024.3.0 - build: h88cb26a_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-ir-frontend-2024.3.0-h88cb26a_0.conda - sha256: 4c9f8428aca195a7fe87de991cfc09f44dab302cc250e065e63948638659a67f - md5: e1727ef328402633481039e66abb599a + size: 199100 + timestamp: 1718739442141 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-ir-frontend-2024.4.0-h3f63f65_0.conda + sha256: 4e3391075bb992d6ac686ec276952677b0d176b2ed07a583042eff64dd2976a3 + md5: e58bb393b3e13eae8c472a962748750f + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libopenvino 2024.4.0 hac27bb2_0 + - libstdcxx >=13 + - pugixml >=1.14,<1.15.0a0 + purls: [] + size: 203147 + timestamp: 1726766313825 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-ir-frontend-2024.4.0-h868cbb4_0.conda + sha256: 1fd5dd4705e6d40f798b586abb2e56b1e800ee466ff830ca0ee31633141829f8 + md5: 9ba5edc002dc3c689ec2e448dd57abdc depends: - __osx >=11.0 - - libcxx >=16 - - libopenvino 2024.3.0 h5c9529b_0 + - libcxx >=17 + - libopenvino 2024.4.0 h49f535f_0 - pugixml >=1.14,<1.15.0a0 purls: [] - size: 171087 - timestamp: 1722423437317 -- kind: conda - name: libopenvino-onnx-frontend - version: 2024.3.0 - build: h07e8aee_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-onnx-frontend-2024.3.0-h07e8aee_0.conda - sha256: 6147718a14b5fd22047b3bafbc3fc28499de1e1b420add8a1f7836388c231fce - md5: 89ab3cfdbf7b9a94643332cf0a8ec0e9 + size: 172377 + timestamp: 1726763883772 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-onnx-frontend-2024.2.0-h07e8aee_1.conda + sha256: 3f7ea37f5d8f052a1a162d864c01b4ba477c05734351847e9136a5ebe84ac827 + md5: 9b0a13989b35302e47da13842683804d depends: - __glibc >=2.17,<3.0.a0 - libgcc-ng >=12 - - libopenvino 2024.3.0 h2da1b83_0 + - libopenvino 2024.2.0 h2da1b83_1 - libprotobuf >=4.25.3,<4.25.4.0a0 - libstdcxx-ng >=12 purls: [] - size: 1553172 - timestamp: 1722425751288 -- kind: conda - name: libopenvino-onnx-frontend - version: 2024.3.0 - build: h32b5460_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-onnx-frontend-2024.3.0-h32b5460_0.conda - sha256: cc0ba5d6e5a2d7937b1be6d5e61d0a01fe0f2d4c94665bae0d01cf7fd1a58670 - md5: 10fee193667ceeaec402861da7d8d204 + size: 1556173 + timestamp: 1718739454241 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-onnx-frontend-2024.4.0-h56242b0_0.conda + sha256: a119277dff41843d9967c77756d1fcba7e17f7fa65977762d6c32d71214da917 + md5: bc2d0913d22b2f30e441036542dfc5e9 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libopenvino 2024.4.0 hac27bb2_0 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - libstdcxx >=13 + purls: [] + size: 1573538 + timestamp: 1726766324672 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-onnx-frontend-2024.4.0-hf4ed89a_0.conda + sha256: 0e38776b2eea0ee0f6cde79faebf7a8be0697a4b734b68895dad9a33b82a82f7 + md5: 41c4642215afd68415adab568d5c876c depends: - __osx >=11.0 - - libcxx >=16 - - libopenvino 2024.3.0 h5c9529b_0 + - libcxx >=17 + - libopenvino 2024.4.0 h49f535f_0 - libprotobuf >=4.25.3,<4.25.4.0a0 purls: [] - size: 1208478 - timestamp: 1722423474069 -- kind: conda - name: libopenvino-paddle-frontend - version: 2024.3.0 - build: h07e8aee_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-paddle-frontend-2024.3.0-h07e8aee_0.conda - sha256: 5a982cb2554137aefe989e7c67ef4e63ddadfc9fd1c28963436e39d9721d099c - md5: b0516d69280d72da03d20d8cc8172b15 + size: 1245113 + timestamp: 1726763914864 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-paddle-frontend-2024.2.0-h07e8aee_1.conda + sha256: da2fcf5e9962d5c5e1d47d52f84635648952354c30205c5908332af5999625bc + md5: 7b3680d3fd00e1f91d5faf9c97c7ae78 depends: - __glibc >=2.17,<3.0.a0 - libgcc-ng >=12 - - libopenvino 2024.3.0 h2da1b83_0 + - libopenvino 2024.2.0 h2da1b83_1 - libprotobuf >=4.25.3,<4.25.4.0a0 - libstdcxx-ng >=12 purls: [] - size: 683148 - timestamp: 1722425765414 -- kind: conda - name: libopenvino-paddle-frontend - version: 2024.3.0 - build: h32b5460_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-paddle-frontend-2024.3.0-h32b5460_0.conda - sha256: 894688374d3ad6a368f891d05b82f55176fff6dc3ad984bcaade7752117f3872 - md5: 1d35f6ca36a729905a8a9050a407ba3f + size: 688252 + timestamp: 1718739467896 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-paddle-frontend-2024.4.0-h56242b0_0.conda + sha256: 3c984a74c06720f9eed0cb4e7c4370470f635c8c5e148aac1517cb51b074ac54 + md5: 9b97741337ad0c7df240498c5bc3e69f depends: - - __osx >=11.0 - - libcxx >=16 - - libopenvino 2024.3.0 h5c9529b_0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libopenvino 2024.4.0 hac27bb2_0 - libprotobuf >=4.25.3,<4.25.4.0a0 + - libstdcxx >=13 purls: [] - size: 417515 - timestamp: 1722423502265 -- kind: conda - name: libopenvino-pytorch-frontend - version: 2024.3.0 - build: h00cdb27_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-pytorch-frontend-2024.3.0-h00cdb27_0.conda - sha256: ec114b35767247e0f58de9eef4bb9096f9b825747bdc38452b0f70c8b17951da - md5: abd15b1e4ccaaa5576bd8e91bc26006b + size: 656450 + timestamp: 1726766337162 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-paddle-frontend-2024.4.0-hf4ed89a_0.conda + sha256: 2884bf464ef707b4f22e3e831e52eface92af8d6ccd5341b9e32b25e1d0bcc1b + md5: 39c2b0fd6991734e0fbb2832836308a2 depends: - __osx >=11.0 - - libcxx >=16 - - libopenvino 2024.3.0 h5c9529b_0 + - libcxx >=17 + - libopenvino 2024.4.0 h49f535f_0 + - libprotobuf >=4.25.3,<4.25.4.0a0 purls: [] - size: 750922 - timestamp: 1722423524643 -- kind: conda - name: libopenvino-pytorch-frontend - version: 2024.3.0 - build: he02047a_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-pytorch-frontend-2024.3.0-he02047a_0.conda - sha256: bd550f304a6b1ef8ee58ee15e13001718dc62bcc26731e2ea051549173a5b4ea - md5: 92654c43075ffd142caae9417bab9c11 + size: 420382 + timestamp: 1726763935872 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-pytorch-frontend-2024.2.0-he02047a_1.conda + sha256: 077470fd8a48b4aafbb46a6ceccd9697a82ec16cce5dcb56282711ec04852e1d + md5: ac43b516c128411f84f1e19c875998f1 depends: - __glibc >=2.17,<3.0.a0 - libgcc-ng >=12 - - libopenvino 2024.3.0 h2da1b83_0 + - libopenvino 2024.2.0 h2da1b83_1 - libstdcxx-ng >=12 purls: [] - size: 1110380 - timestamp: 1722425778193 -- kind: conda - name: libopenvino-tensorflow-frontend - version: 2024.3.0 - build: h2741c3b_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-tensorflow-frontend-2024.3.0-h2741c3b_0.conda - sha256: 91ac34042536e604edb722d5f62e46759b4cef2979df1b159a35fa8aab54ae4e - md5: 2900b3ad360b28270a1cd22b75b37aa3 + size: 1118583 + timestamp: 1718739481557 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-pytorch-frontend-2024.4.0-h5888daf_0.conda + sha256: 314b476ded8c7de2e42911ad6a5a0957e0ceb8b4d99a99caf552f18e69973dde + md5: 4188f0bb601163c25ed8cd515324358c + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libopenvino 2024.4.0 hac27bb2_0 + - libstdcxx >=13 + purls: [] + size: 1073843 + timestamp: 1726766348148 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-pytorch-frontend-2024.4.0-hf9b8971_0.conda + sha256: b4d7060de128d09b47a07b95a1e5b4c2d3ddaa1ace97c50b7099357dd050c6d9 + md5: cc179d2777c15282979772a4323fbc3e depends: - __osx >=11.0 + - libcxx >=17 + - libopenvino 2024.4.0 h49f535f_0 + purls: [] + size: 764922 + timestamp: 1726763955113 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-tensorflow-frontend-2024.2.0-h39126c6_1.conda + sha256: 0558659f340bc22a918750e1142a9215bac66fb8cde62279559f4a22d7d11be1 + md5: 11acf52cac790edcf087b89e83834f7d + depends: + - __glibc >=2.17,<3.0.a0 - libabseil * cxx17* - libabseil >=20240116.2,<20240117.0a0 - - libcxx >=16 - - libopenvino 2024.3.0 h5c9529b_0 + - libgcc-ng >=12 + - libopenvino 2024.2.0 h2da1b83_1 - libprotobuf >=4.25.3,<4.25.4.0a0 - - snappy >=1.2.1,<1.3.0a0 + - libstdcxx-ng >=12 + - snappy >=1.2.0,<1.3.0a0 purls: [] - size: 928490 - timestamp: 1722423572798 -- kind: conda - name: libopenvino-tensorflow-frontend - version: 2024.3.0 - build: h39126c6_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-tensorflow-frontend-2024.3.0-h39126c6_0.conda - sha256: 20d8b283837f92bc1d2f962713965e8c612e49605a54d676972d8f9936813dfb - md5: 5d49cf778f9dadc9438073b9b4bdf587 + size: 1290179 + timestamp: 1718739495084 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-tensorflow-frontend-2024.4.0-h358ae18_0.conda + sha256: f348f0d569dfba6c8e7b9bfff16f244da1f26b1f7ce1001245e1fb8b0af1dc6b + md5: 5fbd3f499da9d147ed5417a6f7e24d83 depends: - __glibc >=2.17,<3.0.a0 - libabseil * cxx17* - libabseil >=20240116.2,<20240117.0a0 - - libgcc-ng >=12 - - libopenvino 2024.3.0 h2da1b83_0 + - libgcc >=13 + - libopenvino 2024.4.0 hac27bb2_0 - libprotobuf >=4.25.3,<4.25.4.0a0 - - libstdcxx-ng >=12 + - libstdcxx >=13 - snappy >=1.2.1,<1.3.0a0 purls: [] - size: 1305937 - timestamp: 1722425793747 -- kind: conda - name: libopenvino-tensorflow-lite-frontend - version: 2024.3.0 - build: h00cdb27_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-tensorflow-lite-frontend-2024.3.0-h00cdb27_0.conda - sha256: d5847c3e5cd5887b6b80afc739d22fcc6cec9d02e97a5ca2fa191b558fa3d941 - md5: 18e9ae86ef870e2b48668f45f8c1d2b6 + size: 1300989 + timestamp: 1726766361932 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-tensorflow-frontend-2024.4.0-h94307f2_0.conda + sha256: 50e5998d67c646b612ca16651e15a31f2414f69fd3825fca527b0015a61dc565 + md5: 2c76cf0843e2986b5ad858cb72454c6e depends: - __osx >=11.0 - - libcxx >=16 - - libopenvino 2024.3.0 h5c9529b_0 + - libabseil * cxx17* + - libabseil >=20240116.2,<20240117.0a0 + - libcxx >=17 + - libopenvino 2024.4.0 h49f535f_0 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - snappy >=1.2.1,<1.3.0a0 purls: [] - size: 369512 - timestamp: 1722423598466 -- kind: conda - name: libopenvino-tensorflow-lite-frontend - version: 2024.3.0 - build: he02047a_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-tensorflow-lite-frontend-2024.3.0-he02047a_0.conda - sha256: fe10142fe37a1486ec66a545a26a6b2ee48e912d770f0d9ccebaf66cc067afeb - md5: 177e64dac3b9f83f0a505b25c698dc09 + size: 945290 + timestamp: 1726763998133 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-tensorflow-lite-frontend-2024.2.0-he02047a_1.conda + sha256: 896b19b23e0649cdadf972c7380f74b766012feaea1417ab2fc4efb4de049cd4 + md5: e7f91b35e3aa7abe880fc9192a761fc0 depends: - __glibc >=2.17,<3.0.a0 - libgcc-ng >=12 - - libopenvino 2024.3.0 h2da1b83_0 + - libopenvino 2024.2.0 h2da1b83_1 - libstdcxx-ng >=12 purls: [] - size: 471539 - timestamp: 1722425807123 -- kind: conda - name: libopus - version: 1.3.1 - build: h27ca646_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libopus-1.3.1-h27ca646_1.tar.bz2 - sha256: e9912101a58cbc609a1917c5289f3bd1f600c82ed3a1c90a6dd4ca02df77958a - md5: 3d0dbee0ccd2f6d6781d270313627b62 - license: BSD-3-Clause - license_family: BSD + size: 474621 + timestamp: 1718739508207 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-tensorflow-lite-frontend-2024.4.0-h5888daf_0.conda + sha256: 6990ea69c92e0f48f3628b753f42919d6201ca1d53c2434750d46b0f7af7b3dd + md5: bffe380c0f0d813bdf7e35445cf11f2a + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libopenvino 2024.4.0 hac27bb2_0 + - libstdcxx >=13 purls: [] - size: 252854 - timestamp: 1606823635137 -- kind: conda - name: libopus - version: 1.3.1 - build: h7f98852_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libopus-1.3.1-h7f98852_1.tar.bz2 + size: 466000 + timestamp: 1726766373816 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenvino-tensorflow-lite-frontend-2024.4.0-hf9b8971_0.conda + sha256: 6b77dd1b3e493ac9b0b481a56e72bb1172045eefad9cee6cc6fdca32b4daa1a7 + md5: b7160871450c8e392ffe72b93a9641ea + depends: + - __osx >=11.0 + - libcxx >=17 + - libopenvino 2024.4.0 h49f535f_0 + purls: [] + size: 369163 + timestamp: 1726764018430 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopus-1.3.1-h7f98852_1.tar.bz2 sha256: 0e1c2740ebd1c93226dc5387461bbcf8142c518f2092f3ea7551f77755decc8f md5: 15345e56d527b330e1cacbdf58676e8f depends: @@ -10483,53 +10176,77 @@ packages: purls: [] size: 260658 timestamp: 1606823578035 -- kind: conda - name: libparquet - version: 17.0.0 - build: h39682fd_13_cpu - build_number: 13 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libparquet-17.0.0-h39682fd_13_cpu.conda - sha256: 3c63b7391275cf6cf2a18d2dba3c30c16dd9d210373d206675e342b084cccdf4 - md5: 49c60a8dc089d8127b9368e9eb6c1a77 - depends: - - __glibc >=2.17,<3.0.a0 - - libarrow 17.0.0 h8d2e343_13_cpu +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopus-1.3.1-h27ca646_1.tar.bz2 + sha256: e9912101a58cbc609a1917c5289f3bd1f600c82ed3a1c90a6dd4ca02df77958a + md5: 3d0dbee0ccd2f6d6781d270313627b62 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 252854 + timestamp: 1606823635137 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libparquet-17.0.0-h39682fd_16_cpu.conda + build_number: 16 + sha256: 09bc64111e5e1e9f5fee78efdd62592e01c681943fe6e91b369f6580dc8726c4 + md5: dd1fee2da0659103080fdd74004656df + depends: + - __glibc >=2.17,<3.0.a0 + - libarrow 17.0.0 had3b6fe_16_cpu - libgcc >=13 - libstdcxx >=13 - libthrift >=0.20.0,<0.20.1.0a0 - - openssl >=3.3.1,<4.0a0 + - openssl >=3.3.2,<4.0a0 + license: Apache-2.0 + license_family: APACHE + purls: [] + size: 1186069 + timestamp: 1726670048098 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libparquet-18.1.0-h081d1f1_6_cpu.conda + build_number: 6 + sha256: c691a59f1ebb6cedbf827f49f6cf414e08b0eec911f589133e6a8321e8ac701c + md5: 68788df49ce7480187eb6387f15b2b67 + depends: + - __glibc >=2.17,<3.0.a0 + - libarrow 18.1.0 h44a453e_6_cpu + - libgcc >=13 + - libstdcxx >=13 + - libthrift >=0.21.0,<0.21.1.0a0 + - openssl >=3.4.0,<4.0a0 license: Apache-2.0 license_family: APACHE purls: [] - size: 1189824 - timestamp: 1725214804075 -- kind: conda - name: libparquet - version: 17.0.0 - build: hf0ba9ef_13_cpu - build_number: 13 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libparquet-17.0.0-hf0ba9ef_13_cpu.conda - sha256: fb7ee16e8f9bf60a1f136170231615c1a6f200087f12de4220e0c73f45edcdc6 - md5: 8d415217e6cc74179b5d00a61238b6a9 + size: 1204535 + timestamp: 1733810811118 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libparquet-17.0.0-hf0ba9ef_16_cpu.conda + build_number: 16 + sha256: 6ed28f06409b02a9f521ee5e8cf2f4d3fb63a7633c11f2ee7ec2880e78e184e5 + md5: 517ecf2ee0c2822e6120c258f3acd383 depends: - __osx >=11.0 - - libarrow 17.0.0 h20538ec_13_cpu + - libarrow 17.0.0 hc6a7651_16_cpu - libcxx >=17 - libthrift >=0.20.0,<0.20.1.0a0 - - openssl >=3.3.1,<4.0a0 + - openssl >=3.3.2,<4.0a0 + license: Apache-2.0 + license_family: APACHE + purls: [] + size: 873007 + timestamp: 1726670938318 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libparquet-18.1.0-h636d7b7_6_cpu.conda + build_number: 6 + sha256: 88c1e810bede65c54f1ebc51c14400f9e8cf0fc1f88a8c0a99210e2f5dfed582 + md5: 9b333c3a38e55f6c1b8733222e22f528 + depends: + - __osx >=11.0 + - libarrow 18.1.0 h4a2f8bd_6_cpu + - libcxx >=18 + - libthrift >=0.21.0,<0.21.1.0a0 + - openssl >=3.4.0,<4.0a0 license: Apache-2.0 license_family: APACHE purls: [] - size: 859328 - timestamp: 1725215440648 -- kind: conda - name: libpciaccess - version: '0.18' - build: hd590300_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libpciaccess-0.18-hd590300_0.conda + size: 873134 + timestamp: 1733809271282 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libpciaccess-0.18-hd590300_0.conda sha256: c0a30ac74eba66ea76a4f0a39acc7833f5ed783a632ca3bb6665b2d81aabd2fb md5: 48f4330bfcd959c3cfb704d424903c82 depends: @@ -10539,97 +10256,112 @@ packages: purls: [] size: 28361 timestamp: 1707101388552 -- kind: conda - name: libpng - version: 1.6.43 - build: h091b4b1_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libpng-1.6.43-h091b4b1_0.conda - sha256: 66c4713b07408398f2221229a1c1d5df57d65dc0902258113f2d9ecac4772495 - md5: 77e684ca58d82cae9deebafb95b1a2b8 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.44-hadc24fc_0.conda + sha256: e5b14f7a01c2db4362d8591f42f82f336ed48d5e4079e4d1f65d0c2a3637ea78 + md5: f4cc49d7aa68316213e4b12be35308d1 depends: - - libzlib >=1.2.13,<2.0.0a0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libzlib >=1.3.1,<2.0a0 license: zlib-acknowledgement purls: [] - size: 264177 - timestamp: 1708780447187 -- kind: conda - name: libpng - version: 1.6.43 - build: h2797004_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.43-h2797004_0.conda - sha256: 502f6ff148ac2777cc55ae4ade01a8fc3543b4ffab25c4e0eaa15f94e90dd997 - md5: 009981dd9cfcaa4dbfa25ffaed86bcae + size: 290661 + timestamp: 1726234747153 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpng-1.6.44-hc14010f_0.conda + sha256: 38f8759a3eb8060deabd4db41f0f023514d853e46ddcbd0ba21768fc4e563bb1 + md5: fb36e93f0ea6a6f5d2b99984f34b049e depends: - - libgcc-ng >=12 - - libzlib >=1.2.13,<2.0.0a0 + - __osx >=11.0 + - libzlib >=1.3.1,<2.0a0 license: zlib-acknowledgement purls: [] - size: 288221 - timestamp: 1708780443939 -- kind: conda - name: libpq - version: '16.4' - build: h2d7952a_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libpq-16.4-h2d7952a_1.conda - sha256: f7a425b8bc94a541f9c43120734305705ffaa3054470e49fbdea0f166fc3f371 - md5: 7e3173fd1299939a02ebf9ec32aa77c4 + size: 263385 + timestamp: 1726234714421 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libpq-16.6-h035377e_1.conda + sha256: 5f30c6d38e7bb524e1d72c4fbcb529f8de3fb6e2e9b19881f2052c4f768e83da + md5: 82018c14a0fde7835071378446561f7b depends: - __glibc >=2.17,<3.0.a0 - krb5 >=1.21.3,<1.22.0a0 - libgcc >=13 - - openssl >=3.3.1,<4.0a0 + - openssl >=3.4.0,<4.0a0 + license: PostgreSQL + purls: [] + size: 2475072 + timestamp: 1733427881343 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libpq-17.2-h3b95a9b_1.conda + sha256: 7e0debdb22c81e069c4c6fed8b5b82fcfa0f37cccba2fb00e833e657dc75113f + md5: 37724d8bae042345a19ca1a25dde786b + depends: + - __glibc >=2.17,<3.0.a0 + - icu >=75.1,<76.0a0 + - krb5 >=1.21.3,<1.22.0a0 + - libgcc >=13 + - openldap >=2.6.9,<2.7.0a0 + - openssl >=3.4.0,<4.0a0 license: PostgreSQL purls: [] - size: 2510669 - timestamp: 1724948449731 -- kind: conda - name: libprotobuf - version: 4.25.3 - build: h08a7969_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-4.25.3-h08a7969_0.conda - sha256: 70e0eef046033af2e8d21251a785563ad738ed5281c74e21c31c457780845dcd - md5: 6945825cebd2aeb16af4c69d97c32c13 + size: 2656919 + timestamp: 1733427612100 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-4.25.3-hd5b35b9_1.conda + sha256: 8b5e4e31ed93bf36fd14e9cf10cd3af78bb9184d0f1f87878b8d28c0374aa4dc + md5: 06def97690ef90781a91b786cb48a0a9 + depends: + - __glibc >=2.17,<3.0.a0 + - libabseil * cxx17* + - libabseil >=20240116.2,<20240117.0a0 + - libgcc >=13 + - libstdcxx >=13 + - libzlib >=1.3.1,<2.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 2883090 + timestamp: 1727161327039 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-5.28.2-h5b01275_0.conda + sha256: 5e8fd4aa00193c85602ce6101dd28fe31306dff85c9725048f6dc828dfa7c421 + md5: ab0bff36363bec94720275a681af8b83 + depends: + - __glibc >=2.17,<3.0.a0 + - libabseil * cxx17* + - libabseil >=20240722.0,<20240723.0a0 + - libgcc >=13 + - libstdcxx >=13 + - libzlib >=1.3.1,<2.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 2945348 + timestamp: 1728565355702 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libprotobuf-4.25.3-hc39d83c_1.conda + sha256: f51bde2dfe73968ab3090c1098f520b65a8d8f11e945cb13bf74d19e30966b61 + md5: fa77986d9170450c014586ab87e144f8 depends: + - __osx >=11.0 - libabseil * cxx17* - - libabseil >=20240116.1,<20240117.0a0 - - libgcc-ng >=12 - - libstdcxx-ng >=12 - - libzlib >=1.2.13,<2.0.0a0 + - libabseil >=20240116.2,<20240117.0a0 + - libcxx >=17 + - libzlib >=1.3.1,<2.0a0 license: BSD-3-Clause license_family: BSD purls: [] - size: 2811207 - timestamp: 1709514552541 -- kind: conda - name: libprotobuf - version: 4.25.3 - build: hbfab5d5_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libprotobuf-4.25.3-hbfab5d5_0.conda - sha256: d754519abc3ddbdedab2a38d0639170f5347c1573eef80c707f3a8dc5dff706a - md5: 5f70b2b945a9741cba7e6dfe735a02a7 + size: 2177164 + timestamp: 1727160770879 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libprotobuf-5.28.2-h8f0b736_0.conda + sha256: f732a6fa918428e2d5ba61e78fe11bb44a002cc8f6bb74c94ee5b1297fefcfd8 + md5: d2cb5991f2fb8eb079c80084435e9ce6 depends: + - __osx >=11.0 - libabseil * cxx17* - - libabseil >=20240116.1,<20240117.0a0 - - libcxx >=16 - - libzlib >=1.2.13,<2.0.0a0 + - libabseil >=20240722.0,<20240723.0a0 + - libcxx >=17 + - libzlib >=1.3.1,<2.0a0 license: BSD-3-Clause license_family: BSD purls: [] - size: 2154402 - timestamp: 1709514097574 -- kind: conda - name: libre2-11 - version: 2023.09.01 - build: h5a48ba9_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libre2-11-2023.09.01-h5a48ba9_2.conda + size: 2374965 + timestamp: 1728565334796 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libre2-11-2023.09.01-h5a48ba9_2.conda sha256: 3f3c65fe0e9e328b4c1ebc2b622727cef3e5b81b18228cfa6cf0955bc1ed8eff md5: 41c69fba59d495e8cf5ffda48a607e35 depends: @@ -10644,13 +10376,23 @@ packages: purls: [] size: 232603 timestamp: 1708946763521 -- kind: conda - name: libre2-11 - version: 2023.09.01 - build: h7b2c953_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libre2-11-2023.09.01-h7b2c953_2.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/libre2-11-2024.07.02-hbbce691_1.conda + sha256: f8ad6a4f6d4fd54ebe3e5e712a01e663222fc57f49d16b6b8b10c30990dafb8f + md5: 2124de47357b7a516c0a3efd8f88c143 + depends: + - __glibc >=2.17,<3.0.a0 + - libabseil * cxx17* + - libabseil >=20240722.0,<20240723.0a0 + - libgcc >=13 + - libstdcxx >=13 + constrains: + - re2 2024.07.02.* + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 211096 + timestamp: 1728778964655 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libre2-11-2023.09.01-h7b2c953_2.conda sha256: c8a0a6e7a627dc9c66ffb8858f8f6d499f67fd269b6636b25dc5169760610f05 md5: 0b7b2ced046d6b5fe6e9d46b1ee0324c depends: @@ -10664,13 +10406,42 @@ packages: purls: [] size: 171443 timestamp: 1708947163461 -- kind: conda - name: libsanitizer - version: 12.4.0 - build: h46f95d5_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-12.4.0-h46f95d5_1.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libre2-11-2024.07.02-h2348fd5_1.conda + sha256: 6facca42cfc85a05b33e484a8b0df7857cc092db34806946d022270098d8d20f + md5: 5a7065309a66097738be6a06fd04b7ef + depends: + - __osx >=11.0 + - libabseil * cxx17* + - libabseil >=20240722.0,<20240723.0a0 + - libcxx >=17 + constrains: + - re2 2024.07.02.* + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 165956 + timestamp: 1728779107218 +- conda: https://conda.anaconda.org/conda-forge/linux-64/librsvg-2.58.4-hc0ffecb_0.conda + sha256: fda3197ffb24512e719d55defa02f9f70286038e56cad8c1d580ed6460f417fa + md5: 83f045969988f5c7a65f3950b95a8b35 + depends: + - __glibc >=2.17,<3.0.a0 + - cairo >=1.18.0,<2.0a0 + - freetype >=2.12.1,<3.0a0 + - gdk-pixbuf >=2.42.12,<3.0a0 + - harfbuzz >=9.0.0,<10.0a0 + - libgcc >=13 + - libglib >=2.80.3,<3.0a0 + - libpng >=1.6.43,<1.7.0a0 + - libxml2 >=2.12.7,<3.0a0 + - pango >=1.54.0,<2.0a0 + constrains: + - __glibc >=2.17 + license: LGPL-2.1-or-later + purls: [] + size: 6390511 + timestamp: 1726227212382 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-12.4.0-h46f95d5_1.conda sha256: 09bfebe6b68ca51018df751e231bf187f96aa49f4d0804556c3920b50d7a244b md5: 6cf3b8a6dd5b1525d7b2653f1ce8c2c5 depends: @@ -10681,29 +10452,7 @@ packages: purls: [] size: 3947704 timestamp: 1724801833649 -- kind: conda - name: libsanitizer - version: 14.1.0 - build: hcba0ae0_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-14.1.0-hcba0ae0_1.conda - sha256: f653c694bb99e36aa0acdb25c8dae0f3b6d090e10068d6734be570c937abc811 - md5: b56e6664bb9a57a29fd91df582223409 - depends: - - libgcc >=14.1.0 - - libstdcxx >=14.1.0 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL - purls: [] - size: 4530998 - timestamp: 1724801881195 -- kind: conda - name: libsodium - version: 1.0.20 - build: h4ab18f5_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libsodium-1.0.20-h4ab18f5_0.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/libsodium-1.0.20-h4ab18f5_0.conda sha256: 0105bd108f19ea8e6a78d2d994a6d4a8db16d19a41212070d2d1d48a63c34161 md5: a587892d3c13b6621a6091be690dbca2 depends: @@ -10712,12 +10461,7 @@ packages: purls: [] size: 205978 timestamp: 1716828628198 -- kind: conda - name: libsodium - version: 1.0.20 - build: h99b78c6_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.20-h99b78c6_0.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.20-h99b78c6_0.conda sha256: fade8223e1e1004367d7101dd17261003b60aa576df6d7802191f8972f7470b1 md5: a7ce36e284c5faaf93c220dfc39e3abd depends: @@ -10726,94 +10470,62 @@ packages: purls: [] size: 164972 timestamp: 1716828607917 -- kind: conda - name: libsqlite - version: 3.46.1 - build: hadc24fc_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.46.1-hadc24fc_0.conda - sha256: 9851c049abafed3ee329d6c7c2033407e2fc269d33a75c071110ab52300002b0 - md5: 36f79405ab16bf271edb55b213836dac +- conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.47.2-hee588c1_0.conda + sha256: 48af21ebc2cbf358976f1e0f4a0ab9e91dfc83d0ef337cf3837c6f5bc22fb352 + md5: b58da17db24b6e08bcbf8fed2fb8c915 depends: - __glibc >=2.17,<3.0.a0 - libgcc >=13 - libzlib >=1.3.1,<2.0a0 license: Unlicense purls: [] - size: 865214 - timestamp: 1725353659783 -- kind: conda - name: libsqlite - version: 3.46.1 - build: hc14010f_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.46.1-hc14010f_0.conda - sha256: 3725f962f490c5d44dae326d5f5b2e3c97f71a6322d914ccc85b5ddc2e50d120 - md5: 58050ec1724e58668d0126a1615553fa + size: 873551 + timestamp: 1733761824646 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.47.2-h3f77e49_0.conda + sha256: f192f3c8973de9ec4c214990715f13b781965247a5cedf9162e7f9e699cfc3c4 + md5: 122d6f29470f1a991e85608e77e56a8a depends: - __osx >=11.0 - libzlib >=1.3.1,<2.0a0 license: Unlicense purls: [] - size: 829500 - timestamp: 1725353720793 -- kind: conda - name: libssh2 - version: 1.11.0 - build: h0841786_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.0-h0841786_0.conda - sha256: 50e47fd9c4f7bf841a11647ae7486f65220cfc988ec422a4475fe8d5a823824d - md5: 1f5a58e686b13bcfde88b93f547d23fe + size: 850553 + timestamp: 1733762057506 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-hf672d98_0.conda + sha256: 0407ac9fda2bb67e11e357066eff144c845801d00b5f664efbc48813af1e7bb9 + md5: be2de152d8073ef1c01b7728475f2fe7 depends: - - libgcc-ng >=12 - - libzlib >=1.2.13,<2.0.0a0 - - openssl >=3.1.1,<4.0a0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.4.0,<4.0a0 license: BSD-3-Clause license_family: BSD purls: [] - size: 271133 - timestamp: 1685837707056 -- kind: conda - name: libssh2 - version: 1.11.0 - build: h7a5bd25_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.0-h7a5bd25_0.conda - sha256: bb57d0c53289721fff1eeb3103a1c6a988178e88d8a8f4345b0b91a35f0e0015 - md5: 029f7dc931a3b626b94823bc77830b01 + size: 304278 + timestamp: 1732349402869 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.1-h9cc3647_0.conda + sha256: f7047c6ed44bcaeb04432e8c74da87591940d091b0a3940c0d884b7faa8062e9 + md5: ddc7194676c285513706e5fc64f214d7 depends: - - libzlib >=1.2.13,<2.0.0a0 - - openssl >=3.1.1,<4.0a0 + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.4.0,<4.0a0 license: BSD-3-Clause license_family: BSD purls: [] - size: 255610 - timestamp: 1685837894256 -- kind: conda - name: libstdcxx - version: 14.1.0 - build: hc0a3c3a_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-14.1.0-hc0a3c3a_1.conda - sha256: 44decb3d23abacf1c6dd59f3c152a7101b7ca565b4ef8872804ceaedcc53a9cd - md5: 9dbb9699ea467983ba8a4ba89b08b066 + size: 279028 + timestamp: 1732349599461 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-14.2.0-hc0a3c3a_1.conda + sha256: 4661af0eb9bdcbb5fb33e5d0023b001ad4be828fccdcc56500059d56f9869462 + md5: 234a5554c53625688d51062645337328 depends: - - libgcc 14.1.0 h77fa898_1 + - libgcc 14.2.0 h77fa898_1 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL purls: [] - size: 3892781 - timestamp: 1724801863728 -- kind: conda - name: libstdcxx-devel_linux-64 - version: 12.4.0 - build: ha4f9413_101 - build_number: 101 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-12.4.0-ha4f9413_101.conda + size: 3893695 + timestamp: 1729027746910 +- conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-12.4.0-ha4f9413_101.conda sha256: 13a2c9b166b4338ef6b0a91c6597198dbb227c038ebaa55df4b6a3f6bfccd5f3 md5: 5e22204cb6cedf08c64933360ccebe7e depends: @@ -10823,28 +10535,17 @@ packages: purls: [] size: 11890684 timestamp: 1724801712899 -- kind: conda - name: libstdcxx-ng - version: 14.1.0 - build: h4852527_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-14.1.0-h4852527_1.conda - sha256: a2dc44f97290740cc187bfe94ce543e6eb3c2ea8964d99f189a1d8c97b419b8c - md5: bd2598399a70bb86d8218e95548d735e +- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-14.2.0-h4852527_1.conda + sha256: 25bb30b827d4f6d6f0522cc0579e431695503822f144043b93c50237017fffd8 + md5: 8371ac6457591af2cf6159439c1fd051 depends: - - libstdcxx 14.1.0 hc0a3c3a_1 + - libstdcxx 14.2.0 hc0a3c3a_1 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL purls: [] - size: 52219 - timestamp: 1724801897766 -- kind: conda - name: libtasn1 - version: 4.19.0 - build: h166bdaf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libtasn1-4.19.0-h166bdaf_0.tar.bz2 + size: 54105 + timestamp: 1729027780628 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libtasn1-4.19.0-h166bdaf_0.tar.bz2 sha256: 5bfeada0e1c6ec2574afe2d17cdbc39994d693a41431338a6cb9dfa7c4d7bfc8 md5: 93840744a8552e9ebf6bb1a5dffc125a depends: @@ -10854,26 +10555,21 @@ packages: purls: [] size: 116878 timestamp: 1661325701583 -- kind: conda - name: libtasn1 - version: 4.19.0 - build: h1a8c8d9_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libtasn1-4.19.0-h1a8c8d9_0.tar.bz2 - sha256: 912e96644ea22b49921c71c9c94bcdd2b6463e9313da895c2fcee298a8c0e44c - md5: c35bc17c31579789c76739486fc6d27a - license: GPL-3.0-or-later - license_family: GPL +- conda: https://conda.anaconda.org/conda-forge/linux-64/libtheora-1.1.1-h4ab18f5_1006.conda + sha256: 50c8cd416ac8425e415264de167b41ae8442de22a91098dfdd993ddbf9f13067 + md5: 553281a034e9cf8693c9df49f6c78ea1 + depends: + - libgcc-ng >=12 + - libogg 1.3.* + - libogg >=1.3.5,<1.4.0a0 + - libvorbis 1.3.* + - libvorbis >=1.3.7,<1.4.0a0 + license: BSD-3-Clause + license_family: BSD purls: [] - size: 116745 - timestamp: 1661325945767 -- kind: conda - name: libthrift - version: 0.20.0 - build: h0e7cc3e_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libthrift-0.20.0-h0e7cc3e_1.conda + size: 328924 + timestamp: 1719667859099 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libthrift-0.20.0-h0e7cc3e_1.conda sha256: 3e70dfda31a3ce28310c86cc0001f20abb78c917502e12c94285a1337fe5b9f0 md5: d0ed81c4591775b70384f4cc78e05cd1 depends: @@ -10888,13 +10584,22 @@ packages: purls: [] size: 417404 timestamp: 1724652349098 -- kind: conda - name: libthrift - version: 0.20.0 - build: h64651cc_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libthrift-0.20.0-h64651cc_1.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/libthrift-0.21.0-h0e7cc3e_0.conda + sha256: ebb395232973c18745b86c9a399a4725b2c39293c9a91b8e59251be013db42f0 + md5: dcb95c0a98ba9ff737f7ae482aef7833 + depends: + - __glibc >=2.17,<3.0.a0 + - libevent >=2.1.12,<2.1.13.0a0 + - libgcc >=13 + - libstdcxx >=13 + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.3.2,<4.0a0 + license: Apache-2.0 + license_family: APACHE + purls: [] + size: 425773 + timestamp: 1727205853307 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libthrift-0.20.0-h64651cc_1.conda sha256: b6afcbc934258e0474e0f1059bc7b23865723b902062f2f2910e0370e6495401 md5: 4cf2e5233320648397184415f380c891 depends: @@ -10908,122 +10613,56 @@ packages: purls: [] size: 315041 timestamp: 1724657608736 -- kind: conda - name: libtiff - version: 4.6.0 - build: h46a8edc_4 - build_number: 4 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.6.0-h46a8edc_4.conda - sha256: 8d42dd7c6602187d4351fc3b69ff526f1c262bfcbfd6ce05d06008f4e0b99b58 - md5: a7e3a62981350e232e0e7345b5aea580 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libthrift-0.21.0-h64651cc_0.conda + sha256: 7a6c7d5f58cbbc2ccd6493b4b821639fdb0701b9b04c737a949e8cb6adf1c9ad + md5: 7ce2bd2f650f8c31ad7ba4c7bfea61b7 + depends: + - __osx >=11.0 + - libcxx >=17 + - libevent >=2.1.12,<2.1.13.0a0 + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.3.2,<4.0a0 + license: Apache-2.0 + license_family: APACHE + purls: [] + size: 324342 + timestamp: 1727206096912 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.0-hd9ff511_3.conda + sha256: b224e16b88d76ea95e4af56e2bc638c603bd26a770b98d117d04541d3aafa002 + md5: 0ea6510969e1296cc19966fad481f6de depends: - __glibc >=2.17,<3.0.a0 - lerc >=4.0.0,<5.0a0 - - libdeflate >=1.21,<1.22.0a0 - - libgcc-ng >=12 + - libdeflate >=1.23,<1.24.0a0 + - libgcc >=13 - libjpeg-turbo >=3.0.0,<4.0a0 - - libstdcxx-ng >=12 + - liblzma >=5.6.3,<6.0a0 + - libstdcxx >=13 - libwebp-base >=1.4.0,<2.0a0 - libzlib >=1.3.1,<2.0a0 - - xz >=5.2.6,<6.0a0 - zstd >=1.5.6,<1.6.0a0 license: HPND purls: [] - size: 282236 - timestamp: 1722871642189 -- kind: conda - name: libtiff - version: 4.6.0 - build: hf8409c0_4 - build_number: 4 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libtiff-4.6.0-hf8409c0_4.conda - sha256: a974a0ed75df11a9fa1ddfe2fa21aa7ecc70e5a92a37b86b648691810f02aac6 - md5: 16a56d4b4ee88fdad1210bf026619cc3 + size: 428173 + timestamp: 1734398813264 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtiff-4.7.0-h551f018_3.conda + sha256: 91417846157e04992801438a496b151df89604b2e7c6775d6f701fcd0cbed5ae + md5: a5d084a957563e614ec0c0196d890654 depends: - __osx >=11.0 - lerc >=4.0.0,<5.0a0 - - libcxx >=16 - - libdeflate >=1.21,<1.22.0a0 + - libcxx >=18 + - libdeflate >=1.23,<1.24.0a0 - libjpeg-turbo >=3.0.0,<4.0a0 + - liblzma >=5.6.3,<6.0a0 - libwebp-base >=1.4.0,<2.0a0 - libzlib >=1.3.1,<2.0a0 - - xz >=5.2.6,<6.0a0 - zstd >=1.5.6,<1.6.0a0 license: HPND purls: [] - size: 238731 - timestamp: 1722871853823 -- kind: conda - name: libtorch - version: 2.3.0 - build: cpu_generic_h95df8ed_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libtorch-2.3.0-cpu_generic_h95df8ed_1.conda - sha256: 823653e97b041e06bb6fa53a1fcbe87a3a8f6533a45efed2ec76d3405b6f042f - md5: 7a355b194f465bb58e36718e668893d9 - depends: - - __osx >=11.0 - - libabseil * cxx17* - - libabseil >=20240116.2,<20240117.0a0 - - libcblas >=3.9.0,<4.0a0 - - libcxx >=16 - - liblapack >=3.9.0,<4.0a0 - - libprotobuf >=4.25.3,<4.25.4.0a0 - - libuv >=1.48.0,<2.0a0 - - llvm-openmp >=16.0.6 - - numpy >=1.19,<3 - - python >=3.12,<3.13.0a0 *_cpython - - python_abi 3.12.* *_cp312 - - sleef >=3.5.1,<4.0a0 - constrains: - - pytorch-gpu ==99999999 - - pytorch-cpu ==2.3.0 - - pytorch 2.3.0 cpu_generic_*_1 - license: BSD-3-Clause - license_family: BSD - purls: [] - size: 28223906 - timestamp: 1716588081023 -- kind: conda - name: libtorch - version: 2.3.0 - build: cpu_generic_h970db74_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libtorch-2.3.0-cpu_generic_h970db74_1.conda - sha256: 76cb8199e6d131a323028bf3d383ba20d498227570b2e38bd348dbb7a25309ad - md5: 41103ca97b679d7840677c1366125546 - depends: - - __glibc >=2.17,<3.0.a0 - - _openmp_mutex >=4.5 - - libabseil * cxx17* - - libabseil >=20240116.2,<20240117.0a0 - - libcblas >=3.9.0,<4.0a0 - - libgcc-ng >=12 - - liblapack >=3.9.0,<4.0a0 - - libprotobuf >=4.25.3,<4.25.4.0a0 - - libstdcxx-ng >=12 - - libuv >=1.48.0,<2.0a0 - - sleef >=3.5.1,<4.0a0 - constrains: - - pytorch 2.3.0 cpu_generic_*_1 - - pytorch-gpu ==99999999 - - pytorch-cpu ==2.3.0 - license: BSD-3-Clause - license_family: BSD - purls: [] - size: 50023600 - timestamp: 1716584208699 -- kind: conda - name: libtorch - version: 2.3.0 - build: cuda120_h2b0da52_301 - build_number: 301 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libtorch-2.3.0-cuda120_h2b0da52_301.conda + size: 370600 + timestamp: 1734398863052 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libtorch-2.3.0-cuda120_h2b0da52_301.conda sha256: 80edf1bff06164db3720b1dc47bde49d35eee07e0afeb810328f65aa2f528721 md5: 2016d407a061f5f62c10eb42fdc609ce depends: @@ -11060,13 +10699,31 @@ packages: purls: [] size: 504830436 timestamp: 1716604864471 -- kind: conda - name: libtorch - version: 2.3.1 - build: cpu_generic_h95df8ed_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libtorch-2.3.1-cpu_generic_h95df8ed_1.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/libtorch-2.3.1-cpu_generic_h970db74_0.conda + sha256: 945bf1e245566743d88934d52ba5fd50e4d30db80b44266b450491776e02200f + md5: ed9a1c4ac5fadbde537a8992d22c9bea + depends: + - __glibc >=2.17,<3.0.a0 + - _openmp_mutex >=4.5 + - libabseil * cxx17* + - libabseil >=20240116.2,<20240117.0a0 + - libcblas >=3.9.0,<4.0a0 + - libgcc-ng >=12 + - liblapack >=3.9.0,<4.0a0 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - libstdcxx-ng >=12 + - libuv >=1.48.0,<2.0a0 + - sleef >=3.5.1,<4.0a0 + constrains: + - pytorch-gpu ==99999999 + - pytorch 2.3.1 cpu_generic_*_0 + - pytorch-cpu ==2.3.1 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 49988813 + timestamp: 1718623091120 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtorch-2.3.1-cpu_generic_h95df8ed_1.conda sha256: dadf8e0c7aab66425ecbdcd4f97f0b250aea0b194d39b016261f485433d03fbf md5: c6f05a4a730543ad124b8d61fd63e7f1 depends: @@ -11092,24 +10749,7 @@ packages: purls: [] size: 28218721 timestamp: 1719369604577 -- kind: conda - name: libunistring - version: 0.9.10 - build: h3422bc3_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libunistring-0.9.10-h3422bc3_0.tar.bz2 - sha256: a1afe12ab199f82f339eae83405d293d197f2485d45346a709703bc7e8299949 - md5: d88e77a4861e20bd96bde6628ee7a5ae - license: GPL-3.0-only OR LGPL-3.0-only - purls: [] - size: 1577561 - timestamp: 1626955172521 -- kind: conda - name: libunistring - version: 0.9.10 - build: h7f98852_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libunistring-0.9.10-h7f98852_0.tar.bz2 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libunistring-0.9.10-h7f98852_0.tar.bz2 sha256: e88c45505921db29c08df3439ddb7f771bbff35f95e7d3103bf365d5d6ce2a6d md5: 7245a044b4a1980ed83196176b78b73a depends: @@ -11118,40 +10758,49 @@ packages: purls: [] size: 1433436 timestamp: 1626955018689 -- kind: conda - name: libutf8proc - version: 2.8.0 - build: h166bdaf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libutf8proc-2.8.0-h166bdaf_0.tar.bz2 - sha256: 49082ee8d01339b225f7f8c60f32a2a2c05fe3b16f31b554b4fb2c1dea237d1c - md5: ede4266dc02e875fe1ea77b25dd43747 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libutf8proc-2.8.0-hf23e847_1.conda + sha256: 104cf5b427fc914fec63e55f685a39480abeb4beb34bdbc77dea084c8f5a55cb + md5: b1aa0faa95017bca11369bd080487ec4 depends: - - libgcc-ng >=12 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 license: MIT license_family: MIT purls: [] - size: 101070 - timestamp: 1667316029302 -- kind: conda - name: libutf8proc - version: 2.8.0 - build: h1a8c8d9_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libutf8proc-2.8.0-h1a8c8d9_0.tar.bz2 - sha256: a3faddac08efd930fa3a1cc254b5053b4ed9428c49a888d437bf084d403c931a - md5: f8c9c41a122ab3abdf8943b13f4957ee + size: 80852 + timestamp: 1732829699583 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libutf8proc-2.9.0-hb9d3cd8_1.conda + sha256: 9794e6388e780c3310d46f773bbc924d4053375c3fcdb07a704b57f4616db928 + md5: 1e936bd23d737aac62a18e9a1e7f8b18 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + license: MIT + license_family: MIT + purls: [] + size: 81500 + timestamp: 1732868419835 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libutf8proc-2.8.0-hc098a78_1.conda + sha256: 7807a98522477a8bf12460402845224f607ab6e1e73ac316b667169f5143cfe5 + md5: ed89b8bf0d74d23ce47bcf566dd36608 + depends: + - __osx >=11.0 license: MIT license_family: MIT purls: [] - size: 103492 - timestamp: 1667316405233 -- kind: conda - name: libuuid - version: 2.38.1 - build: h0b41bf4_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda + size: 82462 + timestamp: 1732829832932 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libutf8proc-2.9.0-h5505292_1.conda + sha256: ea88f06e97ef8fa2490f7594f8885bb542577226edf8abba3144302d951a53c2 + md5: f777470d31c78cd0abe1903a2fda436f + depends: + - __osx >=11.0 + license: MIT + license_family: MIT + purls: [] + size: 83000 + timestamp: 1732868631531 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda sha256: 787eb542f055a2b3de553614b25f09eefb0a0931b0c87dbcce6efdfd92f04f18 md5: 40b61aab5c7ba9ff276c41cfffe6b80b depends: @@ -11161,47 +10810,54 @@ packages: purls: [] size: 33601 timestamp: 1680112270483 -- kind: conda - name: libuv - version: 1.48.0 - build: h93a5062_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.48.0-h93a5062_0.conda - sha256: 60bed2a7a85096387ab0381cbc32ea2da7f8dd99bd90e440983019c0cdd96ad1 - md5: abfd49e80f13453b62a56be226120ea8 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.49.2-hb9d3cd8_0.conda + sha256: a35cd81cd1a9add11024097da83cc06b0aae83186fe4124b77710876f37d8f31 + md5: 070e3c9ddab77e38799d5c30b109c633 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 license: MIT license_family: MIT purls: [] - size: 405988 - timestamp: 1709913494015 -- kind: conda - name: libuv - version: 1.48.0 - build: hd590300_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.48.0-hd590300_0.conda - sha256: b7c0e8a0c93c2621be7645b37123d4e8d27e8a974da26a3fba47a9c37711aa7f - md5: 7e8b914b1062dd4386e3de4d82a3ead6 + size: 884647 + timestamp: 1729322566955 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.49.2-h7ab814d_0.conda + sha256: 0e5176af1e788ad5006cf261c4ea5a288a935fda48993b0240ddd2e562dc3d02 + md5: 4bc348e3a1a74d20a3f9beb866d75e0a depends: - - libgcc-ng >=12 + - __osx >=11.0 license: MIT license_family: MIT purls: [] - size: 899979 - timestamp: 1709913354710 -- kind: conda - name: libva - version: 2.22.0 - build: hb711507_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libva-2.22.0-hb711507_0.conda - sha256: 8a67bda4308a939b2b25337cac1bc7950a1ee755d009c020ab739c4e0607fc2d - md5: d12f659072132c9d16e497073fc1f68b - depends: - - libdrm >=2.4.121,<2.5.0a0 + size: 410500 + timestamp: 1729322654121 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libva-2.21.0-h4ab18f5_2.conda + sha256: cdd0ffd791a677af28a5928c23474312fafeab718dfc93f6ce99569eb8eee8b3 + md5: 109300f4eeeb8a61498283565106b474 + depends: + - libdrm >=2.4.120,<2.5.0a0 - libgcc-ng >=12 - - libxcb >=1.16,<1.17.0a0 - - wayland >=1.23.0,<2.0a0 + - xorg-libx11 >=1.8.9,<2.0a0 + - xorg-libxext >=1.3.4,<2.0a0 + - xorg-libxfixes + - libxcb >=1.15.0,<1.16.0 + license: MIT + license_family: MIT + purls: [] + size: 189921 + timestamp: 1717743848819 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libva-2.22.0-h8a09558_1.conda + sha256: 0bd81019e02cce8d9d4077c96b82ca03c9b0ece67831c7437f977ca1f5a924a3 + md5: 139262125a3eac8ff6eef898598745a3 + depends: + - __glibc >=2.17,<3.0.a0 + - libdrm >=2.4.123,<2.5.0a0 + - libegl >=1.7.0,<2.0a0 + - libgcc >=13 + - libgl >=1.7.0,<2.0a0 + - libglx >=1.7.0,<2.0a0 + - libxcb >=1.16,<2.0.0a0 + - wayland >=1.23.1,<2.0a0 - wayland-protocols - xorg-libx11 >=1.8.9,<2.0a0 - xorg-libxext >=1.3.4,<2.0a0 @@ -11209,30 +10865,21 @@ packages: license: MIT license_family: MIT purls: [] - size: 209586 - timestamp: 1718886769974 -- kind: conda - name: libvpx - version: 1.14.1 - build: h7bae524_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libvpx-1.14.1-h7bae524_0.conda - sha256: 5d6458b5395cba0804846f156574aa8a34eef6d5f05d39e9932ddbb4215f8bd0 - md5: 95bee48afff34f203e4828444c2b2ae9 + size: 217708 + timestamp: 1726828458441 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libvorbis-1.3.7-h9c3ff4c_0.tar.bz2 + sha256: 53080d72388a57b3c31ad5805c93a7328e46ff22fab7c44ad2a86d712740af33 + md5: 309dec04b70a3cc0f1e84a4013683bc0 depends: - - __osx >=11.0 - - libcxx >=16 + - libgcc-ng >=9.3.0 + - libogg >=1.3.4,<1.4.0a0 + - libstdcxx-ng >=9.3.0 license: BSD-3-Clause license_family: BSD purls: [] - size: 1178981 - timestamp: 1717860096742 -- kind: conda - name: libvpx - version: 1.14.1 - build: hac33072_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libvpx-1.14.1-hac33072_0.conda + size: 286280 + timestamp: 1610609811627 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libvpx-1.14.1-hac33072_0.conda sha256: e7d2daf409c807be48310fcc8924e481b62988143f582eb3a58c5523a6763b13 md5: cde393f461e0c169d9ffb2fc70f81c33 depends: @@ -11243,27 +10890,18 @@ packages: purls: [] size: 1022466 timestamp: 1717859935011 -- kind: conda - name: libwebp-base - version: 1.4.0 - build: h93a5062_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libwebp-base-1.4.0-h93a5062_0.conda - sha256: 0d4bad713a512d79bfeb4d61821f447afab8b0792aca823f505ce6b195e9fde5 - md5: c0af0edfebe780b19940e94871f1a765 - constrains: - - libwebp 1.4.0 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libvpx-1.14.1-h7bae524_0.conda + sha256: 5d6458b5395cba0804846f156574aa8a34eef6d5f05d39e9932ddbb4215f8bd0 + md5: 95bee48afff34f203e4828444c2b2ae9 + depends: + - __osx >=11.0 + - libcxx >=16 license: BSD-3-Clause license_family: BSD purls: [] - size: 287750 - timestamp: 1713200194013 -- kind: conda - name: libwebp-base - version: 1.4.0 - build: hd590300_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libwebp-base-1.4.0-hd590300_0.conda + size: 1178981 + timestamp: 1717860096742 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libwebp-base-1.4.0-hd590300_0.conda sha256: 49bc5f6b1e11cb2babf2a2a731d1a680a5e08a858280876a779dbda06c78c35f md5: b26e8aa824079e1be0294e7152ca4559 depends: @@ -11275,35 +10913,46 @@ packages: purls: [] size: 438953 timestamp: 1713199854503 -- kind: conda - name: libxcb - version: '1.16' - build: hb9d3cd8_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.16-hb9d3cd8_1.conda - sha256: 33aa5fc997468b07ab3020b142eacc5479e4e2c2169f467b20ab220f33dd08de - md5: 3601598f0db0470af28985e3e7ad0158 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libwebp-base-1.4.0-h93a5062_0.conda + sha256: 0d4bad713a512d79bfeb4d61821f447afab8b0792aca823f505ce6b195e9fde5 + md5: c0af0edfebe780b19940e94871f1a765 + constrains: + - libwebp 1.4.0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 287750 + timestamp: 1713200194013 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.15-h0b41bf4_0.conda + sha256: a670902f0a3173a466c058d2ac22ca1dd0df0453d3a80e0212815c20a16b0485 + md5: 33277193f5b92bad9fdd230eb700929c + depends: + - libgcc-ng >=12 + - pthread-stubs + - xorg-libxau + - xorg-libxdmcp + license: MIT + license_family: MIT + purls: [] + size: 384238 + timestamp: 1682082368177 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.17.0-h8a09558_0.conda + sha256: 666c0c431b23c6cec6e492840b176dde533d48b7e6fb8883f5071223433776aa + md5: 92ed62436b625154323d40d5f2f11dd7 depends: - __glibc >=2.17,<3.0.a0 - - libgcc-ng >=13 + - libgcc >=13 - pthread-stubs - xorg-libxau >=1.0.11,<2.0a0 - xorg-libxdmcp license: MIT license_family: MIT purls: [] - size: 395570 - timestamp: 1724419104778 -- kind: conda - name: libxcb - version: '1.16' - build: hc9fafa5_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libxcb-1.16-hc9fafa5_1.conda - sha256: 6b38c4bceddde26d7d5bf1bec19bd302536a5e51993c2b0fc671fbb015a05643 - md5: c40807bb9ee47958bf815406c87cbc5b + size: 395888 + timestamp: 1727278577118 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxcb-1.17.0-hdb1d25a_0.conda + sha256: bd3816218924b1e43b275863e21a3e13a5db4a6da74cca8e60bc3c213eb62f71 + md5: af523aae2eca6dfa1c8eec693f5b9a79 depends: - __osx >=11.0 - pthread-stubs @@ -11312,15 +10961,9 @@ packages: license: MIT license_family: MIT purls: [] - size: 325266 - timestamp: 1724419525819 -- kind: conda - name: libxcrypt - version: 4.4.36 - build: hd590300_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda + size: 323658 + timestamp: 1727278733917 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda sha256: 6ae68e0b86423ef188196fff6207ed0c8195dd84273cb5623b85aa08033a410c md5: 5aa797f8787fe7a17d1b0821485b5adc depends: @@ -11329,19 +10972,13 @@ packages: purls: [] size: 100393 timestamp: 1702724383534 -- kind: conda - name: libxkbcommon - version: 1.7.0 - build: h2c5496b_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libxkbcommon-1.7.0-h2c5496b_1.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxkbcommon-1.7.0-h2c5496b_1.conda sha256: 6804c2a7062d10de6f159f7106dc45ebccc8d42bfb925f7919e26e567fa6da6b md5: e2eaefa4de2b7237af7c907b8bbc760a depends: - libgcc-ng >=12 - libstdcxx-ng >=12 - - libxcb >=1.16,<1.17.0a0 + - libxcb >=1.16,<2.0.0a0 - libxml2 >=2.12.7,<3.0a0 - xkeyboard-config - xorg-libxau >=1.0.11,<2.0a0 @@ -11350,69 +10987,92 @@ packages: purls: [] size: 593336 timestamp: 1718819935698 -- kind: conda - name: libxkbfile - version: 1.1.0 - build: h166bdaf_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libxkbfile-1.1.0-h166bdaf_1.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxkbcommon-1.7.0-h662e7e4_0.conda + sha256: 3d97d7f964237f42452295d461afdbc51e93f72e2c80be516f56de80e3bb6621 + md5: b32c0da42b1f24a98577bb3d7fc0b995 + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - libxcb >=1.15,<1.16.0a0 + - libxml2 >=2.12.6,<3.0a0 + - xkeyboard-config + - xorg-libxau >=1.0.11,<2.0a0 + license: MIT/X11 Derivative + license_family: MIT + purls: [] + size: 593534 + timestamp: 1711303445595 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxkbfile-1.1.0-h166bdaf_1.conda sha256: f7c9f4d42c9e87dcf7055c33e9957db4e319735de9bdd5d9ba5633c27b853ae1 md5: c6274d38be57ac8b059b8e33d406aaf6 depends: - - libgcc-ng >=12 + - libgcc-ng >=12 + license: MIT + license_family: MIT + purls: [] + size: 114087 + timestamp: 1676547070237 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.12.7-h4c95cb1_3.conda + sha256: 11a346aed187405a7d3710a79b815fd66ff80fec3b9b7f840a24531324742acf + md5: 0ac9aff6010a7751961c8e4b863a40e7 + depends: + - __glibc >=2.17,<3.0.a0 + - icu >=73.2,<74.0a0 + - libgcc-ng >=12 + - libiconv >=1.17,<2.0a0 + - libzlib >=1.3.1,<2.0a0 + - xz >=5.2.6,<6.0a0 + license: MIT + license_family: MIT + purls: [] + size: 705701 + timestamp: 1720772684071 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.13.5-h0d44e9d_1.conda + sha256: 306e18aa647d8208ad2cd0e62d84933222b2fbe93d2d53cd5283d2256b1d54de + md5: f5b05674697ae7d2c5932766695945e1 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libiconv >=1.17,<2.0a0 + - liblzma >=5.6.3,<6.0a0 + - libzlib >=1.3.1,<2.0a0 + constrains: + - icu <0.0a0 license: MIT license_family: MIT purls: [] - size: 114087 - timestamp: 1676547070237 -- kind: conda - name: libxml2 - version: 2.12.7 - build: h01dff8b_4 - build_number: 4 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.12.7-h01dff8b_4.conda - sha256: a9a76cdc6e93c0182bc2ac58b1ea0152be1a16a5d23f4dc7b8df282a7aef8d20 - md5: 1265488dc5035457b729583119ad4a1b + size: 689993 + timestamp: 1733443678322 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.13.5-h8d12d68_1.conda + sha256: c3b05bdc40d27a9249f0bb60f3f71718f94104b8bcd200163a6c9d4ade7aa052 + md5: 1a21e49e190d1ffe58531a81b6e400e1 depends: - - __osx >=11.0 + - __glibc >=2.17,<3.0.a0 - icu >=75.1,<76.0a0 + - libgcc >=13 - libiconv >=1.17,<2.0a0 + - liblzma >=5.6.3,<6.0a0 - libzlib >=1.3.1,<2.0a0 - - xz >=5.2.6,<6.0a0 license: MIT license_family: MIT purls: [] - size: 588990 - timestamp: 1721031045514 -- kind: conda - name: libxml2 - version: 2.12.7 - build: he7c6b58_4 - build_number: 4 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.12.7-he7c6b58_4.conda - sha256: 10e9e0ac52b9a516a17edbc07f8d559e23778e54f1a7721b2e0e8219284fed3b - md5: 08a9265c637230c37cb1be4a6cad4536 + size: 690589 + timestamp: 1733443667823 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.13.5-h178c5d8_1.conda + sha256: d7af3f25a4cece170502acd38f2dafbea4521f373f46dcb28a37fbe6ac2da544 + md5: 3dc3cff0eca1640a6acbbfab2f78139e depends: - - __glibc >=2.17,<3.0.a0 + - __osx >=11.0 - icu >=75.1,<76.0a0 - - libgcc-ng >=12 - libiconv >=1.17,<2.0a0 + - liblzma >=5.6.3,<6.0a0 - libzlib >=1.3.1,<2.0a0 - - xz >=5.2.6,<6.0a0 license: MIT license_family: MIT purls: [] - size: 707169 - timestamp: 1721031016143 -- kind: conda - name: libxslt - version: 1.1.39 - build: h76b75d6_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libxslt-1.1.39-h76b75d6_0.conda + size: 582898 + timestamp: 1733443841584 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxslt-1.1.39-h76b75d6_0.conda sha256: 684e9b67ef7b9ca0ca993762eeb39705ec58e2e7f958555c758da7ef416db9f3 md5: e71f31f8cfb0a91439f2086fc8aa0461 depends: @@ -11423,131 +11083,125 @@ packages: purls: [] size: 254297 timestamp: 1701628814990 -- kind: conda - name: libzlib - version: 1.3.1 - build: h4ab18f5_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-h4ab18f5_1.conda - sha256: adf6096f98b537a11ae3729eaa642b0811478f0ea0402ca67b5108fe2cb0010d - md5: 57d7dc60e9325e3de37ff8dffd18e814 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libzip-1.11.2-h6991a6a_0.conda + sha256: 991e7348b0f650d495fb6d8aa9f8c727bdf52dabf5853c0cc671439b160dce48 + md5: a7b27c075c9b7f459f1c022090697cba depends: - - libgcc-ng >=12 + - __glibc >=2.17,<3.0.a0 + - bzip2 >=1.0.8,<2.0a0 + - libgcc >=13 + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.3.2,<4.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 109043 + timestamp: 1730442108429 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-hb9d3cd8_2.conda + sha256: d4bfe88d7cb447768e31650f06257995601f89076080e76df55e3112d4e47dc4 + md5: edb0dca6bc32e4f4789199455a1dbeb8 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 constrains: - - zlib 1.3.1 *_1 + - zlib 1.3.1 *_2 license: Zlib license_family: Other purls: [] - size: 61574 - timestamp: 1716874187109 -- kind: conda - name: libzlib - version: 1.3.1 - build: hfb2fe0b_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-hfb2fe0b_1.conda - sha256: c34365dd37b0eab27b9693af32a1f7f284955517c2cc91f1b88a7ef4738ff03e - md5: 636077128927cf79fd933276dc3aed47 + size: 60963 + timestamp: 1727963148474 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-h8359307_2.conda + sha256: ce34669eadaba351cd54910743e6a2261b67009624dbc7daeeafdef93616711b + md5: 369964e85dc26bfe78f41399b366c435 depends: - __osx >=11.0 constrains: - - zlib 1.3.1 *_1 + - zlib 1.3.1 *_2 license: Zlib license_family: Other purls: [] - size: 46921 - timestamp: 1716874262512 -- kind: conda - name: llvm-openmp - version: 18.1.8 - build: hde57baf_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-18.1.8-hde57baf_1.conda - sha256: 7a76e2932ac77e6314bfa1c4ff83f617c8260313bfed1b8401b508ed3e9d70ba - md5: fe89757e3cd14bb1c6ebd68dac591363 + size: 46438 + timestamp: 1727963202283 +- conda: https://conda.anaconda.org/conda-forge/linux-64/llvm-openmp-19.1.6-h024ca30_0.conda + sha256: 9e385c2a8169d951cf153221fb7fbb3dc8f1e5ac77371edee7329f8721dbe1ae + md5: 96e42ccbd3c067c1713ff5f2d2169247 depends: - - __osx >=11.0 + - __glibc >=2.17,<3.0.a0 constrains: - - openmp 18.1.8|18.1.8.* + - openmp 19.1.6|19.1.6.* license: Apache-2.0 WITH LLVM-exception - license_family: APACHE purls: [] - size: 276263 - timestamp: 1723605341828 -- kind: conda - name: llvm-openmp - version: 18.1.8 - build: hf5423f3_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/llvm-openmp-18.1.8-hf5423f3_1.conda - sha256: 54b706eb3bdb1252d4fb3672d25eea4e7c66866c2a43418d895e30b34c9168ba - md5: 8782406a10201b67bd6476ca70cf92a8 + size: 3201572 + timestamp: 1734520399290 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-19.1.6-hdb05f8b_0.conda + sha256: a0f3e9139ab16f0a67b9d2bbabc15b78977168f4a5b5503fed4962dcb9a96102 + md5: 34fdeffa0555a1a56f38839415cc066c depends: - - libzlib >=1.3.1,<2.0a0 - - zstd >=1.5.6,<1.6.0a0 + - __osx >=11.0 constrains: - - openmp 18.1.8|18.1.8.* + - openmp 19.1.6|19.1.6.* license: Apache-2.0 WITH LLVM-exception - license_family: APACHE purls: [] - size: 58476497 - timestamp: 1723605385200 -- kind: pypi + size: 281251 + timestamp: 1734520462311 +- pypi: https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl name: loguru - version: 0.7.2 - url: https://files.pythonhosted.org/packages/03/0a/4f6fed21aa246c6b49b561ca55facacc2a44b87d65b8b92362a8e99ba202/loguru-0.7.2-py3-none-any.whl - sha256: 003d71e3d3ed35f0f8984898359d65b79e5b21943f78af86aa5491210429b8eb + version: 0.7.3 + sha256: 31a33c10c8e1e10422bfd431aeb5d351c7cf7fa671e3c4df004162264b28220c requires_dist: - - aiocontextvars>=0.2.0 ; python_full_version < '3.7' - colorama>=0.3.4 ; sys_platform == 'win32' + - aiocontextvars>=0.2.0 ; python_full_version < '3.7' - win32-setctime>=1.0.0 ; sys_platform == 'win32' - - mypy==0.910 ; python_full_version < '3.6' and extra == 'dev' + - pre-commit==4.0.1 ; python_full_version >= '3.9' and extra == 'dev' - tox==3.27.1 ; python_full_version < '3.8' and extra == 'dev' + - tox==4.23.2 ; python_full_version >= '3.8' and extra == 'dev' - pytest==6.1.2 ; python_full_version < '3.8' and extra == 'dev' + - pytest==8.3.2 ; python_full_version >= '3.8' and extra == 'dev' - pytest-cov==2.12.1 ; python_full_version < '3.8' and extra == 'dev' + - pytest-cov==5.0.0 ; python_full_version == '3.8.*' and extra == 'dev' + - pytest-cov==6.0.0 ; python_full_version >= '3.9' and extra == 'dev' + - pytest-mypy-plugins==1.9.3 ; python_full_version >= '3.6' and python_full_version < '3.8' and extra == 'dev' + - pytest-mypy-plugins==3.1.0 ; python_full_version >= '3.8' and extra == 'dev' - colorama==0.4.5 ; python_full_version < '3.8' and extra == 'dev' + - colorama==0.4.6 ; python_full_version >= '3.8' and extra == 'dev' - freezegun==1.1.0 ; python_full_version < '3.8' and extra == 'dev' - - mypy==0.971 ; python_full_version == '3.6.*' and extra == 'dev' - - pytest-mypy-plugins==1.9.3 ; python_full_version >= '3.6' and python_full_version < '3.8' and extra == 'dev' + - freezegun==1.5.0 ; python_full_version >= '3.8' and extra == 'dev' - exceptiongroup==1.1.3 ; python_full_version >= '3.7' and python_full_version < '3.11' and extra == 'dev' + - mypy==0.910 ; python_full_version < '3.6' and extra == 'dev' + - mypy==0.971 ; python_full_version == '3.6.*' and extra == 'dev' - mypy==1.4.1 ; python_full_version == '3.7.*' and extra == 'dev' - - pre-commit==3.4.0 ; python_full_version >= '3.8' and extra == 'dev' - - tox==4.11.0 ; python_full_version >= '3.8' and extra == 'dev' - - pytest==7.4.0 ; python_full_version >= '3.8' and extra == 'dev' - - pytest-cov==4.1.0 ; python_full_version >= '3.8' and extra == 'dev' - - pytest-mypy-plugins==3.0.0 ; python_full_version >= '3.8' and extra == 'dev' - - colorama==0.4.6 ; python_full_version >= '3.8' and extra == 'dev' - - freezegun==1.2.2 ; python_full_version >= '3.8' and extra == 'dev' - - mypy==1.5.1 ; python_full_version >= '3.8' and extra == 'dev' - - sphinx==7.2.5 ; python_full_version >= '3.9' and extra == 'dev' - - sphinx-autobuild==2021.3.14 ; python_full_version >= '3.9' and extra == 'dev' - - sphinx-rtd-theme==1.3.0 ; python_full_version >= '3.9' and extra == 'dev' - requires_python: '>=3.5' -- kind: conda - name: lz4-c - version: 1.9.4 - build: hb7217d7_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/lz4-c-1.9.4-hb7217d7_0.conda - sha256: fc343b8c82efe40819b986e29ba748366514e5ab94a1e1138df195af5f45fa24 - md5: 45505bec548634f7d05e02fb25262cb9 + - mypy==1.13.0 ; python_full_version >= '3.8' and extra == 'dev' + - sphinx==8.1.3 ; python_full_version >= '3.11' and extra == 'dev' + - sphinx-rtd-theme==3.0.2 ; python_full_version >= '3.11' and extra == 'dev' + - myst-parser==4.0.0 ; python_full_version >= '3.11' and extra == 'dev' + - build==1.2.2 ; python_full_version >= '3.11' and extra == 'dev' + - twine==6.0.1 ; python_full_version >= '3.11' and extra == 'dev' + requires_python: '>=3.5,<4.0' +- conda: https://conda.anaconda.org/conda-forge/linux-64/loguru-0.7.2-py312h7900ff3_2.conda + sha256: e5477e3fa7b4ef070e9ecae619cfc5845e14e3cdac8fbb2d158a03d51f967bef + md5: fddd3092f921be8e01b18f2a0266d98f depends: - - libcxx >=14.0.6 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: MIT + license_family: MIT + purls: + - pkg:pypi/loguru?source=project-defined-mapping + size: 123047 + timestamp: 1725349857430 +- conda: https://conda.anaconda.org/conda-forge/linux-64/lz4-c-1.10.0-h5888daf_1.conda + sha256: 47326f811392a5fd3055f0f773036c392d26fdb32e4d8e7a8197eed951489346 + md5: 9de5350a85c4a20c685259b889aa6393 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 license: BSD-2-Clause license_family: BSD purls: [] - size: 141188 - timestamp: 1674727268278 -- kind: conda - name: lz4-c - version: 1.9.4 - build: hcb278e6_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/lz4-c-1.9.4-hcb278e6_0.conda + size: 167055 + timestamp: 1733741040117 +- conda: https://conda.anaconda.org/conda-forge/linux-64/lz4-c-1.9.4-hcb278e6_0.conda sha256: 1b4c105a887f9b2041219d57036f72c4739ab9e9fe5a1486f094e58c76b31f5f md5: 318b08df404f9c9be5712aaa5a6f0bb0 depends: @@ -11558,13 +11212,28 @@ packages: purls: [] size: 143402 timestamp: 1674727076728 -- kind: conda - name: lzo - version: '2.10' - build: hd590300_1001 - build_number: 1001 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/lzo-2.10-hd590300_1001.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/lz4-c-1.10.0-h286801f_1.conda + sha256: 94d3e2a485dab8bdfdd4837880bde3dd0d701e2b97d6134b8806b7c8e69c8652 + md5: 01511afc6cc1909c5303cf31be17b44f + depends: + - __osx >=11.0 + - libcxx >=18 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 148824 + timestamp: 1733741047892 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/lz4-c-1.9.4-hb7217d7_0.conda + sha256: fc343b8c82efe40819b986e29ba748366514e5ab94a1e1138df195af5f45fa24 + md5: 45505bec548634f7d05e02fb25262cb9 + depends: + - libcxx >=14.0.6 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 141188 + timestamp: 1674727268278 +- conda: https://conda.anaconda.org/conda-forge/linux-64/lzo-2.10-hd590300_1001.conda sha256: 88433b98a9dd9da315400e7fb9cd5f70804cb17dca8b1c85163a64f90f584126 md5: ec7398d21e2651e0dcb0044d03b9a339 depends: @@ -11574,37 +11243,25 @@ packages: purls: [] size: 171416 timestamp: 1713515738503 -- kind: conda - name: markdown-it-py - version: 3.0.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-3.0.0-pyhd8ed1ab_0.conda - sha256: c041b0eaf7a6af3344d5dd452815cdc148d6284fec25a4fa3f4263b3a021e962 - md5: 93a8e71256479c62074356ef6ebf501b +- conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-3.0.0-pyhd8ed1ab_1.conda + sha256: 0fbacdfb31e55964152b24d5567e9a9996e1e7902fb08eb7d91b5fd6ce60803a + md5: fee3164ac23dfca50cfcc8b85ddefb81 depends: - mdurl >=0.1,<1 - - python >=3.8 + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/markdown-it-py?source=project-defined-mapping - size: 64356 - timestamp: 1686175179621 -- kind: conda - name: markupsafe - version: 2.1.5 - build: py312h024a12e_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/markupsafe-2.1.5-py312h024a12e_1.conda - sha256: 0e337724d82b19510c457246c319b35944580f31b3859359e1e8b9c53a14bc52 - md5: 66ee733dbdf8a9ca670f167bf5ea36b4 + size: 64430 + timestamp: 1733250550053 +- conda: https://conda.anaconda.org/conda-forge/linux-64/markupsafe-3.0.2-py312h178313f_1.conda + sha256: 4a6bf68d2a2b669fecc9a4a009abd1cf8e72c2289522ff00d81b5a6e51ae78f5 + md5: eb227c3e0bf58f5bd69c0532b157975b depends: - - __osx >=11.0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 constrains: - jinja2 >=3.0.0 @@ -11612,21 +11269,15 @@ packages: license_family: BSD purls: - pkg:pypi/markupsafe?source=project-defined-mapping - size: 25840 - timestamp: 1724959900292 -- kind: conda - name: markupsafe - version: 2.1.5 - build: py312h66e93f0_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/markupsafe-2.1.5-py312h66e93f0_1.conda - sha256: 5c88cd6e19437015de16bde30dd25791aca63ac9cbb8d66b65f365ecff1b235b - md5: 80b79ce0d3dc127e96002dfdcec0a2a5 + size: 24604 + timestamp: 1733219911494 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/markupsafe-3.0.2-py312h998013c_1.conda + sha256: 4aa997b244014d3707eeef54ab0ee497d12c0d0d184018960cce096169758283 + md5: 46e547061080fddf9cf95a0327e8aba6 depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=13 + - __osx >=11.0 - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 constrains: - jinja2 >=3.0.0 @@ -11634,18 +11285,14 @@ packages: license_family: BSD purls: - pkg:pypi/markupsafe?source=project-defined-mapping - size: 26772 - timestamp: 1724959630484 -- kind: conda - name: matplotlib - version: 3.9.2 - build: py312h1f38498_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-3.9.2-py312h1f38498_0.conda - sha256: d5d332f2bb301eec1e43d4702f5332d8c32953ab7974e74da99a3fef94c00d86 - md5: dddd7fd8834329a4436deea957022433 - depends: - - matplotlib-base >=3.9.2,<3.9.3.0a0 + size: 24048 + timestamp: 1733219945697 +- conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-3.9.4-py312h7900ff3_0.conda + sha256: c191931cfad4048c4a31911ea0242679ddb240963df0b85f13a380108033c7f0 + md5: 2b1df96ad1f394cb0d3e67a930ac19c0 + depends: + - matplotlib-base >=3.9.4,<3.9.5.0a0 + - pyside6 >=6.7.2 - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 - tornado >=5 @@ -11653,19 +11300,13 @@ packages: license_family: PSF purls: - pkg:pypi/matplotlib?source=project-defined-mapping - size: 8884 - timestamp: 1723759792668 -- kind: conda - name: matplotlib - version: 3.9.2 - build: py312h7900ff3_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-3.9.2-py312h7900ff3_0.conda - sha256: b728fe3bb3525fc2a2d37b81e5fee1c697fa6ce380da8c1dbd4378ff0a3bc299 - md5: 44c07eccf73f549b8ea5c9aacfe3ad0a - depends: - - matplotlib-base >=3.9.2,<3.9.3.0a0 - - pyside6 >=6.7.2 + size: 16942 + timestamp: 1734120430188 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-3.9.4-py312h1f38498_0.conda + sha256: 61d125fbf8ea3cdf1b2e573767301ea24b293da8086d79f6d1bb76d4af4d0dee + md5: 6f8e47a520d0d67e989bb5f244157d39 + depends: + - matplotlib-base >=3.9.4,<3.9.5.0a0 - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 - tornado >=5 @@ -11673,49 +11314,39 @@ packages: license_family: PSF purls: - pkg:pypi/matplotlib?source=project-defined-mapping - size: 8747 - timestamp: 1723759696471 -- kind: conda - name: matplotlib-base - version: 3.9.2 - build: py312h32d6e5a_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-base-3.9.2-py312h32d6e5a_0.conda - sha256: 508798a3d84d6cb2d17f8025ff3be5949351b3ab680e7a5acebc1166abb2d157 - md5: 2649a9158eb3183c8de0116b9fd6aada + size: 17082 + timestamp: 1734120634757 +- conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-base-3.10.0-py312hd3ec401_0.conda + sha256: eed67ea988883a3c05160c6d02f34f5a4b6405713cf699d9117eb68fb4743017 + md5: c27a17a8c54c0d35cf83bbc0de8f7f77 depends: - - __osx >=11.0 - - certifi >=2020.06.20 + - __glibc >=2.17,<3.0.a0 - contourpy >=1.0.1 - cycler >=0.10 - fonttools >=4.22.0 - freetype >=2.12.1,<3.0a0 - kiwisolver >=1.3.1 - - libcxx >=16 + - libgcc >=13 + - libstdcxx >=13 - numpy >=1.19,<3 - numpy >=1.23 - packaging >=20.0 - pillow >=8 - pyparsing >=2.3.1 - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - python-dateutil >=2.7 - python_abi 3.12.* *_cp312 - qhull >=2020.2,<2020.3.0a0 + - tk >=8.6.13,<8.7.0a0 license: PSF-2.0 license_family: PSF purls: - pkg:pypi/matplotlib?source=project-defined-mapping - size: 7864592 - timestamp: 1723759750829 -- kind: conda - name: matplotlib-base - version: 3.9.2 - build: py312h854627b_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-base-3.9.2-py312h854627b_0.conda - sha256: ae075b97ce43439a7a914bf478564927a3dfe00724fb69555947cc3bae737a11 - md5: a57b0ae7c0aac603839a4e83a3e997d6 + size: 8210655 + timestamp: 1734380560683 +- conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-base-3.9.4-py312hd3ec401_0.conda + sha256: aaa7f459f89c9dcd5bb6a8189d35e5d959c898cdb5ea200374fe2172703560cd + md5: b39b563d1a75c7b9b623e2a2b42d9e6d depends: - __glibc >=2.17,<3.0.a0 - certifi >=2020.06.20 @@ -11724,8 +11355,8 @@ packages: - fonttools >=4.22.0 - freetype >=2.12.1,<3.0a0 - kiwisolver >=1.3.1 - - libgcc-ng >=12 - - libstdcxx-ng >=12 + - libgcc >=13 + - libstdcxx >=13 - numpy >=1.19,<3 - numpy >=1.23 - packaging >=20.0 @@ -11740,208 +11371,191 @@ packages: license_family: PSF purls: - pkg:pypi/matplotlib?source=project-defined-mapping - size: 7904910 - timestamp: 1723759675614 -- kind: conda - name: matplotlib-inline - version: 0.1.7 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/matplotlib-inline-0.1.7-pyhd8ed1ab_0.conda - sha256: 7ea68676ea35fbb095420bbcc1c82c4767b8be7bb56abb6989b7f89d957a3bab - md5: 779345c95648be40d22aaa89de7d4254 + size: 7893167 + timestamp: 1734120409482 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-base-3.10.0-py312hdbc7e53_0.conda + sha256: 8e53e3e3a7c81aed357b92e5dc0be0199a0081a2ce9cc726f5afba946ed77796 + md5: af50086982d6939b23d2656c21172be0 depends: - - python >=3.6 + - __osx >=11.0 + - contourpy >=1.0.1 + - cycler >=0.10 + - fonttools >=4.22.0 + - freetype >=2.12.1,<3.0a0 + - kiwisolver >=1.3.1 + - libcxx >=18 + - numpy >=1.19,<3 + - numpy >=1.23 + - packaging >=20.0 + - pillow >=8 + - pyparsing >=2.3.1 + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python-dateutil >=2.7 + - python_abi 3.12.* *_cp312 + - qhull >=2020.2,<2020.3.0a0 + license: PSF-2.0 + license_family: PSF + purls: + - pkg:pypi/matplotlib?source=project-defined-mapping + size: 8019543 + timestamp: 1734380918722 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-base-3.9.4-py312hdbc7e53_0.conda + sha256: db1f9351d0129482ff35fabea4b43a22cb4fabe93f7403673d758433a51e40ea + md5: c35cffd51b15063f0e37f71c7c3f5b9a + depends: + - __osx >=11.0 + - certifi >=2020.06.20 + - contourpy >=1.0.1 + - cycler >=0.10 + - fonttools >=4.22.0 + - freetype >=2.12.1,<3.0a0 + - kiwisolver >=1.3.1 + - libcxx >=18 + - numpy >=1.19,<3 + - numpy >=1.23 + - packaging >=20.0 + - pillow >=8 + - pyparsing >=2.3.1 + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python-dateutil >=2.7 + - python_abi 3.12.* *_cp312 + - qhull >=2020.2,<2020.3.0a0 + license: PSF-2.0 + license_family: PSF + purls: + - pkg:pypi/matplotlib?source=project-defined-mapping + size: 7794869 + timestamp: 1734120591452 +- conda: https://conda.anaconda.org/conda-forge/noarch/matplotlib-inline-0.1.7-pyhd8ed1ab_1.conda + sha256: 69b7dc7131703d3d60da9b0faa6dd8acbf6f6c396224cf6aef3e855b8c0c41c6 + md5: af6ab708897df59bd6e7283ceab1b56b + depends: + - python >=3.9 - traitlets license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/matplotlib-inline?source=project-defined-mapping - size: 14599 - timestamp: 1713250613726 -- kind: conda - name: mdit-py-plugins - version: 0.4.1 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/mdit-py-plugins-0.4.1-pyhd8ed1ab_0.conda - sha256: 3525b8e4598ccaab913a2bcb8a63998c6e5cc1870d0c5a5b4e867aa69c720aa1 - md5: eb90dd178bcdd0260dfaa6e1cbccf042 + size: 14467 + timestamp: 1733417051523 +- conda: https://conda.anaconda.org/conda-forge/noarch/mdit-py-plugins-0.4.2-pyhd8ed1ab_1.conda + sha256: c63ed79d9745109c0a70397713b0c07f06e7d3561abcb122cfc80a141ab3b449 + md5: af2060041d4f3250a7eb6ab3ec0e549b depends: - markdown-it-py >=1.0.0,<4.0.0 - - python >=3.8 + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/mdit-py-plugins?source=project-defined-mapping - size: 41972 - timestamp: 1715570303416 -- kind: conda - name: mdurl - version: 0.1.2 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_0.conda - sha256: 64073dfb6bb429d52fff30891877b48c7ec0f89625b1bf844905b66a81cce6e1 - md5: 776a8dd9e824f77abac30e6ef43a8f7a + size: 42180 + timestamp: 1733854816517 +- conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda + sha256: 78c1bbe1723449c52b7a9df1af2ee5f005209f67e40b6e1d3c7619127c43b1c7 + md5: 592132998493b3ff25fd7479396e8351 depends: - - python >=3.6 + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/mdurl?source=project-defined-mapping - size: 14680 - timestamp: 1704317789138 -- kind: conda - name: mesa-khr-devel-cos7-x86_64 - version: 18.3.4 - build: h9b0a68f_1105 - build_number: 1105 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/mesa-khr-devel-cos7-x86_64-18.3.4-h9b0a68f_1105.tar.bz2 - sha256: 2a7bf7d5493e312747827ab78997f063861c0989b50fc121070bc5623907a5f5 - md5: c2e7b967a47f1ed33b6ad16268986ee1 + size: 14465 + timestamp: 1733255681319 +- conda: https://conda.anaconda.org/conda-forge/noarch/mesa-khr-devel-cos7-x86_64-18.3.4-ha675448_1106.tar.bz2 + sha256: 1cb24f5273cd675bcb6e5da1cd7d4f1567217969bed9069dfda40a7c6baa729f + md5: bf8e0ce6388204f37e636a4810919897 depends: - sysroot_linux-64 2.17.* license: MIT license_family: MIT purls: [] - size: 7694 - timestamp: 1627497668341 -- kind: conda - name: mesa-libegl-cos7-x86_64 - version: 18.3.4 - build: h9b0a68f_1105 - build_number: 1105 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/mesa-libegl-cos7-x86_64-18.3.4-h9b0a68f_1105.tar.bz2 - sha256: c8eea65cf45978a4554fefca2af17725ae1edb7ee2fa1960f7345e1f5371e614 - md5: c0057ef5818cafdd295a68bbf4a3ed6f + size: 8402 + timestamp: 1726574663941 +- conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libegl-cos7-x86_64-18.3.4-ha675448_1106.tar.bz2 + sha256: df0f06c6064658b179d4a6fc6652edf81258fb049ae18e0536260d8503b8fcf1 + md5: 6c84b52d678e43a40390c549e58fa77b depends: - - mesa-libgbm-cos7-x86_64 ==18.3.4 *_1105 + - mesa-libgbm-cos7-x86_64 ==18.3.4 *_1106 - sysroot_linux-64 2.17.* license: MIT license_family: MIT purls: [] - size: 112399 - timestamp: 1627504564196 -- kind: conda - name: mesa-libegl-devel-cos7-x86_64 - version: 18.3.4 - build: h9b0a68f_1105 - build_number: 1105 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/mesa-libegl-devel-cos7-x86_64-18.3.4-h9b0a68f_1105.tar.bz2 - sha256: 326602cbdd700f95f052a0c01ac9af64e41908250d62d971ec13beac01dbd543 - md5: 80314954275d3c48b34b2f216217e954 + size: 113264 + timestamp: 1726585432404 +- conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libegl-devel-cos7-x86_64-18.3.4-ha675448_1106.tar.bz2 + sha256: 1dbd543823b5d38e54e8638227efbd06c539142ecfc8ab5ac12f5ad120d39357 + md5: a71e7bc7e4154b85951222baf47df523 depends: - - mesa-khr-devel-cos7-x86_64 ==18.3.4 *_1105 - - mesa-libegl-cos7-x86_64 ==18.3.4 *_1105 + - mesa-khr-devel-cos7-x86_64 ==18.3.4 *_1106 + - mesa-libegl-cos7-x86_64 ==18.3.4 *_1106 - sysroot_linux-64 2.17.* license: MIT license_family: MIT purls: [] - size: 20079 - timestamp: 1627506329741 -- kind: conda - name: mesa-libgbm-cos7-x86_64 - version: 18.3.4 - build: h9b0a68f_1105 - build_number: 1105 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/mesa-libgbm-cos7-x86_64-18.3.4-h9b0a68f_1105.tar.bz2 - sha256: bc43fc4ed1b07991e5597386e0a9cbbf5dc1e577026b84c57e09c0671656c685 - md5: d4257e612733f6a1e04bccff55f256e9 + size: 20864 + timestamp: 1726585755356 +- conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libgbm-cos7-x86_64-18.3.4-ha675448_1106.tar.bz2 + sha256: d5881e47917c58cd8d6a61b73e6bf8d5e586a622ba6c3c86f7c774bb7336155b + md5: 85c57d12a7fe6a16a8979d3d2f2d7b15 depends: - - libdrm-cos7-x86_64 >=2.4.83 *_1105 - - mesa-libglapi-cos7-x86_64 ==18.3.4 *_1105 + - libdrm-cos7-x86_64 >=2.4.83 *_1106 + - mesa-libglapi-cos7-x86_64 ==18.3.4 *_1106 - sysroot_linux-64 2.17.* license: MIT license_family: MIT purls: [] - size: 32590 - timestamp: 1627501160814 -- kind: conda - name: mesa-libglapi-cos7-x86_64 - version: 18.3.4 - build: h9b0a68f_1105 - build_number: 1105 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/mesa-libglapi-cos7-x86_64-18.3.4-h9b0a68f_1105.tar.bz2 - sha256: 2eb8503f0f14692f46a767c108f95a12c3871dfcd23cb1988441b1d31233f93c - md5: 4e400eb4ecbcd7d69cdbb5c761e348ae + size: 33387 + timestamp: 1726581574491 +- conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libglapi-cos7-x86_64-18.3.4-ha675448_1106.tar.bz2 + sha256: 5e3eab3a1b29f0fb33d682549eea70c58084600ccfddb5bcf10b02dd8ebc9ae5 + md5: 49b1e8b781dc8b978617f706aa93823a depends: - sysroot_linux-64 2.17.* license: MIT license_family: MIT purls: [] - size: 46161 - timestamp: 1627493667796 -- kind: conda - name: mesa-libglu-cos7-x86_64 - version: 9.0.0 - build: h9b0a68f_1105 - build_number: 1105 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/mesa-libglu-cos7-x86_64-9.0.0-h9b0a68f_1105.tar.bz2 - sha256: b569af7aba3d08dddc5b4d205872da1458b6bb6a252ca749ad37e957c3a32036 - md5: fa5ea3653ea19b9ececc4a9271c67c55 + size: 46982 + timestamp: 1726573576112 +- conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libglu-cos7-x86_64-9.0.0-ha675448_1106.tar.bz2 + sha256: 403fc2403b988343b9d65cce7eab2a65de30fe5aa5365494c381cb9b0b79b913 + md5: a864b3235d2cf8cb6299671fa53e4b9a depends: - - libdrm-cos7-x86_64 >=2.4.83 *_1105 - - libglvnd-glx-cos7-x86_64 >=1.0.1 *_1105 - - mesa-libglapi-cos7-x86_64 ==18.3.4 *_1105 + - libdrm-cos7-x86_64 >=2.4.83 *_1106 + - libglvnd-glx-cos7-x86_64 >=1.0.1 *_1106 + - mesa-libglapi-cos7-x86_64 ==18.3.4 *_1106 - sysroot_linux-64 2.17.* license: MIT license_family: MIT purls: [] - size: 224029 - timestamp: 1708951893434 -- kind: conda - name: mesa-libglu-devel-cos7-x86_64 - version: 9.0.0 - build: h9b0a68f_1105 - build_number: 1105 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/mesa-libglu-devel-cos7-x86_64-9.0.0-h9b0a68f_1105.tar.bz2 - sha256: 50631fb84d3ed5ae357db5c2ec9a00ba3af1e223ec1447f1b391225993fd6de2 - md5: c5ca7b9bd6cbc56f9cf14d3016fdae29 + size: 223920 + timestamp: 1726585443822 +- conda: https://conda.anaconda.org/conda-forge/noarch/mesa-libglu-devel-cos7-x86_64-9.0.0-ha675448_1106.tar.bz2 + sha256: 36fdbebf9993c6d58ffcd74f352b217c7aa133ddbddae4432677ee8e2eba71c7 + md5: 61670dc15738ce307a207d7ef7d531b7 depends: - - mesa-khr-devel-cos7-x86_64 ==18.3.4 *_1105 - - mesa-libglu-cos7-x86_64 ==9.0.0 *_1105 + - mesa-khr-devel-cos7-x86_64 ==18.3.4 *_1106 + - mesa-libglu-cos7-x86_64 ==9.0.0 *_1106 - sysroot_linux-64 2.17.* license: MIT license_family: MIT purls: [] - size: 10552 - timestamp: 1708952118905 -- kind: conda - name: mesalib - version: 24.2.2 - build: h4e3793c_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/mesalib-24.2.2-h4e3793c_0.conda - sha256: 6da8e71c3bdc4b459d7ddde31cde5365cce23aae9276c148e724d4802e118bd8 - md5: 75cb4b48d50df4c1ce32ce19700f0007 + size: 10527 + timestamp: 1726587697449 +- conda: https://conda.anaconda.org/conda-forge/linux-64/mesalib-24.1.0-hfa94a56_0.conda + sha256: 946f6c801014e1001b3bd0076733f5e65d56d1cd325064c47ef0e10b4e44699b + md5: 4e4e246f38bc23fbea7654d28776d915 depends: - __glibc >=2.17,<3.0.a0 - elfutils >=0.191,<0.192.0a0 - - libdrm >=2.4.123,<2.5.0a0 - - libexpat >=2.6.3,<3.0a0 - - libgcc >=13 - - libllvm18 >=18.1.8,<18.2.0a0 - - libstdcxx >=13 - - libxcb >=1.16,<1.17.0a0 - - libzlib >=1.3.1,<2.0a0 + - libdrm >=2.4.120,<2.5.0a0 + - libexpat >=2.6.2,<3.0a0 + - libgcc-ng >=12 + - libllvm18 >=18.1.5,<18.2.0a0 + - libstdcxx-ng >=12 + - libxcb >=1.15,<1.16.0a0 + - libzlib >=1.2.13,<2.0.0a0 - ncurses >=6.5,<7.0a0 - xorg-glproto - xorg-libx11 >=1.8.9,<2.0a0 @@ -11949,7 +11563,6 @@ packages: - xorg-libxext >=1.3.4,<2.0a0 - xorg-libxfixes - xorg-libxrandr - - xorg-libxxf86vm >=1.1.5,<2.0a0 - xorg-xextproto >=7.3.0,<8.0a0 - xorg-xf86vidmodeproto - zstd >=1.5.6,<1.6.0a0 @@ -11958,32 +11571,49 @@ packages: license: MIT license_family: MIT purls: [] - size: 3984032 - timestamp: 1725594063582 -- kind: conda - name: mistune - version: 3.0.2 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/mistune-3.0.2-pyhd8ed1ab_0.conda - sha256: f95cb70007e3cc2ba44e17c29a056b499e6dadf08746706d0c817c8e2f47e05c - md5: 5cbee699846772cc939bef23a0d524ed + size: 3971785 + timestamp: 1716421102685 +- conda: https://conda.anaconda.org/conda-forge/linux-64/mesalib-24.3.1-h0b126fc_0.conda + sha256: 603cb5aab8ce80d66e17655a5663f926f153ee5c2c9b3dfd7a2c138797c743d8 + md5: 12d32a61fb1163e4584731956592cf79 depends: - - python >=3.7 + - __glibc >=2.17,<3.0.a0 + - elfutils >=0.192,<0.193.0a0 + - libdrm >=2.4.123,<2.5.0a0 + - libexpat >=2.6.4,<3.0a0 + - libgcc >=13 + - libllvm19 >=19.1.5,<19.2.0a0 + - libstdcxx >=13 + - libxcb >=1.17.0,<2.0a0 + - libzlib >=1.3.1,<2.0a0 + - ncurses >=6.5,<7.0a0 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxdamage >=1.1.6,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + - xorg-libxfixes >=6.0.1,<7.0a0 + - xorg-libxrandr >=1.5.4,<2.0a0 + - xorg-libxshmfence >=1.3.2,<2.0a0 + - xorg-libxxf86vm >=1.1.5,<2.0a0 + - zstd >=1.5.6,<1.6.0a0 + track_features: + - mesalib + license: MIT + license_family: MIT + purls: [] + size: 4007457 + timestamp: 1733400240736 +- conda: https://conda.anaconda.org/conda-forge/noarch/mistune-3.0.2-pyhd8ed1ab_1.conda + sha256: 0a9faaf1692b74f321cedbd37a44f108a1ec3f5d9638bc5bbf860cb3b6ff6db4 + md5: c46df05cae629e55426773ac1f85d68f + depends: + - python >=3.9 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/mistune?source=project-defined-mapping - size: 66022 - timestamp: 1698947249750 -- kind: conda - name: mkl - version: 2023.2.0 - build: h84fe81f_50496 - build_number: 50496 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/mkl-2023.2.0-h84fe81f_50496.conda + size: 65901 + timestamp: 1733258822603 +- conda: https://conda.anaconda.org/conda-forge/linux-64/mkl-2023.2.0-h84fe81f_50496.conda sha256: 046073737bf73153b0c39e343b197cdf0b7867d336962369407465a17ea5979a md5: 81d4a1a57d618adf0152db973d93b2ad depends: @@ -11996,55 +11626,37 @@ packages: purls: [] size: 164432797 timestamp: 1698350676814 -- kind: conda - name: ml_dtypes - version: 0.4.0 - build: py312hcd31e36_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/ml_dtypes-0.4.0-py312hcd31e36_2.conda - sha256: 3931aef8f1e04f2fd9cff55a0c8dd76f818a3eb4fad5ef6cfd83649d14a663e4 - md5: 70b338acc912c1989a36ed8511f884a7 +- conda: https://conda.anaconda.org/conda-forge/linux-64/ml_dtypes-0.5.0-py312hf9745cd_0.conda + sha256: 559c14640ce8e3f2270da6130ba50ae624f3db56176fad29a5436b2dec3fc3b2 + md5: 8ca779f3f30b00181aeee820fe8b22d5 depends: - - __osx >=11.0 - - libcxx >=17 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 - numpy >=1.19,<3 - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 license: MPL-2.0 AND Apache-2.0 purls: - pkg:pypi/ml-dtypes?source=project-defined-mapping - size: 123771 - timestamp: 1725475270272 -- kind: conda - name: ml_dtypes - version: 0.4.0 - build: py312hf9745cd_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/ml_dtypes-0.4.0-py312hf9745cd_2.conda - sha256: 0dd6a676396af5f30bbf0b872bfea2716a11585731385d0e145b55fa2958336e - md5: c070bbf2a3c9e2e6d2c64b219e2e78da + size: 290054 + timestamp: 1726376440408 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ml_dtypes-0.5.0-py312hcd31e36_0.conda + sha256: b581ad4531beb3d782c2990ec1f5f5e36244b097337ac23598653fad3ff16e94 + md5: 7bc100120bdda5fcb7c1f64589e07375 depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=13 - - libstdcxx >=13 + - __osx >=11.0 + - libcxx >=17 - numpy >=1.19,<3 - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 license: MPL-2.0 AND Apache-2.0 purls: - pkg:pypi/ml-dtypes?source=project-defined-mapping - size: 167320 - timestamp: 1725475244129 -- kind: conda - name: mpc - version: 1.3.1 - build: h24ddda3_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/mpc-1.3.1-h24ddda3_1.conda + size: 202179 + timestamp: 1726376547204 +- conda: https://conda.anaconda.org/conda-forge/linux-64/mpc-1.3.1-h24ddda3_1.conda sha256: 1bf794ddf2c8b3a3e14ae182577c624fa92dea975537accff4bc7e5fea085212 md5: aa14b9a5196a6d8dd364164b7ce56acf depends: @@ -12053,16 +11665,11 @@ packages: - libgcc >=13 - mpfr >=4.2.1,<5.0a0 license: LGPL-3.0-or-later + license_family: LGPL purls: [] size: 116777 timestamp: 1725629179524 -- kind: conda - name: mpc - version: 1.3.1 - build: h8f1351a_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/mpc-1.3.1-h8f1351a_1.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/mpc-1.3.1-h8f1351a_1.conda sha256: 2700899ad03302a1751dbf2bca135407e470dd83ac897ab91dd8675d4300f158 md5: a5635df796b71f6ca400fc7026f50701 depends: @@ -12070,68 +11677,102 @@ packages: - gmp >=6.3.0,<7.0a0 - mpfr >=4.2.1,<5.0a0 license: LGPL-3.0-or-later + license_family: LGPL purls: [] size: 104766 timestamp: 1725629165420 -- kind: conda - name: mpfr - version: 4.2.1 - build: h1cfca0a_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/mpfr-4.2.1-h1cfca0a_2.conda - sha256: 4ed8519e032d1f5be5e5c1324d630aee13e81498b35999a4ff8bb7f38c3dc44e - md5: 56b5b819e0ad2c08a67e630211629896 +- conda: https://conda.anaconda.org/conda-forge/linux-64/mpfr-4.2.1-h90cbb55_3.conda + sha256: f25d2474dd557ca66c6231c8f5ace5af312efde1ba8290a6ea5e1732a4e669c0 + md5: 2eeb50cab6652538eee8fc0bc3340c81 depends: - - __osx >=11.0 + - __glibc >=2.17,<3.0.a0 - gmp >=6.3.0,<7.0a0 + - libgcc >=13 license: LGPL-3.0-only license_family: LGPL purls: [] - size: 346298 - timestamp: 1722132645001 -- kind: conda - name: mpfr - version: 4.2.1 - build: h38ae2d0_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/mpfr-4.2.1-h38ae2d0_2.conda - sha256: 016981edf60146a6c553e22457ca3d121ff52b98d24b2191b82ef2aefa89cc7f - md5: 168e18a2bba4f8520e6c5e38982f5847 + size: 634751 + timestamp: 1725746740014 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/mpfr-4.2.1-hb693164_3.conda + sha256: 4463e4e2aba7668e37a1b8532859191b4477a6f3602a5d6b4d64ad4c4baaeac5 + md5: 4e4ea852d54cc2b869842de5044662fb depends: - - __glibc >=2.17,<3.0.a0 + - __osx >=11.0 - gmp >=6.3.0,<7.0a0 - - libgcc-ng >=12 license: LGPL-3.0-only license_family: LGPL purls: [] - size: 640978 - timestamp: 1722132616744 -- kind: conda - name: mpmath - version: 1.3.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda - sha256: a4f025c712ec1502a55c471b56a640eaeebfce38dd497d5a1a33729014cac47a - md5: dbf6e2d89137da32fa6670f3bffc024e + size: 345517 + timestamp: 1725746730583 +- conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_1.conda + sha256: 7d7aa3fcd6f42b76bd711182f3776a02bef09a68c5f117d66b712a6d81368692 + md5: 3585aa87c43ab15b167b574cd73b057b depends: - - python >=3.6 + - python >=3.9 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/mpmath?source=project-defined-mapping + size: 439705 + timestamp: 1733302781386 +- conda: https://conda.anaconda.org/conda-forge/noarch/msgpack-numpy-0.4.8-pyhd8ed1ab_1.conda + sha256: 1ae2b713fefd2bee98173bcf1539e1087aede05dceb3f445f771c03117bb59d0 + md5: 9b59e2a73c3a4503031a4caf6851ac34 + depends: + - msgpack-python >=0.5.2 + - numpy >=1.9.0 + - python >=3.9 license: BSD-3-Clause license_family: BSD purls: - - pkg:pypi/mpmath?source=project-defined-mapping - size: 438339 - timestamp: 1678228210181 -- kind: conda - name: munkres - version: 1.1.4 - build: pyh9f0ad1d_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/munkres-1.1.4-pyh9f0ad1d_0.tar.bz2 + - pkg:pypi/msgpack-numpy?source=project-defined-mapping + size: 12657 + timestamp: 1734421154030 +- conda: https://conda.anaconda.org/conda-forge/linux-64/msgpack-python-1.1.0-py312h68727a3_0.conda + sha256: 4bc53333774dea1330643b7e23aa34fd6880275737fc2e07491795872d3af8dd + md5: 5c9b020a3f86799cdc6115e55df06146 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/msgpack?source=project-defined-mapping + size: 105271 + timestamp: 1725975182669 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/msgpack-python-1.1.0-py312h6142ec9_0.conda + sha256: 2b8c22f8a4e0031c2d6fa81d32814c8afdaf7e7fe2e681bf2369a35ff3eab1fd + md5: 0dfc3750cc6bbc463d72c0b727e60d8a + depends: + - __osx >=11.0 + - libcxx >=17 + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/msgpack?source=project-defined-mapping + size: 90793 + timestamp: 1725975279147 +- conda: https://conda.anaconda.org/conda-forge/linux-64/multidict-6.1.0-py312h178313f_2.conda + sha256: b05bc8252a6e957bf4a776ed5e0e61d1ba88cdc46ccb55890c72cc58b10371f4 + md5: 5b5e3267d915a107eca793d52e1b780a + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/multidict?source=project-defined-mapping + size: 61507 + timestamp: 1733913288935 +- conda: https://conda.anaconda.org/conda-forge/noarch/munkres-1.1.4-pyh9f0ad1d_0.tar.bz2 sha256: f86fb22b58e93d04b6f25e0d811b56797689d598788b59dcb47f59045b568306 md5: 2ba8498c1018c1e9c61eb99b973dfe19 depends: @@ -12142,14 +11783,9 @@ packages: - pkg:pypi/munkres?source=project-defined-mapping size: 12452 timestamp: 1600387789153 -- kind: conda - name: mysql-common - version: 9.0.1 - build: h70512c7_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/mysql-common-9.0.1-h70512c7_0.conda - sha256: 4417ba9daf1f818e62e399dc9ab33fcd12741d79d19db0884394cc9c766ae78d - md5: c567b6fa201bc424e84f1e70f7a36095 +- conda: https://conda.anaconda.org/conda-forge/linux-64/mysql-common-8.3.0-h70512c7_5.conda + sha256: 09296629aab020fb131c8256d8683087769c53ce5197ca3a2abe040bfb285d88 + md5: 4b652e3e572cbb3f297e77c96313faea depends: - __glibc >=2.17,<3.0.a0 - libgcc-ng >=12 @@ -12158,55 +11794,68 @@ packages: license: GPL-2.0-or-later license_family: GPL purls: [] - size: 612947 - timestamp: 1723209940114 -- kind: conda - name: mysql-libs - version: 9.0.1 - build: ha479ceb_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/mysql-libs-9.0.1-ha479ceb_0.conda - sha256: f4bea852a48a2168d2bdb73c9be6e3d0ba30525a7e4f0472e899a0773206a8a9 - md5: 6fd406aef37faad86bd7f37a94fb6f8a + size: 780145 + timestamp: 1721386057930 +- conda: https://conda.anaconda.org/conda-forge/linux-64/mysql-common-9.0.1-h266115a_3.conda + sha256: 3190048edb948829d551591bb4269582172e2ba0fb936664c01d29a4deefe4b1 + md5: 9411c61ff1070b5e065b32840c39faa5 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + - openssl >=3.4.0,<4.0a0 + license: GPL-2.0-or-later + license_family: GPL + purls: [] + size: 630543 + timestamp: 1733494450594 +- conda: https://conda.anaconda.org/conda-forge/linux-64/mysql-libs-8.3.0-ha479ceb_5.conda + sha256: c6e9b0961b6877eda8c300b12a0939c81f403a4eb5c0db802e13130fd5a3a059 + md5: 82776ee8145b9d1fd6546604de4b351d depends: - __glibc >=2.17,<3.0.a0 - libgcc-ng >=12 - libstdcxx-ng >=12 - libzlib >=1.3.1,<2.0a0 - - mysql-common 9.0.1 h70512c7_0 + - mysql-common 8.3.0 h70512c7_5 - openssl >=3.3.1,<4.0a0 - zstd >=1.5.6,<1.6.0a0 license: GPL-2.0-or-later license_family: GPL purls: [] - size: 1368619 - timestamp: 1723210027997 -- kind: conda - name: natsort - version: 8.4.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/natsort-8.4.0-pyhd8ed1ab_0.conda - sha256: 1d5c42c7f271779e450d095c49598ce7214a7089f229e59f0b78d8703de67059 - md5: 70959cd1db3cf77b2a27a0836cfd08a7 + size: 1532137 + timestamp: 1721386157918 +- conda: https://conda.anaconda.org/conda-forge/linux-64/mysql-libs-9.0.1-he0572af_3.conda + sha256: 69527c08c444cae605545b42f67ea4e3f90cd7128fad8ad77d17a1cdc06ad767 + md5: dd9da69dd4c2bf798c0b8bd4786cafb5 depends: - - python >=3.7 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + - libzlib >=1.3.1,<2.0a0 + - mysql-common 9.0.1 h266115a_3 + - openssl >=3.4.0,<4.0a0 + - zstd >=1.5.6,<1.6.0a0 + license: GPL-2.0-or-later + license_family: GPL + purls: [] + size: 1368301 + timestamp: 1733494547340 +- conda: https://conda.anaconda.org/conda-forge/noarch/natsort-8.4.0-pyh29332c3_1.conda + sha256: 594ae12c32f163f6d312e38de41311a89e476544613df0c1d048f699721621d7 + md5: 0aa03903d33997f3886be58abc890aef + depends: + - python >=3.9 + - python license: MIT license_family: MIT purls: - pkg:pypi/natsort?source=project-defined-mapping - size: 37338 - timestamp: 1687263265777 -- kind: conda - name: nbclient - version: 0.10.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/nbclient-0.10.0-pyhd8ed1ab_0.conda - sha256: 589d72d36d61a23b39d6fff2c488f93e29e20de4fc6f5d315b5f2c16e81028bf - md5: 15b51397e0fe8ea7d7da60d83eb76ebc + size: 39002 + timestamp: 1733880463101 +- conda: https://conda.anaconda.org/conda-forge/noarch/nbclient-0.10.1-pyhd8ed1ab_0.conda + sha256: 564e22c4048f2f00c7ee79417dea364f95cf069a1f2565dc26d5ece1fc3fd779 + md5: 3ee79082e59a28e1db11e2a9c3bcd85a depends: - jupyter_client >=6.1.12 - jupyter_core >=4.12,!=5.0.* @@ -12217,37 +11866,23 @@ packages: license_family: BSD purls: - pkg:pypi/nbclient?source=project-defined-mapping - size: 27851 - timestamp: 1710317767117 -- kind: conda - name: nbconvert - version: 7.16.4 - build: hd8ed1ab_1 - build_number: 1 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/nbconvert-7.16.4-hd8ed1ab_1.conda - sha256: e014e8a583ca2f2fc751bf9093ee95bfd203bd189bafe0f512c0262fece69bce - md5: ab83e3b9ca2b111d8f332e9dc8b2170f - depends: - - nbconvert-core 7.16.4 pyhd8ed1ab_1 - - nbconvert-pandoc 7.16.4 hd8ed1ab_1 + size: 27878 + timestamp: 1732882434219 +- conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-7.16.4-hd8ed1ab_2.conda + sha256: 034ae98c183f260307d3a9775fa75871dd6ab00b2bce52c6cd417dd8cc86fc4a + md5: 9337002f0dd2fcb8e1064f8023c8e0c0 + depends: + - nbconvert-core 7.16.4 pyhff2d567_2 + - nbconvert-pandoc 7.16.4 hd8ed1ab_2 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/nbconvert?source=project-defined-mapping - size: 8335 - timestamp: 1718135538730 -- kind: conda - name: nbconvert-core - version: 7.16.4 - build: pyhd8ed1ab_1 - build_number: 1 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/nbconvert-core-7.16.4-pyhd8ed1ab_1.conda - sha256: 074d858c5808e0a832acc0da37cd70de1565e8d6e17a62d5a11b3902b5e78319 - md5: e2d2abb421c13456a9a9f80272fdf543 + size: 8134 + timestamp: 1733405605338 +- conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-core-7.16.4-pyhff2d567_2.conda + sha256: 03a1303ce135a8214b450e751d93c9048f55edb37f3f9f06c5e9d78ba3ef2a89 + md5: 0457fdf55c88e52e0e7b63691eafcc48 depends: - beautifulsoup4 - bleach @@ -12267,95 +11902,54 @@ packages: - tinycss2 - traitlets >=5.0 constrains: - - nbconvert =7.16.4=*_1 + - nbconvert =7.16.4=*_2 - pandoc >=2.9.2,<4.0.0 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/nbconvert?source=project-defined-mapping - size: 189599 - timestamp: 1718135529468 -- kind: conda - name: nbconvert-pandoc - version: 7.16.4 - build: hd8ed1ab_1 - build_number: 1 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/nbconvert-pandoc-7.16.4-hd8ed1ab_1.conda - sha256: 31df882e97b227e7e57a328a36840e65ea3247023ac2ce502fd5d4b621da8dbe - md5: 37cec2cf68f4c09563d8bc833791096b + size: 188505 + timestamp: 1733405603619 +- conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-pandoc-7.16.4-hd8ed1ab_2.conda + sha256: d72734dcda3ab02e76ac11d453e1d4fac7edbd37db86fe14b324b15fd84ce42c + md5: 28701f71ce0b88b86783df822dd9d7b9 depends: - - nbconvert-core 7.16.4 pyhd8ed1ab_1 + - nbconvert-core 7.16.4 pyhff2d567_2 - pandoc license: BSD-3-Clause license_family: BSD purls: [] - size: 8371 - timestamp: 1718135533429 -- kind: conda - name: nbformat - version: 5.10.4 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/nbformat-5.10.4-pyhd8ed1ab_0.conda - sha256: 36fe73da4d37bc7ac2d1540526ecd294fbd09acda04e096181ab8f1ccd2b464c - md5: 0b57b5368ab7fc7cdc9e3511fa867214 + size: 8171 + timestamp: 1733405604621 +- conda: https://conda.anaconda.org/conda-forge/noarch/nbformat-5.10.4-pyhd8ed1ab_1.conda + sha256: 7a5bd30a2e7ddd7b85031a5e2e14f290898098dc85bea5b3a5bf147c25122838 + md5: bbe1963f1e47f594070ffe87cdf612ea depends: - jsonschema >=2.6 - jupyter_core >=4.12,!=5.0.* - - python >=3.8 + - python >=3.9 - python-fastjsonschema >=2.15 - traitlets >=5.1 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/nbformat?source=project-defined-mapping - size: 101232 - timestamp: 1712239122969 -- kind: conda - name: nccl - version: 2.22.3.1 - build: hbc370b7_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/nccl-2.22.3.1-hbc370b7_1.conda - sha256: 3a9656272cbe6f74973be4c5a610a731c2be0baaa7769544be996e147c3de36b - md5: 94e562f042ae010fc77326d28079c48c + size: 100945 + timestamp: 1733402844974 +- conda: https://conda.anaconda.org/conda-forge/linux-64/nccl-2.23.4.1-h2b5d15b_3.conda + sha256: fb327a4623d8d7b967a49104a1a4b111efbfdff6d4a1619d93aa9f3244395b73 + md5: da69647cf84be91a201e2c4138e676ae depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=12.0,<13 - cuda-version >=12.0,<13.0a0 - - libgcc-ng >=12 - - libstdcxx-ng >=12 + - libgcc >=12 + - libstdcxx >=12 license: BSD-3-Clause license_family: BSD purls: [] - size: 112458432 - timestamp: 1722290310919 -- kind: conda - name: ncurses - version: '6.5' - build: h7bae524_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-h7bae524_1.conda - sha256: 27d0b9ff78ad46e1f3a6c96c479ab44beda5f96def88e2fe626e0a49429d8afc - md5: cb2b0ea909b97b3d70cd3921d1445e1a - depends: - - __osx >=11.0 - license: X11 AND BSD-3-Clause - purls: [] - size: 802321 - timestamp: 1724658775723 -- kind: conda - name: ncurses - version: '6.5' - build: he02047a_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-he02047a_1.conda + size: 124592707 + timestamp: 1732655186186 +- conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-he02047a_1.conda sha256: 6a1d5d8634c1a07913f1c525db6455918cbc589d745fac46d9d6e30340c8731a md5: 70caf8bb6cf39a0b6b7efc885f51c0fe depends: @@ -12365,42 +11959,27 @@ packages: purls: [] size: 889086 timestamp: 1724658547447 -- kind: conda - name: nest-asyncio - version: 1.6.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/nest-asyncio-1.6.0-pyhd8ed1ab_0.conda - sha256: 30db21d1f7e59b3408b831a7e0417b83b53ee6223afae56482c5f26da3ceb49a - md5: 6598c056f64dc8800d40add25e4e2c34 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-h7bae524_1.conda + sha256: 27d0b9ff78ad46e1f3a6c96c479ab44beda5f96def88e2fe626e0a49429d8afc + md5: cb2b0ea909b97b3d70cd3921d1445e1a depends: - - python >=3.5 + - __osx >=11.0 + license: X11 AND BSD-3-Clause + purls: [] + size: 802321 + timestamp: 1724658775723 +- conda: https://conda.anaconda.org/conda-forge/noarch/nest-asyncio-1.6.0-pyhd8ed1ab_1.conda + sha256: bb7b21d7fd0445ddc0631f64e66d91a179de4ba920b8381f29b9d006a42788c0 + md5: 598fd7d4d0de2455fb74f56063969a97 + depends: + - python >=3.9 license: BSD-2-Clause license_family: BSD purls: - pkg:pypi/nest-asyncio?source=project-defined-mapping - size: 11638 - timestamp: 1705850780510 -- kind: conda - name: nettle - version: 3.9.1 - build: h40ed0f5_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/nettle-3.9.1-h40ed0f5_0.conda - sha256: 5de149b6e35adac11e22ae02516a7466412348690da52049f80ea07fe544896d - md5: b157977e1ec1dde3ba7ebc6e0dde363f - license: GPL 2 and LGPL3 - license_family: GPL - purls: [] - size: 510164 - timestamp: 1686310071126 -- kind: conda - name: nettle - version: 3.9.1 - build: h7ab15ed_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/nettle-3.9.1-h7ab15ed_0.conda + size: 11543 + timestamp: 1733325673691 +- conda: https://conda.anaconda.org/conda-forge/linux-64/nettle-3.9.1-h7ab15ed_0.conda sha256: 1ef1b7efa69c7fb4e2a36a88316f307c115713698d1c12e19f55ae57c0482995 md5: 2bf1915cc107738811368afcb0993a59 depends: @@ -12410,35 +11989,24 @@ packages: purls: [] size: 1011638 timestamp: 1686309814836 -- kind: conda - name: networkx - version: '3.3' - build: pyhd8ed1ab_1 - build_number: 1 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/networkx-3.3-pyhd8ed1ab_1.conda - sha256: cbd8a6de87ad842e7665df38dcec719873fe74698bc761de5431047b8fada41a - md5: d335fd5704b46f4efb89a6774e81aef0 +- conda: https://conda.anaconda.org/conda-forge/noarch/networkx-3.4.2-pyh267e887_2.conda + sha256: 39625cd0c9747fa5c46a9a90683b8997d8b9649881b3dc88336b13b7bdd60117 + md5: fd40bf7f7f4bc4b647dc8512053d9873 depends: - python >=3.10 + - python constrains: - - pandas >=1.4 - - numpy >=1.22 - - matplotlib >=3.5 - - scipy >=1.9,!=1.11.0,!=1.11.1 + - numpy >=1.24 + - scipy >=1.10,!=1.11.0,!=1.11.1 + - matplotlib >=3.7 + - pandas >=2.0 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/networkx?source=project-defined-mapping - size: 1185670 - timestamp: 1712540499262 -- kind: conda - name: ninja - version: 1.12.1 - build: h297d8ca_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.12.1-h297d8ca_0.conda + size: 1265008 + timestamp: 1731521053408 +- conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.12.1-h297d8ca_0.conda sha256: 40f7b76b07067935f8a5886aab0164067b7aa71eb5ad20b7278618c0c2c98e06 md5: 3aa1c7e292afeff25a0091ddd7c69b72 depends: @@ -12449,12 +12017,7 @@ packages: purls: [] size: 2198858 timestamp: 1715440571685 -- kind: conda - name: ninja - version: 1.12.1 - build: h420ef59_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.12.1-h420ef59_0.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.12.1-h420ef59_0.conda sha256: 11528acfa0f05d0c51639f6b09b51dc6611b801668449bb36c206c4b055be4f4 md5: 9166c10405d41c95ffde8fcb8e5c3d51 depends: @@ -12465,74 +12028,81 @@ packages: purls: [] size: 112576 timestamp: 1715440927034 -- kind: conda - name: nodeenv - version: 1.9.1 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_0.conda - sha256: 85ee07342ab055dc081f3de8292c5e7195e43e046db9c5750f242f928f6bb8f2 - md5: dfe0528d0f1c16c1f7c528ea5536ab30 +- conda: https://conda.anaconda.org/conda-forge/linux-64/nlohmann_json-3.11.3-he02047a_1.conda + sha256: ce4bcced4f8eea71b7cac8bc3daac097abf7a5792f278cd811dedada199500c1 + md5: e46f7ac4917215b49df2ea09a694a3fa + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + license: MIT + license_family: MIT + purls: [] + size: 122743 + timestamp: 1723652407663 +- conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_1.conda + sha256: 3636eec0e60466a00069b47ce94b6d88b01419b6577d8e393da44bb5bc8d3468 + md5: 7ba3f09fceae6a120d664217e58fe686 depends: - - python 2.7|>=3.7 + - python >=3.9 - setuptools license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/nodeenv?source=project-defined-mapping - size: 34489 - timestamp: 1717585382642 -- kind: conda - name: nodejs - version: 22.8.0 - build: h08fde81_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/nodejs-22.8.0-h08fde81_0.conda - sha256: 44a1cccb04cc14b3c71e540a2e1f6ece993bc6e1405af45d8595d9fb048f8452 - md5: 6cb1a4b2f38221be0c3205d84ec6bf2c + size: 34574 + timestamp: 1734112236147 +- conda: https://conda.anaconda.org/conda-forge/linux-64/nodejs-22.12.0-hf235a45_0.conda + sha256: 1a519b80bc3d5afddeccb593711df2e60ac48ecf3e903f7bdc279f64f7210fc4 + md5: 30458a23bf5568d2bc0e1fed6a4e2b12 depends: - - __osx >=11.0 + - __glibc >=2.28,<3.0.a0 - icu >=75.1,<76.0a0 - - libcxx >=17 + - libgcc >=13 + - libstdcxx >=13 + - libuv >=1.49.2,<2.0a0 + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.4.0,<4.0a0 + - zlib + license: MIT + license_family: MIT + purls: [] + size: 21796933 + timestamp: 1734113054756 +- conda: https://conda.anaconda.org/conda-forge/linux-64/nodejs-22.6.0-h6d9b948_0.conda + sha256: f2f77d9ea568c37e03b00c0066eee0449d2ee3058fffc8eaea8bb8954fdc3ddc + md5: 7f0af8a2662c74fd0843f1d5a2bfd898 + depends: + - __glibc >=2.17,<3.0.a0 + - icu >=73.2,<74.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 - libuv >=1.48.0,<2.0a0 - libzlib >=1.3.1,<2.0a0 - - openssl >=3.3.2,<4.0a0 + - openssl >=3.3.1,<4.0a0 - zlib license: MIT license_family: MIT purls: [] - size: 14929897 - timestamp: 1725489495197 -- kind: conda - name: nodejs - version: 22.8.0 - build: hf235a45_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/nodejs-22.8.0-hf235a45_0.conda - sha256: afd41efcdcb2cc9393aa28329b176124dd4fc6f6ca645300db473a7a3307a59d - md5: d61c014fb753ee700986e2032bec8bf9 + size: 21414159 + timestamp: 1723461563766 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/nodejs-22.12.0-h02a13b7_0.conda + sha256: 0d6f31cf19a3671aa7a6473392447801b4231ec832c8526b9a975b5c01930343 + md5: 293e451c0590d9029036f58aa109bc5d depends: - - __glibc >=2.28,<3.0.a0 + - __osx >=11.0 - icu >=75.1,<76.0a0 - - libgcc >=13 - - libstdcxx >=13 - - libuv >=1.48.0,<2.0a0 + - libcxx >=18 + - libuv >=1.49.2,<2.0a0 - libzlib >=1.3.1,<2.0a0 - - openssl >=3.3.2,<4.0a0 + - openssl >=3.4.0,<4.0a0 - zlib license: MIT license_family: MIT purls: [] - size: 21412805 - timestamp: 1725479400125 -- kind: conda - name: nomkl - version: '1.0' - build: h5ca1d4c_0 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/nomkl-1.0-h5ca1d4c_0.tar.bz2 + size: 15429539 + timestamp: 1734125056499 +- conda: https://conda.anaconda.org/conda-forge/noarch/nomkl-1.0-h5ca1d4c_0.tar.bz2 sha256: d38542a151a90417065c1a234866f97fd1ea82a81de75ecb725955ab78f88b4b md5: 9a66894dfd07c4510beb6b3f9672ccc0 constrains: @@ -12542,79 +12112,63 @@ packages: purls: [] size: 3843 timestamp: 1582593857545 -- kind: conda - name: notebook - version: 7.2.2 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/notebook-7.2.2-pyhd8ed1ab_0.conda - sha256: 613242d5151a4d70438bb2d65041c509e4376b7e18c06c3795c52a18176e41dc - md5: c4d5a58f43ce9ffa430e6ecad6c30a42 +- conda: https://conda.anaconda.org/conda-forge/noarch/notebook-7.3.1-pyhd8ed1ab_0.conda + sha256: d5bd4e3c27b2fd234c5d79f3749cd6139d5b13a88cb7320f93c239aabc28e576 + md5: f663ab5bcc9a28364b7b80aa976ed00f depends: + - importlib_resources >=5.0 - jupyter_server >=2.4.0,<3 - - jupyterlab >=4.2.0,<4.3 + - jupyterlab >=4.3.2,<4.4 - jupyterlab_server >=2.27.1,<3 - notebook-shim >=0.2,<0.3 - - python >=3.8 + - python >=3.9 - tornado >=6.2.0 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/notebook?source=project-defined-mapping - size: 3904930 - timestamp: 1724861465900 -- kind: conda - name: notebook-shim - version: 0.2.4 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/notebook-shim-0.2.4-pyhd8ed1ab_0.conda - sha256: 9b5fdef9ebe89222baa9da2796ebe7bc02ec6c5a1f61327b651d6b92cf9a0230 - md5: 3d85618e2c97ab896b5b5e298d32b5b3 + size: 9415854 + timestamp: 1733367221274 +- conda: https://conda.anaconda.org/conda-forge/noarch/notebook-shim-0.2.4-pyhd8ed1ab_1.conda + sha256: 7b920e46b9f7a2d2aa6434222e5c8d739021dbc5cc75f32d124a8191d86f9056 + md5: e7f89ea5f7ea9401642758ff50a2d9c1 depends: - jupyter_server >=1.8,<3 - - python >=3.7 + - python >=3.9 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/notebook-shim?source=project-defined-mapping - size: 16880 - timestamp: 1707957948029 -- kind: conda - name: nsight-compute - version: 2024.3.1.2 - build: hce307c1_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/nsight-compute-2024.3.1.2-hce307c1_0.conda - sha256: 56cbb555b3d2b0330fbac99936ce8b618a37f9a6ece470704b0bfd318294f5b4 - md5: 02c0fc23adf085936922305ae8ed68f7 + size: 16817 + timestamp: 1733408419340 +- conda: https://conda.anaconda.org/conda-forge/linux-64/nsight-compute-2024.2.0.16-h54680a5_0.conda + sha256: eff133f6e234debdf8b75efb8edab5f98fb6ab2ef4797d3ffe0f15802c386831 + md5: cc5da2c992fa8dca85c94d28e8869168 depends: - __glibc >=2.17,<3.0.a0 - - alsa-lib >=1.2.12,<1.3.0a0 - - cuda-version >=12.6,<12.7.0a0 + - alsa-lib >=1.2.11,<1.3.0a0 + - cuda-version >=12.5,<12.6.0a0 - dbus >=1.13.6,<2.0a0 - fontconfig >=2.14.2,<3.0a0 - fonts-conda-ecosystem - freetype >=2.12.1,<3.0a0 - - krb5 >=1.21.3,<1.22.0a0 + - krb5 >=1.21.2,<1.22.0a0 - libexpat >=2.6.2,<3.0a0 - - libgcc >=13 - - libglib >=2.80.3,<3.0a0 - - libstdcxx >=13 - - libxcb >=1.16,<1.17.0a0 + - libgcc-ng >=12 + - libglib >=2.80.2,<3.0a0 + - libstdcxx-ng >=12 + - libxcb >=1.15,<1.16.0a0 - libxkbcommon >=1.7.0,<2.0a0 - libxkbfile >=1.1.0,<1.2.0a0 - - libzlib >=1.3.1,<2.0a0 + - libzlib >=1.2.13,<2.0a0 - nspr >=4.35,<5.0a0 - - nss >=3.103,<4.0a0 - - wayland >=1.23.1,<2.0a0 + - nss >=3.100,<4.0a0 + - wayland >=1.22.0,<2.0a0 - xcb-util-cursor >=0.1.4,<0.2.0a0 - xcb-util-image >=0.4.0,<0.5.0a0 - - xcb-util-keysyms >=0.4.1,<0.5.0a0 - - xcb-util-renderutil >=0.3.10,<0.4.0a0 - - xcb-util-wm >=0.4.2,<0.5.0a0 + - xcb-util-keysyms >=0.4.0,<0.5.0a0 + - xcb-util-renderutil >=0.3.9,<0.4.0a0 + - xcb-util-wm >=0.4.1,<0.5.0a0 - xorg-libice >=1.1.1,<2.0a0 - xorg-libsm >=1.2.4,<2.0a0 - xorg-libx11 >=1.8.9,<2.0a0 @@ -12624,63 +12178,48 @@ packages: - xorg-libxfixes >=5.0.3,<5.1.0a0 - xorg-libxrandr >=1.5.2,<1.6.0a0 - xorg-libxrender >=0.9.11,<0.10.0a0 - - xorg-libxtst >=1.2.5,<1.3.0a0 - - xorg-libxtst >=1.2.5,<2.0a0 + - xorg-libxtst >=1.2.3,<1.3.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement purls: [] - size: 465627668 - timestamp: 1724958937220 -- kind: conda - name: nspr - version: '4.35' - build: h27087fc_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/nspr-4.35-h27087fc_0.conda - sha256: 8fadeebb2b7369a4f3b2c039a980d419f65c7b18267ba0c62588f9f894396d0c - md5: da0ec11a6454ae19bff5b02ed881a2b1 + size: 469760014 + timestamp: 1717076660602 +- conda: https://conda.anaconda.org/conda-forge/linux-64/nspr-4.36-h5888daf_0.conda + sha256: a87471d9265a7c02a98c20debac8b13afd80963968ed7b1c1c2ac7b80955ce31 + md5: de9cd5bca9e4918527b9b72b6e2e1409 depends: - - libgcc-ng >=12 - - libstdcxx-ng >=12 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 license: MPL-2.0 license_family: MOZILLA purls: [] - size: 226848 - timestamp: 1669784948267 -- kind: conda - name: nss - version: '3.104' - build: hd34e28f_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/nss-3.104-hd34e28f_0.conda - sha256: 0beb64ae310a34537c41e43110ebc24352c4319e6348cebe3d8a89b02382212c - md5: 0664e59f6937a660eba9f3d2f9123fa8 + size: 230204 + timestamp: 1729545773406 +- conda: https://conda.anaconda.org/conda-forge/linux-64/nss-3.107-hdf54f9c_0.conda + sha256: 4a901b96cc8d371cc71ab5cf1e3184c234ae7e74c4d50b3789d4bdadcd0f3c40 + md5: 294b7009fe9010b35c25bb683f663bc3 depends: - __glibc >=2.17,<3.0.a0 - libgcc >=13 - - libsqlite >=3.46.0,<4.0a0 + - libsqlite >=3.47.0,<4.0a0 - libstdcxx >=13 - libzlib >=1.3.1,<2.0a0 - - nspr >=4.35,<5.0a0 + - nspr >=4.36,<5.0a0 license: MPL-2.0 license_family: MOZILLA purls: [] - size: 1979701 - timestamp: 1725079209552 -- kind: conda - name: numpy - version: 1.26.4 - build: py312h8442bc7_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-1.26.4-py312h8442bc7_0.conda - sha256: c8841d6d6f61fd70ca80682efbab6bdb8606dc77c68d8acabfbd7c222054f518 - md5: d83fc83d589e2625a3451c9a7e21047c + size: 2002459 + timestamp: 1732239827455 +- conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-1.26.4-py312heda63a1_0.conda + sha256: fe3459c75cf84dcef6ef14efcc4adb0ade66038ddd27cadb894f34f4797687d8 + md5: d8285bea2a350f63fab23bf460221f3f depends: - libblas >=3.9.0,<4.0a0 - libcblas >=3.9.0,<4.0a0 - - libcxx >=16 + - libgcc-ng >=12 - liblapack >=3.9.0,<4.0a0 + - libstdcxx-ng >=12 - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 constrains: - numpy-base <0a0 @@ -12688,22 +12227,18 @@ packages: license_family: BSD purls: - pkg:pypi/numpy?source=project-defined-mapping - size: 6073136 - timestamp: 1707226249608 -- kind: conda - name: numpy - version: 1.26.4 - build: py312heda63a1_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/numpy-1.26.4-py312heda63a1_0.conda - sha256: fe3459c75cf84dcef6ef14efcc4adb0ade66038ddd27cadb894f34f4797687d8 - md5: d8285bea2a350f63fab23bf460221f3f + size: 7484186 + timestamp: 1707225809722 +- conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.2.0-py312h7e784f5_0.conda + sha256: 288b65215e8b2872b41aa369d31c8d7a22e280e94d5704d4d92594126796a5aa + md5: c9e9a81299192e77428f40711a4fb00d depends: + - __glibc >=2.17,<3.0.a0 - libblas >=3.9.0,<4.0a0 - libcblas >=3.9.0,<4.0a0 - - libgcc-ng >=12 + - libgcc >=13 - liblapack >=3.9.0,<4.0a0 - - libstdcxx-ng >=12 + - libstdcxx >=13 - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 constrains: @@ -12712,24 +12247,18 @@ packages: license_family: BSD purls: - pkg:pypi/numpy?source=project-defined-mapping - size: 7484186 - timestamp: 1707225809722 -- kind: conda - name: numpy - version: 2.1.1 - build: py312h58c1407_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.1.1-py312h58c1407_0.conda - sha256: 5d7d73f46d929dba57d96e6ef68506a490c89a2599514575c3e33b031e62b244 - md5: 839596d1c1c41f6fc01042e12cb7500c + size: 8421926 + timestamp: 1733688768634 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-1.26.4-py312h8442bc7_0.conda + sha256: c8841d6d6f61fd70ca80682efbab6bdb8606dc77c68d8acabfbd7c222054f518 + md5: d83fc83d589e2625a3451c9a7e21047c depends: - - __glibc >=2.17,<3.0.a0 - libblas >=3.9.0,<4.0a0 - libcblas >=3.9.0,<4.0a0 - - libgcc >=13 + - libcxx >=16 - liblapack >=3.9.0,<4.0a0 - - libstdcxx >=13 - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 constrains: - numpy-base <0a0 @@ -12737,67 +12266,122 @@ packages: license_family: BSD purls: - pkg:pypi/numpy?source=project-defined-mapping - size: 8457863 - timestamp: 1725412270045 -- kind: conda - name: ocl-icd - version: 2.3.2 - build: hd590300_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/ocl-icd-2.3.2-hd590300_1.conda - sha256: 0e01384423e48e5011eb6b224da8dc5e3567c87dbcefbe60cd9d5cead276cdcd - md5: c66f837ac65e4d1cdeb80e2a1d5fcc3d + size: 6073136 + timestamp: 1707226249608 +- conda: https://conda.anaconda.org/conda-forge/linux-64/ocl-icd-2.3.2-hb9d3cd8_2.conda + sha256: 96ddd13054032fabd54636f634d50bc74d10d8578bc946405c429b2d895db6f2 + md5: 2e8d2b469559d6b2cb6fd4b34f9c8d7f depends: - - libgcc-ng >=12 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - opencl-headers >=2024.10.24 license: BSD-2-Clause license_family: BSD purls: [] - size: 135681 - timestamp: 1710946531879 -- kind: conda - name: openexr - version: 3.2.2 - build: h2c51e1d_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/openexr-3.2.2-h2c51e1d_1.conda - sha256: 243b221c708bbe7f5c0fd72bdbd944a08f4ea9bc1e52b4f12f7fdb5f59633e13 - md5: 4ccfab8e79256a8480165969dd1d350c + size: 94934 + timestamp: 1732915114536 +- conda: https://conda.anaconda.org/conda-forge/linux-64/octomap-1.10.0-h84d6215_0.conda + sha256: 9b5bcc8be93c8da5be803be357d1096c190339018f688f509a0a295e04fb98be + md5: 0dfda663c7d58e8c35c96239ed57c16f depends: - - imath >=3.1.11,<3.1.12.0a0 - - libcxx >=16 - - libzlib >=1.2.13,<2.0.0a0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 license: BSD-3-Clause license_family: BSD purls: [] - size: 1361156 - timestamp: 1709261019544 -- kind: conda - name: openexr - version: 3.2.2 - build: haf962dd_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/openexr-3.2.2-haf962dd_1.conda - sha256: 01d773a14124929abd6c26169d900ce439f9df8a9e37d3ea197c7f71f61e7906 - md5: 34e58e21fc28e404207d6ce4287da264 + size: 234800 + timestamp: 1728635293810 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/octomap-1.10.0-h7b3277c_0.conda + sha256: 5f9547af44aea4cf7d8898198d35108d27c43ef45e2f46d065a643800da271d3 + md5: b58ab4e998bb09e7666eb15c34802df2 depends: - - imath >=3.1.11,<3.1.12.0a0 - - libgcc-ng >=12 - - libstdcxx-ng >=12 - - libzlib >=1.2.13,<2.0.0a0 + - __osx >=11.0 + - libcxx >=17 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 175588 + timestamp: 1728635358077 +- conda: https://conda.anaconda.org/conda-forge/linux-64/open3d-0.18.0-py312he431d9b_6.conda + sha256: 90116a9904cfd1b3aa3e366cb2b961c250283fc860e3be97684acea77a182008 + md5: 1e8aad73ba60957f11e7e3ae0ed2b973 + depends: + - __glibc >=2.17,<3.0.a0 + - _openmp_mutex >=4.5 + - assimp >=5.4.2,<5.4.3.0a0 + - dash + - embree 3.* + - embree >=3.13.0,<3.14.0a0 + - fmt >=9.1.0,<10.0a0 + - glew >=2.1.0,<2.2.0a0 + - glfw >=3.4,<4.0a0 + - jsoncpp >=1.9.5,<1.9.6.0a0 + - libcurl >=8.9.1,<9.0a0 + - libgcc-ng >=13 + - libjpeg-turbo >=3.0.0,<4.0a0 + - liblapacke >=3.9.0,<4.0a0 + - liblzf >=3.6,<3.7.0a0 + - libpng >=1.6.43,<1.7.0a0 + - libstdcxx-ng >=13 + - libzlib >=1.3.1,<2.0a0 + - numpy + - plotly + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - qhull >=2020.2,<2020.3.0a0 + - qt6-main >=6.7.2,<6.8.0a0 + - tinyobjloader >=1.0.7,<2.0a0 + - vtk * qt* + - vtk-base >=9.3.0,<9.3.1.0a0 + - zeromq >=4.3.5,<4.4.0a0 + license: MIT + license_family: MIT + purls: + - pkg:pypi/open3d?source=project-defined-mapping + size: 6339753 + timestamp: 1724400758408 +- conda: https://conda.anaconda.org/conda-forge/linux-64/opencl-headers-2024.10.24-h5888daf_0.conda + sha256: 7e1d3ad55d4ad3ddf826e205d4603b9ed40c5e655a9dfd66b56f459d7ba14db3 + md5: 3ba02cce423fdac1a8582bd6bb189359 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/opencl-headers + size: 54060 + timestamp: 1732912937444 +- conda: https://conda.anaconda.org/conda-forge/linux-64/openexr-3.2.2-h04e0de5_2.conda + sha256: a3768e0b6b5c7d291db0c1fd429cfbc3266e70a19f39f84bb5cdbecb077e78a5 + md5: 4ae01310cfeb55b4211aed3d442b9c66 + depends: + - __glibc >=2.17,<3.0.a0 + - imath >=3.1.12,<3.1.13.0a0 + - libgcc >=13 + - libstdcxx >=13 + - libzlib >=1.3.1,<2.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 1457889 + timestamp: 1726024792651 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/openexr-3.2.2-hab01212_2.conda + sha256: 5317b63c63fb57f0de109dcecb38ffb8ff05747eaee90b6771697dec198f5c8d + md5: 104fb7fbb910fe9d66fe81d1611baf2c + depends: + - __osx >=11.0 + - imath >=3.1.12,<3.1.13.0a0 + - libcxx >=17 + - libzlib >=1.3.1,<2.0a0 license: BSD-3-Clause license_family: BSD purls: [] - size: 1466865 - timestamp: 1709260550301 -- kind: conda - name: openh264 - version: 2.4.1 - build: h59595ed_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/openh264-2.4.1-h59595ed_0.conda + size: 1248482 + timestamp: 1726024848729 +- conda: https://conda.anaconda.org/conda-forge/linux-64/openh264-2.4.1-h59595ed_0.conda sha256: 0d4eaf15fb771f25c924aef831d76eea11d90c824778fc1e7666346e93475f42 md5: 3dfcf61b8e78af08110f5229f79580af depends: @@ -12808,12 +12392,19 @@ packages: purls: [] size: 735244 timestamp: 1706873814072 -- kind: conda - name: openh264 - version: 2.4.1 - build: hebf3989_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/openh264-2.4.1-hebf3989_0.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/openh264-2.5.0-hf92e6e3_0.conda + sha256: dedda20c58aec3d8f9c12e3660225608b93a257a21e0da703fdd814789291519 + md5: d1b18a73fc3cfd0de9c7e786d2febb8f + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 727504 + timestamp: 1731068122274 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/openh264-2.4.1-hebf3989_0.conda sha256: ecadea5985082105b102f86ff8289128fb247c183b36355d867eb6fc6996df29 md5: 25a7835e284a4d947fe9a70efa97e019 depends: @@ -12823,128 +12414,104 @@ packages: purls: [] size: 598764 timestamp: 1706874342701 -- kind: conda - name: openjpeg - version: 2.5.2 - build: h488ebb8_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/openjpeg-2.5.2-h488ebb8_0.conda - sha256: 5600a0b82df042bd27d01e4e687187411561dfc11cc05143a08ce29b64bf2af2 - md5: 7f2e286780f072ed750df46dc2631138 +- conda: https://conda.anaconda.org/conda-forge/linux-64/openjpeg-2.5.3-h5fbd93e_0.conda + sha256: 5bee706ea5ba453ed7fd9da7da8380dd88b865c8d30b5aaec14d2b6dd32dbc39 + md5: 9e5816bc95d285c115a3ebc2f8563564 depends: - - libgcc-ng >=12 - - libpng >=1.6.43,<1.7.0a0 - - libstdcxx-ng >=12 - - libtiff >=4.6.0,<4.7.0a0 - - libzlib >=1.2.13,<2.0.0a0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libpng >=1.6.44,<1.7.0a0 + - libstdcxx >=13 + - libtiff >=4.7.0,<4.8.0a0 + - libzlib >=1.3.1,<2.0a0 license: BSD-2-Clause license_family: BSD purls: [] - size: 341592 - timestamp: 1709159244431 -- kind: conda - name: openjpeg - version: 2.5.2 - build: h9f1df11_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/openjpeg-2.5.2-h9f1df11_0.conda - sha256: 472d6eaffc1996e6af35ec8e91c967f472a536a470079bfa56383cc0dbf4d463 - md5: 5029846003f0bc14414b9128a1f7c84b + size: 342988 + timestamp: 1733816638720 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/openjpeg-2.5.3-h8a3d83b_0.conda + sha256: 1d59bc72ca7faac06d349c1a280f5cfb8a57ee5896f1e24225a997189d7418c7 + md5: 4b71d78648dbcf68ce8bf22bb07ff838 depends: - - libcxx >=16 - - libpng >=1.6.43,<1.7.0a0 - - libtiff >=4.6.0,<4.7.0a0 - - libzlib >=1.2.13,<2.0.0a0 + - __osx >=11.0 + - libcxx >=18 + - libpng >=1.6.44,<1.7.0a0 + - libtiff >=4.7.0,<4.8.0a0 + - libzlib >=1.3.1,<2.0a0 license: BSD-2-Clause license_family: BSD purls: [] - size: 316603 - timestamp: 1709159627299 -- kind: conda - name: openssl - version: 3.3.2 - build: h8359307_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.3.2-h8359307_0.conda - sha256: 940fa01c4dc6152158fe8943e05e55a1544cab639df0994e3b35937839e4f4d1 - md5: 1773ebccdc13ec603356e8ff1db9e958 + size: 319362 + timestamp: 1733816781741 +- conda: https://conda.anaconda.org/conda-forge/linux-64/openldap-2.6.9-he970967_0.conda + sha256: 224f458848f792fe9e3587ee6b626d4eaad63aead0e5e6c25cbe29aba7b05c53 + md5: ca2de8bbdc871bce41dbf59e51324165 depends: - - __osx >=11.0 + - __glibc >=2.17,<3.0.a0 + - cyrus-sasl >=2.1.27,<3.0a0 + - krb5 >=1.21.3,<1.22.0a0 + - libgcc >=13 + - libstdcxx >=13 + - openssl >=3.4.0,<4.0a0 + license: OLDAP-2.8 + license_family: BSD + purls: [] + size: 784483 + timestamp: 1732674189726 +- conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.4.0-hb9d3cd8_0.conda + sha256: 814b9dff1847b132c676ee6cc1a8cb2d427320779b93e1b6d76552275c128705 + md5: 23cc74f77eb99315c0360ec3533147a9 + depends: + - __glibc >=2.17,<3.0.a0 - ca-certificates + - libgcc >=13 license: Apache-2.0 license_family: Apache purls: [] - size: 2882450 - timestamp: 1725410638874 -- kind: conda - name: openssl - version: 3.3.2 - build: hb9d3cd8_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.3.2-hb9d3cd8_0.conda - sha256: cee91036686419f6dd6086902acf7142b4916e1c4ba042e9ca23e151da012b6d - md5: 4d638782050ab6faa27275bed57e9b4e + size: 2947466 + timestamp: 1731377666602 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.4.0-h39f12f2_0.conda + sha256: bd1d58ced46e75efa3b842c61642fd12272c69e9fe4d7261078bc082153a1d53 + md5: df307bbc703324722df0293c9ca2e418 depends: - - __glibc >=2.17,<3.0.a0 + - __osx >=11.0 - ca-certificates - - libgcc >=13 license: Apache-2.0 license_family: Apache purls: [] - size: 2891789 - timestamp: 1725410790053 -- kind: conda - name: opt-einsum - version: 3.3.0 - build: hd8ed1ab_2 - build_number: 2 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/opt-einsum-3.3.0-hd8ed1ab_2.conda - sha256: 7cc87658f3ef09bd6f85afdf6c55db0c274960132de4050328759e8b3784df22 - md5: ab262acd95cb73f3ed9426cc4204ac3a + size: 2935176 + timestamp: 1731377561525 +- conda: https://conda.anaconda.org/conda-forge/noarch/opt-einsum-3.4.0-hd8ed1ab_1.conda + sha256: 8db3d841c72f184de69e1237b900a2d79c742e30e8378973814543bf987b6bc6 + md5: b94f689d8b1ce7dd212946e0331037ad depends: - - opt_einsum >=3.3.0,<3.3.1.0a0 + - opt_einsum >=3.4.0,<3.4.1.0a0 license: MIT license_family: MIT purls: - pkg:pypi/opt-einsum?source=project-defined-mapping - size: 6594 - timestamp: 1696449067022 -- kind: conda - name: opt_einsum - version: 3.3.0 - build: pyhc1e730c_2 - build_number: 2 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/opt_einsum-3.3.0-pyhc1e730c_2.conda - sha256: 1995657f10e23dbe534219f754c66b7fb2a805d68a3385abdacb7807a915b0c3 - md5: 7a94ac68b892daa9f17ae8a52b31ed81 + size: 6558 + timestamp: 1733688054327 +- conda: https://conda.anaconda.org/conda-forge/noarch/opt_einsum-3.4.0-pyhd8ed1ab_1.conda + sha256: af71aabb2bfa4b2c89b7b06403e5cec23b418452cae9f9772bd7ac3f9ea1ff44 + md5: 52919815cd35c4e1a0298af658ccda04 depends: - - numpy - - python >=3.6 + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/opt-einsum?source=project-defined-mapping - size: 58004 - timestamp: 1696449058916 -- kind: conda - name: optax - version: 0.2.2 - build: pyhd8ed1ab_1 - build_number: 1 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/optax-0.2.2-pyhd8ed1ab_1.conda - sha256: 68ab5cd076de8d3ec6971a78bd3786a129a2c0d172a0fc66776b36d28b54f5f8 - md5: dd370641d3610ed329ae747f0eae09c8 + size: 62479 + timestamp: 1733688053334 +- conda: https://conda.anaconda.org/conda-forge/noarch/optax-0.2.3-pyhd8ed1ab_0.conda + sha256: bba20ec697805ad0247a7fe8bef31a12c98d9c35676b7fbaa0bb00ebb2b4a0b4 + md5: e3abc01ef0ada036abe35d39a2c15767 depends: - absl-py >=0.7.1 - chex >=0.1.86 - - jax >=0.1.55 - - jaxlib >=0.1.37 + - etils + - jax >=0.4.27 + - jaxlib >=0.4.27 - numpy >=1.18.0 - python >=3.9 - typing_extensions >=3.10 @@ -12952,14 +12519,9 @@ packages: license_family: APACHE purls: - pkg:pypi/optax?source=project-defined-mapping - size: 145268 - timestamp: 1718550769933 -- kind: conda - name: orc - version: 2.0.2 - build: h669347b_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/orc-2.0.2-h669347b_0.conda + size: 177495 + timestamp: 1727945733024 +- conda: https://conda.anaconda.org/conda-forge/linux-64/orc-2.0.2-h669347b_0.conda sha256: 8a126e0be7f87c499f0a9b5229efa4321e60fc4ae46abdec9b13240631cb1746 md5: 1e6c10f7d749a490612404efeb179eb8 depends: @@ -12977,12 +12539,25 @@ packages: purls: [] size: 1066349 timestamp: 1723760593232 -- kind: conda - name: orc - version: 2.0.2 - build: h75dedd0_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/orc-2.0.2-h75dedd0_0.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/orc-2.0.3-h97ab989_1.conda + sha256: 9de7e2746fde57c9b7f08ee87142014f6bb9b2d3a506839ea3e98baa99711576 + md5: 2f46eae652623114e112df13fae311cf + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libprotobuf >=5.28.2,<5.28.3.0a0 + - libstdcxx >=13 + - libzlib >=1.3.1,<2.0a0 + - lz4-c >=1.10.0,<1.11.0a0 + - snappy >=1.2.1,<1.3.0a0 + - tzdata + - zstd >=1.5.6,<1.6.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 1189462 + timestamp: 1733509801323 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/orc-2.0.2-h75dedd0_0.conda sha256: a23f3a88a6b16363bd13f964b4abd12be1576abac460126f3269cbed12d04840 md5: 9c89e09cede143716b479c5eacc924fb depends: @@ -12999,23 +12574,33 @@ packages: purls: [] size: 436164 timestamp: 1723760750932 -- kind: pypi +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/orc-2.0.3-hbcee414_1.conda + sha256: e5e72438a3cd967ebc774070e8c49500d2d6d4175f349400b327fee75d3bfc05 + md5: e808cf7819eaa1735c8790d7f9f482c7 + depends: + - __osx >=11.0 + - libcxx >=18 + - libprotobuf >=5.28.2,<5.28.3.0a0 + - libzlib >=1.3.1,<2.0a0 + - lz4-c >=1.10.0,<1.11.0a0 + - snappy >=1.2.1,<1.3.0a0 + - tzdata + - zstd >=1.5.6,<1.6.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 437391 + timestamp: 1733510118673 +- pypi: https://files.pythonhosted.org/packages/33/55/af02708f230eb77084a299d7b08175cff006dea4f2721074b92cdb0296c0/ordered_set-4.1.0-py3-none-any.whl name: ordered-set version: 4.1.0 - url: https://files.pythonhosted.org/packages/33/55/af02708f230eb77084a299d7b08175cff006dea4f2721074b92cdb0296c0/ordered_set-4.1.0-py3-none-any.whl sha256: 046e1132c71fcf3330438a539928932caf51ddbc582496833e23de611de14562 requires_dist: - pytest ; extra == 'dev' - black ; extra == 'dev' - mypy ; extra == 'dev' requires_python: '>=3.7' -- kind: conda - name: overrides - version: 7.7.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/overrides-7.7.0-pyhd8ed1ab_0.conda +- conda: https://conda.anaconda.org/conda-forge/noarch/overrides-7.7.0-pyhd8ed1ab_0.conda sha256: 5e238e5e646414d517a13f6786c7227206ace58271e3ef63f6adca4d6a4c2839 md5: 24fba5a9d161ad8103d4e84c0e1a3ed4 depends: @@ -13027,28 +12612,7 @@ packages: - pkg:pypi/overrides?source=project-defined-mapping size: 30232 timestamp: 1706394723472 -- kind: conda - name: p11-kit - version: 0.24.1 - build: h29577a5_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/p11-kit-0.24.1-h29577a5_0.tar.bz2 - sha256: 3e124859307956f9f390f39c74b9700be4843eaaf56891c4b09da75b1bd5b57f - md5: 8f111d56c8c7c1895bde91a942c43d93 - depends: - - libffi >=3.4.2,<3.5.0a0 - - libtasn1 >=4.18.0,<5.0a0 - license: MIT - license_family: MIT - purls: [] - size: 890711 - timestamp: 1654869118646 -- kind: conda - name: p11-kit - version: 0.24.1 - build: hc5aa10d_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/p11-kit-0.24.1-hc5aa10d_0.tar.bz2 +- conda: https://conda.anaconda.org/conda-forge/linux-64/p11-kit-0.24.1-hc5aa10d_0.tar.bz2 sha256: aa8d3887b36557ad0c839e4876c0496e0d670afe843bf5bba4a87764b868196d md5: 56ee94e34b71742bbdfa832c974e47a8 depends: @@ -13060,28 +12624,21 @@ packages: purls: [] size: 4702497 timestamp: 1654868759643 -- kind: conda - name: packaging - version: '24.1' - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/packaging-24.1-pyhd8ed1ab_0.conda - sha256: 36aca948219e2c9fdd6d80728bcc657519e02f06c2703d8db3446aec67f51d81 - md5: cbe1bb1f21567018ce595d9c2be0f0db +- conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.2-pyhd8ed1ab_2.conda + sha256: da157b19bcd398b9804c5c52fc000fcb8ab0525bdb9c70f95beaa0bb42f85af1 + md5: 3bfed7e6228ebf2f7b9eaa47f1b4e2aa depends: - python >=3.8 license: Apache-2.0 license_family: APACHE purls: - pkg:pypi/packaging?source=project-defined-mapping - size: 50290 - timestamp: 1718189540074 -- kind: pypi + size: 60164 + timestamp: 1733203368787 +- pypi: https://files.pythonhosted.org/packages/38/f8/d8fddee9ed0d0c0f4a2132c1dfcf0e3e53265055da8df952a53e7eaf178c/pandas-2.2.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl name: pandas - version: 2.2.2 - url: https://files.pythonhosted.org/packages/40/10/79e52ef01dfeb1c1ca47a109a01a248754ebe990e159a844ece12914de83/pandas-2.2.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl - sha256: eee3a87076c0756de40b05c5e9a6069c035ba43e8dd71c379e68cab2c20f16ad + version: 2.2.3 + sha256: fffb8ae78d8af97f849404f21411c95062db1496aeb3e56f146f0355c9989319 requires_dist: - numpy>=1.22.4 ; python_full_version < '3.11' - numpy>=1.23.2 ; python_full_version == '3.11.*' @@ -13169,11 +12726,10 @@ packages: - xlsxwriter>=3.0.5 ; extra == 'all' - zstandard>=0.19.0 ; extra == 'all' requires_python: '>=3.9' -- kind: pypi +- pypi: https://files.pythonhosted.org/packages/e1/0c/ad295fd74bfac85358fd579e271cded3ac969de81f62dd0142c426b9da91/pandas-2.2.3-cp312-cp312-macosx_11_0_arm64.whl name: pandas - version: 2.2.2 - url: https://files.pythonhosted.org/packages/db/7c/9a60add21b96140e22465d9adf09832feade45235cd22f4cb1668a25e443/pandas-2.2.2-cp312-cp312-macosx_11_0_arm64.whl - sha256: e9b79011ff7a0f4b1d6da6a61aa1aa604fb312d6647de5bad20013682d1429ce + version: 2.2.3 + sha256: a5a1595fe639f5988ba6a8e5bc9649af3baf26df3998a0abe56c02609392e0a4 requires_dist: - numpy>=1.22.4 ; python_full_version < '3.11' - numpy>=1.23.2 ; python_full_version == '3.11.*' @@ -13261,39 +12817,23 @@ packages: - xlsxwriter>=3.0.5 ; extra == 'all' - zstandard>=0.19.0 ; extra == 'all' requires_python: '>=3.9' -- kind: conda - name: pandoc - version: '3.3' - build: ha770c72_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/pandoc-3.3-ha770c72_0.conda - sha256: 0a9591992ada40a6dd2a3f37bfe51cd01956e54b1fa9204f2bd92b31148cb55e - md5: 0a3af8b93ba501c6ba020deacc9df841 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pandoc-3.6-ha770c72_0.conda + sha256: 9d4cfbb4cb844c50cecb0bc3c1ad7479908f422299bf79e667aa75129c4b0a21 + md5: 38ee82616a780cf22ec6355e386e2563 license: GPL-2.0-or-later license_family: GPL purls: [] - size: 20892835 - timestamp: 1722242814344 -- kind: conda - name: pandoc - version: '3.3' - build: hce30654_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/pandoc-3.3-hce30654_0.conda - sha256: 097451021b144932e9932dbcc20d3996b728178878ff00bdd9c1ee0ef372491d - md5: d6414d4e7997d462d2d60a971e68d3b4 + size: 21236819 + timestamp: 1733818363981 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pandoc-3.6-hce30654_0.conda + sha256: 893123508bf052cd1db0a792d9d135275ac092c187418d2ca3f283024d064602 + md5: 853119c65d59cdc890facf6ed77a0a78 license: GPL-2.0-or-later license_family: GPL purls: [] - size: 22897552 - timestamp: 1722242876996 -- kind: conda - name: pandocfilters - version: 1.5.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/pandocfilters-1.5.0-pyhd8ed1ab_0.tar.bz2 + size: 23155494 + timestamp: 1733818394255 +- conda: https://conda.anaconda.org/conda-forge/noarch/pandocfilters-1.5.0-pyhd8ed1ab_0.tar.bz2 sha256: 2bb9ba9857f4774b85900c2562f7e711d08dd48e2add9bee4e1612fbee27e16f md5: 457c2c8c08e54905d6954e79cb5b5db9 depends: @@ -13304,48 +12844,49 @@ packages: - pkg:pypi/pandocfilters?source=project-defined-mapping size: 11627 timestamp: 1631603397334 -- kind: conda - name: parso - version: 0.8.4 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.4-pyhd8ed1ab_0.conda - sha256: bfe404eebb930cc41782d34f8fc04c0388ea692eeebe2c5fc28df8ec8d4d61ae - md5: 81534b420deb77da8833f2289b8d47ac +- conda: https://conda.anaconda.org/conda-forge/linux-64/pango-1.54.0-h3a902e7_3.conda + sha256: b04f43a7968cedb93cc0b52854f2cac21d8b8ac150b40305865d9ff3c3d4da72 + md5: 8c12547e7b143fb70873fb732a4056b9 depends: - - python >=3.6 + - __glibc >=2.17,<3.0.a0 + - cairo >=1.18.2,<2.0a0 + - fontconfig >=2.15.0,<3.0a0 + - fonts-conda-ecosystem + - freetype >=2.12.1,<3.0a0 + - fribidi >=1.0.10,<2.0a0 + - harfbuzz >=9.0.0,<10.0a0 + - libexpat >=2.6.4,<3.0a0 + - libgcc >=13 + - libglib >=2.82.2,<3.0a0 + - libpng >=1.6.44,<1.7.0a0 + license: LGPL-2.1-or-later + purls: [] + size: 447446 + timestamp: 1733761801816 +- conda: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.4-pyhd8ed1ab_1.conda + sha256: 17131120c10401a99205fc6fe436e7903c0fa092f1b3e80452927ab377239bcc + md5: 5c092057b6badd30f75b06244ecd01c9 + depends: + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/parso?source=project-defined-mapping - size: 75191 - timestamp: 1712320447201 -- kind: conda - name: pcre2 - version: '10.44' - build: h297a79d_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.44-h297a79d_2.conda - sha256: 83153c7d8fd99cab33c92ce820aa7bfed0f1c94fc57010cf227b6e3c50cb7796 - md5: 147c83e5e44780c7492998acbacddf52 + size: 75295 + timestamp: 1733271352153 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.43-hcad00b1_0.conda + sha256: 766dd986a7ed6197676c14699000bba2625fd26c8a890fcb7a810e5cf56155bc + md5: 8292dea9e022d9610a11fce5e0896ed8 depends: - - __osx >=11.0 - bzip2 >=1.0.8,<2.0a0 - - libzlib >=1.3.1,<2.0a0 + - libgcc-ng >=12 + - libzlib >=1.2.13,<2.0.0a0 license: BSD-3-Clause license_family: BSD purls: [] - size: 618973 - timestamp: 1723488853807 -- kind: conda - name: pcre2 - version: '10.44' - build: hba22ea6_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.44-hba22ea6_2.conda + size: 950847 + timestamp: 1708118050286 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.44-hba22ea6_2.conda sha256: 1087716b399dab91cc9511d6499036ccdc53eb29a288bebcb19cf465c51d7c0d md5: df359c09c41cd186fffb93a2d87aa6f5 depends: @@ -13358,13 +12899,19 @@ packages: purls: [] size: 952308 timestamp: 1723488734144 -- kind: conda - name: pdoc - version: 14.4.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/pdoc-14.4.0-pyhd8ed1ab_0.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.44-h297a79d_2.conda + sha256: 83153c7d8fd99cab33c92ce820aa7bfed0f1c94fc57010cf227b6e3c50cb7796 + md5: 147c83e5e44780c7492998acbacddf52 + depends: + - __osx >=11.0 + - bzip2 >=1.0.8,<2.0a0 + - libzlib >=1.3.1,<2.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 618973 + timestamp: 1723488853807 +- conda: https://conda.anaconda.org/conda-forge/noarch/pdoc-14.4.0-pyhd8ed1ab_0.conda sha256: 4216368f212046e76badbb340fbc0aae5624ff817bf5fea17800148e0b902adc md5: 423fdfd88f712f7252524d4ffe2eaad8 depends: @@ -13378,10 +12925,9 @@ packages: - pkg:pypi/pdoc?source=project-defined-mapping size: 114871 timestamp: 1705591088723 -- kind: pypi +- pypi: https://files.pythonhosted.org/packages/41/dc/d123e5815af021ba22f9321d6922b03b1c1351170f78c3ebb86c522f24aa/penzai-0.1.5-py3-none-any.whl name: penzai version: 0.1.5 - url: https://files.pythonhosted.org/packages/41/dc/d123e5815af021ba22f9321d6922b03b1c1351170f78c3ebb86c522f24aa/penzai-0.1.5-py3-none-any.whl sha256: bc46c5f0ed2d0e74b558c1dc39dfb94c168eaddfe5ca446627e9d7affda78e20 requires_dist: - absl-py>=1.4.0 @@ -13420,48 +12966,29 @@ packages: - orbax-checkpoint ; extra == 'notebook' - palettable ; extra == 'notebook' requires_python: '>=3.10' -- kind: conda - name: pexpect - version: 4.9.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_0.conda - sha256: 90a09d134a4a43911b716d4d6eb9d169238aff2349056f7323d9db613812667e - md5: 629f3203c99b32e0988910c93e77f3b6 +- conda: https://conda.anaconda.org/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_1.conda + sha256: 202af1de83b585d36445dc1fda94266697341994d1a3328fabde4989e1b3d07a + md5: d0d408b1f18883a944376da5cf8101ea depends: - ptyprocess >=0.5 - - python >=3.7 + - python >=3.9 license: ISC purls: - pkg:pypi/pexpect?source=project-defined-mapping - size: 53600 - timestamp: 1706113273252 -- kind: conda - name: pickleshare - version: 0.7.5 - build: py_1003 - build_number: 1003 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/pickleshare-0.7.5-py_1003.tar.bz2 - sha256: a1ed1a094dd0d1b94a09ed85c283a0eb28943f2e6f22161fb45e128d35229738 - md5: 415f0ebb6198cc2801c73438a9fb5761 + size: 53561 + timestamp: 1733302019362 +- conda: https://conda.anaconda.org/conda-forge/noarch/pickleshare-0.7.5-pyhd8ed1ab_1004.conda + sha256: e2ac3d66c367dada209fc6da43e645672364b9fd5f9d28b9f016e24b81af475b + md5: 11a9d1d09a3615fc07c3faf79bc0b943 depends: - - python >=3 + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/pickleshare?source=project-defined-mapping - size: 9332 - timestamp: 1602536313357 -- kind: conda - name: pillow - version: 10.3.0 - build: py312h287a98d_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/pillow-10.3.0-py312h287a98d_1.conda + size: 11748 + timestamp: 1733327448200 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pillow-10.3.0-py312h287a98d_1.conda sha256: e1a2426f23535fc15e577d799685229a93117b645734e5cca60597bb23cef09e md5: b1325cda3f250f9f842180607054e6ed depends: @@ -13469,9 +12996,9 @@ packages: - lcms2 >=2.16,<3.0a0 - libgcc-ng >=12 - libjpeg-turbo >=3.0.0,<4.0a0 - - libtiff >=4.6.0,<4.7.0a0 + - libtiff >=4.6.0,<4.8.0a0 - libwebp-base >=1.4.0,<2.0a0 - - libxcb >=1.16,<1.17.0a0 + - libxcb >=1.16,<2.0.0a0 - libzlib >=1.3.1,<2.0a0 - openjpeg >=2.5.2,<3.0a0 - python >=3.12,<3.13.0a0 @@ -13482,76 +13009,82 @@ packages: - pkg:pypi/pillow?source=project-defined-mapping size: 41702764 timestamp: 1718833930009 -- kind: conda - name: pillow - version: 10.3.0 - build: py312h39b1d8d_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/pillow-10.3.0-py312h39b1d8d_1.conda - sha256: 37907cdfdb8765d26cb239098fcb053b0b55216945d8bedc9429023ba8db11ab - md5: 4d3a01b6c6df5cc761adb1f3da5b99c2 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pillow-10.3.0-py312hdcec9eb_0.conda + sha256: a7fdcc1e56b66d95622bad073cc8d347cc180988040419754abb2a4ed7b29471 + md5: 425bb325f970e57a047ac57c4586489d depends: - - __osx >=11.0 - freetype >=2.12.1,<3.0a0 - lcms2 >=2.16,<3.0a0 + - libgcc-ng >=12 + - libjpeg-turbo >=3.0.0,<4.0a0 + - libtiff >=4.6.0,<4.8.0a0 + - libwebp-base >=1.3.2,<2.0a0 + - libxcb >=1.15,<1.16.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - openjpeg >=2.5.2,<3.0a0 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - tk >=8.6.13,<8.7.0a0 + license: HPND + purls: + - pkg:pypi/pillow?source=project-defined-mapping + size: 41991755 + timestamp: 1712154634705 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pillow-11.0.0-py312h7b63e92_0.conda + sha256: 13a464bea02c0df0199c20ef6bad24a6bc336aaf55bf8d6a133d0fe664463224 + md5: 385f46a4df6f97892503a841121a9acf + depends: + - __glibc >=2.17,<3.0.a0 + - freetype >=2.12.1,<3.0a0 + - lcms2 >=2.16,<3.0a0 + - libgcc >=13 - libjpeg-turbo >=3.0.0,<4.0a0 - - libtiff >=4.6.0,<4.7.0a0 + - libtiff >=4.7.0,<4.8.0a0 - libwebp-base >=1.4.0,<2.0a0 - - libxcb >=1.16,<1.17.0a0 + - libxcb >=1.17.0,<2.0a0 - libzlib >=1.3.1,<2.0a0 - openjpeg >=2.5.2,<3.0a0 - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 - tk >=8.6.13,<8.7.0a0 license: HPND purls: - pkg:pypi/pillow?source=project-defined-mapping - size: 42691135 - timestamp: 1718834038233 -- kind: conda - name: pillow - version: 10.4.0 - build: py312h287a98d_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/pillow-10.4.0-py312h287a98d_0.conda - sha256: f3bca9472702f32bf85196efbf013e9dabe130776e76c7f81062f18682f33a05 - md5: 59ea71eed98aee0bebbbdd3b118167c7 + size: 41948418 + timestamp: 1729065846594 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pillow-10.3.0-py312h39b1d8d_1.conda + sha256: 37907cdfdb8765d26cb239098fcb053b0b55216945d8bedc9429023ba8db11ab + md5: 4d3a01b6c6df5cc761adb1f3da5b99c2 depends: + - __osx >=11.0 - freetype >=2.12.1,<3.0a0 - lcms2 >=2.16,<3.0a0 - - libgcc-ng >=12 - libjpeg-turbo >=3.0.0,<4.0a0 - - libtiff >=4.6.0,<4.7.0a0 + - libtiff >=4.6.0,<4.8.0a0 - libwebp-base >=1.4.0,<2.0a0 - - libxcb >=1.16,<1.17.0a0 + - libxcb >=1.16,<2.0.0a0 - libzlib >=1.3.1,<2.0a0 - openjpeg >=2.5.2,<3.0a0 - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 - tk >=8.6.13,<8.7.0a0 license: HPND purls: - pkg:pypi/pillow?source=project-defined-mapping - size: 42068301 - timestamp: 1719903698022 -- kind: conda - name: pillow - version: 10.4.0 - build: py312h39b1d8d_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/pillow-10.4.0-py312h39b1d8d_0.conda - sha256: 7c4244fa62cf630375531723631764a276eb06eeb5cc345a8e55a091aec1e52d - md5: 461c9897622e08c614087f9c9b9a22ce + size: 42691135 + timestamp: 1718834038233 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pillow-11.0.0-py312haf37ca6_0.conda + sha256: 727b4c3faecdb6f6809cf20c5f32d2df4af34e0d5b9146b7588383bcba7990e8 + md5: dc9b51fbd2b6f7fea9b5123458864dbb depends: - __osx >=11.0 - freetype >=2.12.1,<3.0a0 - lcms2 >=2.16,<3.0a0 - libjpeg-turbo >=3.0.0,<4.0a0 - - libtiff >=4.6.0,<4.7.0a0 + - libtiff >=4.7.0,<4.8.0a0 - libwebp-base >=1.4.0,<2.0a0 - - libxcb >=1.16,<1.17.0a0 + - libxcb >=1.17.0,<2.0a0 - libzlib >=1.3.1,<2.0a0 - openjpeg >=2.5.2,<3.0a0 - python >=3.12,<3.13.0a0 @@ -13561,97 +13094,94 @@ packages: license: HPND purls: - pkg:pypi/pillow?source=project-defined-mapping - size: 42347638 - timestamp: 1719903919946 -- kind: conda - name: pixman - version: 0.43.2 - build: h59595ed_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/pixman-0.43.2-h59595ed_0.conda - sha256: 366d28e2a0a191d6c535e234741e0cd1d94d713f76073d8af4a5ccb2a266121e - md5: 71004cbf7924e19c02746ccde9fd7123 + size: 41737424 + timestamp: 1729065920347 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pixman-0.44.2-h29eaf8c_0.conda + sha256: 747c58db800d5583fee78e76240bf89cbaeedf7ab1ef339c2990602332b9c4be + md5: 5e2a7acfa2c24188af39e7944e1b3604 depends: - - libgcc-ng >=12 - - libstdcxx-ng >=12 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 license: MIT license_family: MIT purls: [] - size: 386826 - timestamp: 1706549500138 -- kind: conda - name: pixman - version: 0.43.4 - build: hebf3989_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/pixman-0.43.4-hebf3989_0.conda - sha256: df0ba2710ccdea5c909b63635529797f6eb3635b6fb77ae9cb2f183d08818409 - md5: 0308c68e711cd295aaa026a4f8c4b1e5 + size: 381072 + timestamp: 1733698987122 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pixman-0.44.2-h2f9eb0b_0.conda + sha256: 28855d4cb2d9fc9a6bd9196dadbaecd6868ec706394cec2f88824a61ba4b1bc0 + md5: fa8e429fdb9e5b757281f69b8cc4330b depends: - - libcxx >=16 + - __osx >=11.0 + - libcxx >=18 license: MIT license_family: MIT purls: [] - size: 198755 - timestamp: 1709239846651 -- kind: conda - name: pkgutil-resolve-name - version: 1.3.10 - build: pyhd8ed1ab_1 - build_number: 1 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/pkgutil-resolve-name-1.3.10-pyhd8ed1ab_1.conda - sha256: fecf95377134b0e8944762d92ecf7b0149c07d8186fb5db583125a2705c7ea0a - md5: 405678b942f2481cecdb3e010f4925d9 + size: 201076 + timestamp: 1733699127167 +- conda: https://conda.anaconda.org/conda-forge/noarch/pkgutil-resolve-name-1.3.10-pyhd8ed1ab_2.conda + sha256: adb2dde5b4f7da70ae81309cce6188ed3286ff280355cf1931b45d91164d2ad8 + md5: 5a5870a74432aa332f7d32180633ad05 depends: - - python >=3.6 + - python >=3.9 license: MIT AND PSF-2.0 purls: - pkg:pypi/pkgutil-resolve-name?source=project-defined-mapping - size: 10778 - timestamp: 1694617398467 -- kind: conda - name: platformdirs - version: 4.2.2 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.2.2-pyhd8ed1ab_0.conda - sha256: adc59384cf0b2fc6dc7362840151e8cb076349197a38f7230278252698a88442 - md5: 6f6cf28bf8e021933869bae3f84b8fc9 + size: 10693 + timestamp: 1733344619659 +- conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.3.6-pyhd8ed1ab_1.conda + sha256: bb50f6499e8bc1d1a26f17716c97984671121608dc0c3ecd34858112bce59a27 + md5: 577852c7e53901ddccc7e6a9959ddebe depends: - - python >=3.8 + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/platformdirs?source=project-defined-mapping - size: 20572 - timestamp: 1715777739019 -- kind: conda - name: pluggy - version: 1.5.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda - sha256: 33eaa3359948a260ebccf9cdc2fd862cea5a6029783289e13602d8e634cd9a26 - md5: d3483c8fc2dc2cc3f5cf43e26d60cabf + size: 20448 + timestamp: 1733232756001 +- conda: https://conda.anaconda.org/conda-forge/noarch/plotly-5.24.1-pyhd8ed1ab_1.conda + sha256: d1bbf2d80105bfc8a7ed9817888f4a1686ed393d6435572921add09cc9347c1c + md5: 71ac632876630091c81c50a05ec5e030 depends: - - python >=3.8 + - packaging + - python >=3.9 + - tenacity >=6.2.0 + constrains: + - ipywidgets >=7.6 + license: MIT + license_family: MIT + purls: + - pkg:pypi/plotly?source=project-defined-mapping + size: 8022748 + timestamp: 1733733328161 +- conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_1.conda + sha256: 122433fc5318816b8c69283aaf267c73d87aa2d09ce39f64c9805c9a3b264819 + md5: e9dcbce5f45f9ee500e728ae58b605b6 + depends: + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/pluggy?source=project-defined-mapping - size: 23815 - timestamp: 1713667175451 -- kind: conda - name: polars - version: 0.20.31 - build: py312h812d8f0_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/polars-0.20.31-py312h812d8f0_1.conda + size: 23595 + timestamp: 1733222855563 +- conda: https://conda.anaconda.org/conda-forge/linux-64/polars-0.20.31-py312hd26010a_1.conda + sha256: b72fbb124c666cc7ddbf5ac38193310b19b5b88d4dc24c8d7ca88e86d60cd944 + md5: c444edacfe51f9034ee19fa227939d4b + depends: + - libgcc-ng >=12 + - numpy >=1.16.0 + - packaging + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: MIT + license_family: MIT + purls: + - pkg:pypi/polars?source=project-defined-mapping + size: 22016623 + timestamp: 1719840857908 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/polars-0.20.31-py312h812d8f0_1.conda sha256: e51ba18e6343618a4bd5d3cbdc87da6962a0cc6479df0c72f47fe7f2b80f73d9 md5: ac8354805908cb1f37428599a44b6615 depends: @@ -13669,204 +13199,146 @@ packages: - pkg:pypi/polars?source=project-defined-mapping size: 18940611 timestamp: 1719852707042 -- kind: conda - name: polars - version: 0.20.31 - build: py312hd26010a_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/polars-0.20.31-py312hd26010a_1.conda - sha256: b72fbb124c666cc7ddbf5ac38193310b19b5b88d4dc24c8d7ca88e86d60cd944 - md5: c444edacfe51f9034ee19fa227939d4b +- conda: https://conda.anaconda.org/conda-forge/linux-64/proj-9.3.1-h1d62c97_0.conda + sha256: 234f8f7b255dc9036812ec30d097c0725047f3fc7e8e0bc7944e4e17d242ab99 + md5: 44ec51d0857d9be26158bb85caa74fdb depends: + - libcurl >=8.4.0,<9.0a0 - libgcc-ng >=12 - - numpy >=1.16.0 - - packaging - - python >=3.12,<3.13.0a0 - - python_abi 3.12.* *_cp312 + - libsqlite >=3.44.2,<4.0a0 + - libstdcxx-ng >=12 + - libtiff >=4.6.0,<4.8.0a0 + - sqlite + constrains: + - proj4 ==999999999999 license: MIT license_family: MIT - purls: - - pkg:pypi/polars?source=project-defined-mapping - size: 22016623 - timestamp: 1719840857908 -- kind: conda - name: prometheus_client - version: 0.20.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/prometheus_client-0.20.0-pyhd8ed1ab_0.conda - sha256: 757cd91d01c2e0b64fadf6bc9a11f558cf7638d897dfbaf7415ddf324d5405c9 - md5: 9a19b94034dd3abb2b348c8b93388035 + purls: [] + size: 3004737 + timestamp: 1701484763294 +- conda: https://conda.anaconda.org/conda-forge/noarch/prometheus_client-0.21.1-pyhd8ed1ab_0.conda + sha256: bc8f00d5155deb7b47702cb8370f233935704100dbc23e30747c161d1b6cf3ab + md5: 3e01e386307acc60b2f89af0b2e161aa depends: - - python >=3.8 + - python >=3.9 license: Apache-2.0 license_family: Apache purls: - pkg:pypi/prometheus-client?source=project-defined-mapping - size: 48913 - timestamp: 1707932844383 -- kind: conda - name: prompt-toolkit - version: 3.0.47 - build: pyha770c72_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/prompt-toolkit-3.0.47-pyha770c72_0.conda - sha256: d93ac5853e398aaa10f0dd7addd64b411f94ace1f9104d619cd250e19a5ac5b4 - md5: 1247c861065d227781231950e14fe817 + size: 49002 + timestamp: 1733327434163 +- conda: https://conda.anaconda.org/conda-forge/noarch/prompt-toolkit-3.0.48-pyha770c72_1.conda + sha256: 79fb7d1eeb490d4cc1b79f781bb59fe302ae38cf0a30907ecde75a7d399796cc + md5: 368d4aa48358439e07a97ae237491785 depends: - - python >=3.7 + - python >=3.9 - wcwidth constrains: - - prompt_toolkit 3.0.47 + - prompt_toolkit 3.0.48 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/prompt-toolkit?source=project-defined-mapping - size: 270710 - timestamp: 1718048095491 -- kind: conda - name: prompt_toolkit - version: 3.0.47 - build: hd8ed1ab_0 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/prompt_toolkit-3.0.47-hd8ed1ab_0.conda - sha256: 081ef6c9fbc280940c8d65683371795a8876cd4994b3fbdd0ccda7cc3ee87f74 - md5: 3e0c82ddcfe27eb4ae77f887cfd9f45b + size: 269848 + timestamp: 1733302634979 +- conda: https://conda.anaconda.org/conda-forge/noarch/prompt_toolkit-3.0.48-hd8ed1ab_1.conda + sha256: e4dd1b4eb467589edd51981c341d8ae0b3a71814541bd5fdcf0e55b5be22c4c0 + md5: bf730bb1f201e3f5a961c1fb2ffc4f05 depends: - - prompt-toolkit >=3.0.47,<3.0.48.0a0 + - prompt-toolkit >=3.0.48,<3.0.49.0a0 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/prompt-toolkit?source=project-defined-mapping - size: 6784 - timestamp: 1718048101184 -- kind: conda - name: psutil - version: 6.0.0 - build: py312h7e5086c_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-6.0.0-py312h7e5086c_0.conda - sha256: d677457b2ce2e6ef6c2845c653e5bc39be9a59a900d95a5a7771b490f754cb5f - md5: e45a140733a4805d80e282c1ede40d0b + size: 6634 + timestamp: 1733302636477 +- conda: https://conda.anaconda.org/conda-forge/linux-64/propcache-0.2.1-py312h66e93f0_0.conda + sha256: 5771311fb5ded614ca349c92579a0b752af55a310f40b71fc533e20625965391 + md5: 55d5742a696d7da1c1262e99b6217ceb depends: - - __osx >=11.0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/propcache + size: 52747 + timestamp: 1733391916349 +- conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-6.1.0-py312h66e93f0_0.conda + sha256: 0f309b435174e037d5cfe5ed26c1c5ad8152c68cfe61af17709ec31ec3d9f096 + md5: 0524eb91d3d78d76d671c6e3cd7cee82 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/psutil?source=project-defined-mapping - size: 501703 - timestamp: 1719274787455 -- kind: conda - name: psutil - version: 6.0.0 - build: py312h9a8786e_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/psutil-6.0.0-py312h9a8786e_0.conda - sha256: d629363515df957507411fd24db2a0635ac893e5d60b2ee2f656b53be9c70b1d - md5: 1aeffa86c55972ca4e88ac843eccedf2 + size: 488462 + timestamp: 1729847159916 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-6.1.0-py312h0bf5046_0.conda + sha256: 143a40f9c72d803744ebd6a60801c5cd17af152b293f8d59e90111ce62b53569 + md5: 61566f5c6e1d29d1d12882eb93e28532 depends: - - libgcc-ng >=12 + - __osx >=11.0 - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/psutil?source=project-defined-mapping - size: 493452 - timestamp: 1719274737481 -- kind: conda - name: psygnal - version: 0.11.1 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/psygnal-0.11.1-pyhd8ed1ab_0.conda - sha256: fc12b32c36c522d263bf24dbced4c755925198fa153bbddd7181b68e3443a468 - md5: b49c6ca5e5661b5473f91ac01782e487 + size: 493431 + timestamp: 1729847279283 +- conda: https://conda.anaconda.org/conda-forge/noarch/psygnal-0.11.1-pyhd8ed1ab_1.conda + sha256: b73c382b5e0197ee06176c5412245c092c3ef19cf9cfbde3f5ba7a47f326352d + md5: 086ce04684bf6f06c399d602b53d98e6 depends: - - python >=3.8 + - python >=3.9 - typing_extensions - wrapt license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/psygnal?source=project-defined-mapping - size: 63627 - timestamp: 1715085720906 -- kind: conda - name: pthread-stubs - version: '0.4' - build: h27ca646_1001 - build_number: 1001 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/pthread-stubs-0.4-h27ca646_1001.tar.bz2 - sha256: 9da9e6f5d51dff6ad2e4ee0874791437ba952e0a6249942273f0fedfd07ea826 - md5: d3f26c6494d4105d4ecb85203d687102 + size: 63671 + timestamp: 1733746769131 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-hb9d3cd8_1002.conda + sha256: 9c88f8c64590e9567c6c80823f0328e58d3b1efb0e1c539c0315ceca764e0973 + md5: b3c17d95b5a10c6e64a21fa17573e70e + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 license: MIT license_family: MIT purls: [] - size: 5696 - timestamp: 1606147608402 -- kind: conda - name: pthread-stubs - version: '0.4' - build: h36c2ea0_1001 - build_number: 1001 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-h36c2ea0_1001.tar.bz2 - sha256: 67c84822f87b641d89df09758da498b2d4558d47b920fd1d3fe6d3a871e000ff - md5: 22dad4df6e8630e8dff2428f6f6a7036 + size: 8252 + timestamp: 1726802366959 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pthread-stubs-0.4-hd74edd7_1002.conda + sha256: 8ed65e17fbb0ca944bfb8093b60086e3f9dd678c3448b5de212017394c247ee3 + md5: 415816daf82e0b23a736a069a75e9da7 depends: - - libgcc-ng >=7.5.0 + - __osx >=11.0 license: MIT license_family: MIT purls: [] - size: 5625 - timestamp: 1606147468727 -- kind: conda - name: ptyprocess - version: 0.7.0 - build: pyhd3deb0d_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/ptyprocess-0.7.0-pyhd3deb0d_0.tar.bz2 - sha256: fb31e006a25eb2e18f3440eb8d17be44c8ccfae559499199f73584566d0a444a - md5: 359eeb6536da0e687af562ed265ec263 + size: 8381 + timestamp: 1726802424786 +- conda: https://conda.anaconda.org/conda-forge/noarch/ptyprocess-0.7.0-pyhd8ed1ab_1.conda + sha256: a7713dfe30faf17508ec359e0bc7e0983f5d94682492469bd462cdaae9c64d83 + md5: 7d9daffbb8d8e0af0f769dbbcd173a54 depends: - - python + - python >=3.9 license: ISC purls: - pkg:pypi/ptyprocess?source=project-defined-mapping - size: 16546 - timestamp: 1609419417991 -- kind: conda - name: pugixml - version: '1.14' - build: h13dd4ca_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/pugixml-1.14-h13dd4ca_0.conda - sha256: 0bfeac4f1a374da9ff0a322344cdab577d397d6a0a0e5591f08cb7b491926825 - md5: 4de774bb04e03af9704ec1a2618c636c - depends: - - libcxx >=15.0.7 - license: MIT - license_family: MIT - purls: [] - size: 92472 - timestamp: 1696182843052 -- kind: conda - name: pugixml - version: '1.14' - build: h59595ed_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/pugixml-1.14-h59595ed_0.conda + size: 19457 + timestamp: 1733302371990 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pugixml-1.14-h59595ed_0.conda sha256: ea5f2d593177318f6b19af05018c953f41124cbb3bf21f9fdedfdb6ac42913ae md5: 2c97dd90633508b422c11bd3018206ab depends: @@ -13877,34 +13349,32 @@ packages: purls: [] size: 114871 timestamp: 1696182708943 -- kind: conda - name: pure_eval - version: 0.2.3 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/pure_eval-0.2.3-pyhd8ed1ab_0.conda - sha256: dcfcb3cee1ae0a89729601582cc3edea20ba13c9493967a03a693c67567af0c8 - md5: 0f051f09d992e0d08941706ad519ee0e +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pugixml-1.14-h13dd4ca_0.conda + sha256: 0bfeac4f1a374da9ff0a322344cdab577d397d6a0a0e5591f08cb7b491926825 + md5: 4de774bb04e03af9704ec1a2618c636c depends: - - python >=3.5 + - libcxx >=15.0.7 + license: MIT + license_family: MIT + purls: [] + size: 92472 + timestamp: 1696182843052 +- conda: https://conda.anaconda.org/conda-forge/noarch/pure_eval-0.2.3-pyhd8ed1ab_1.conda + sha256: 71bd24600d14bb171a6321d523486f6a06f855e75e547fa0cb2a0953b02047f0 + md5: 3bfdfb8dbcdc4af1ae3f9a8eb3948f04 + depends: + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/pure-eval?source=project-defined-mapping - size: 16551 - timestamp: 1721585805256 -- kind: conda - name: py-opencv - version: 4.10.0 - build: headless_py312hd31a7ba_3 - build_number: 3 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/py-opencv-4.10.0-headless_py312hd31a7ba_3.conda - sha256: e9e9781bccda8d60189acebad36c26f545ae4c61d5bccff80f23d56d77596a1f - md5: d539f1ec4d19e663001aeed9e05062e1 - depends: - - libopencv 4.10.0 headless_py312h7bc6ef4_3 + size: 16668 + timestamp: 1733569518868 +- conda: https://conda.anaconda.org/conda-forge/linux-64/py-opencv-4.10.0-qt6_py312h071dcc1_601.conda + sha256: 55a0507dd400bc5c960554ca5a6865676434adfff3a481e6fc2040fe94833135 + md5: f185431bac7667c06a494bd14a6d1610 + depends: + - libopencv 4.10.0 qt6_py312h131ea51_601 - libprotobuf >=4.25.3,<4.25.4.0a0 - numpy >=1.19,<3 - python >=3.12,<3.13.0a0 @@ -13912,19 +13382,13 @@ packages: license: Apache-2.0 license_family: Apache purls: [] - size: 1153557 - timestamp: 1723437490641 -- kind: conda - name: py-opencv - version: 4.10.0 - build: qt6_py312h071dcc1_603 - build_number: 603 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/py-opencv-4.10.0-qt6_py312h071dcc1_603.conda - sha256: 816f8a72d74d3d4534befb8ff9f1d254b83289060249eed253e4fe5fe3dffebd - md5: 56da7b5524b9c4975723b4fe288067bd - depends: - - libopencv 4.10.0 qt6_py312h6ebf6f7_603 + size: 1152900 + timestamp: 1718896824962 +- conda: https://conda.anaconda.org/conda-forge/linux-64/py-opencv-4.10.0-qt6_py312h071dcc1_604.conda + sha256: c6075b5a0d571c5c7342034bbe17a9d2addae9293cca9f892e823edaa26f8f42 + md5: b647c1dc74d48859a841f58e247fceb6 + depends: + - libopencv 4.10.0 qt6_py312h01efb12_604 - libprotobuf >=4.25.3,<4.25.4.0a0 - numpy >=1.19,<3 - python >=3.12,<3.13.0a0 @@ -13932,73 +13396,145 @@ packages: license: Apache-2.0 license_family: Apache purls: [] - size: 1152928 - timestamp: 1723433950551 -- kind: conda - name: pyarrow - version: 17.0.0 - build: py312h9cebb41_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/pyarrow-17.0.0-py312h9cebb41_1.conda - sha256: f08a9ae2c5b57085ef70175928f7bd0954d9ea56ef6cd2cd51a29b6a7c879204 - md5: 7e8ddbd44fb99ba376b09c4e9e61e509 + size: 1153109 + timestamp: 1726969156045 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/py-opencv-4.10.0-headless_py312hd31a7ba_6.conda + sha256: acd76c373294a77a120836dd4a7b1db5f7e43e1af923895f86874369a0732622 + md5: 82d0947d8fe6d010558529813a0ce552 + depends: + - libopencv 4.10.0 headless_py312haa779ad_6 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - numpy >=1.19,<3 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 1153110 + timestamp: 1727651572375 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pyarrow-17.0.0-py312h9cebb41_2.conda + sha256: 9e1baddd1199e244f4f8be10c7250691088948583ab3955c510b90eb71c91a2c + md5: 5f7d505626cb057e1320bbd46dd02ef2 + depends: + - libarrow-acero 17.0.0.* + - libarrow-dataset 17.0.0.* + - libarrow-substrait 17.0.0.* + - libparquet 17.0.0.* + - numpy >=1.19,<3 + - pyarrow-core 17.0.0 *_2_* + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/pyarrow?source=project-defined-mapping + size: 25538 + timestamp: 1730169714708 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pyarrow-18.1.0-py312h7900ff3_0.conda + sha256: 46a61c29375d3bf1933eae61c7861394c168898915d59fc99bf05e46de2ff5ad + md5: ac65b70df28687c6af4270923c020bdd + depends: + - libarrow-acero 18.1.0.* + - libarrow-dataset 18.1.0.* + - libarrow-substrait 18.1.0.* + - libparquet 18.1.0.* + - pyarrow-core 18.1.0 *_0_* + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/pyarrow?source=project-defined-mapping + size: 25213 + timestamp: 1732610785600 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyarrow-17.0.0-py312ha814d7c_2.conda + sha256: d6433c343120e723cad92b52ea05c16e05096845489275a697201ce0a50fc568 + md5: 04a90c4ce691f2e289658dd475f69631 depends: - libarrow-acero 17.0.0.* - libarrow-dataset 17.0.0.* - libarrow-substrait 17.0.0.* - libparquet 17.0.0.* - numpy >=1.19,<3 - - pyarrow-core 17.0.0 *_1_* + - pyarrow-core 17.0.0 *_2_* + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/pyarrow?source=project-defined-mapping + size: 25811 + timestamp: 1730169125041 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyarrow-18.1.0-py312h1f38498_0.conda + sha256: 06c0e208d5bf15051874097366c8e8e5db176dffba38526f227a34e80cc8e9bc + md5: 3710616b880b31d0c8afd8ae7e12392a + depends: + - libarrow-acero 18.1.0.* + - libarrow-dataset 18.1.0.* + - libarrow-substrait 18.1.0.* + - libparquet 18.1.0.* + - pyarrow-core 18.1.0 *_0_* + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/pyarrow?source=project-defined-mapping + size: 25375 + timestamp: 1732610892198 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pyarrow-core-17.0.0-py312h01725c0_2_cpu.conda + build_number: 2 + sha256: e5ed32ee7664a6322263e446d3504a35ff6f5452b17f1161bce7922d03f3cbd4 + md5: add603bfa43d9bf3f06783f780e1a817 + depends: + - __glibc >=2.17,<3.0.a0 + - libarrow 17.0.0.* *cpu + - libgcc >=13 + - libstdcxx >=13 + - libzlib >=1.3.1,<2.0a0 + - numpy >=1.19,<3 - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 + constrains: + - apache-arrow-proc =*=cpu license: Apache-2.0 license_family: APACHE purls: - pkg:pypi/pyarrow?source=project-defined-mapping - size: 25693 - timestamp: 1722487649034 -- kind: conda - name: pyarrow - version: 17.0.0 - build: py312ha814d7c_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/pyarrow-17.0.0-py312ha814d7c_1.conda - sha256: 1ea696a3c4eb6ad9a12e1ae5f368789bc2cd34519a316f6557abd771f6fa4d9a - md5: 324baefe2624473b422212c2d1db964b + size: 4607408 + timestamp: 1730169265797 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pyarrow-core-18.1.0-py312h01725c0_0_cpu.conda + sha256: 948a4161c56f846d374a3721a657e58ddbc992a29b3b3e7a6411975c30361d94 + md5: ee80934a6c280ff8635f8db5dec11e04 depends: - - libarrow-acero 17.0.0.* - - libarrow-dataset 17.0.0.* - - libarrow-substrait 17.0.0.* - - libparquet 17.0.0.* - - numpy >=1.19,<3 - - pyarrow-core 17.0.0 *_1_* + - __glibc >=2.17,<3.0.a0 + - libarrow 18.1.0.* *cpu + - libgcc >=13 + - libstdcxx >=13 + - libzlib >=1.3.1,<2.0a0 - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 + constrains: + - numpy >=1.21,<3 + - apache-arrow-proc =*=cpu license: Apache-2.0 license_family: APACHE purls: - pkg:pypi/pyarrow?source=project-defined-mapping - size: 25928 - timestamp: 1722487521448 -- kind: conda - name: pyarrow-core - version: 17.0.0 - build: py312h9cafe31_1_cpu - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/pyarrow-core-17.0.0-py312h9cafe31_1_cpu.conda - sha256: 0b594422fb27578470c42d238d7152f2335ba1a5106049201ac08b3a7e3505c0 - md5: 235827b9c93850cafdd2d5ab359893f9 + size: 4612916 + timestamp: 1732610377259 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyarrow-core-17.0.0-py312hc40f475_2_cpu.conda + build_number: 2 + sha256: 708488e602a159fa38a7fd5fa4466e9f093761dc4a8538661f06be3df42f30a5 + md5: bc617fed2854d65a16760d2bf02a475c depends: - - __glibc >=2.17,<3.0.a0 + - __osx >=11.0 - libarrow 17.0.0.* *cpu - - libgcc-ng >=12 - - libstdcxx-ng >=12 + - libcxx >=18 - libzlib >=1.3.1,<2.0a0 - numpy >=1.19,<3 - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 constrains: - apache-arrow-proc =*=cpu @@ -14006,119 +13542,122 @@ packages: license_family: APACHE purls: - pkg:pypi/pyarrow?source=project-defined-mapping - size: 4645745 - timestamp: 1722487499158 -- kind: conda - name: pyarrow-core - version: 17.0.0 - build: py312he20ac61_1_cpu - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/pyarrow-core-17.0.0-py312he20ac61_1_cpu.conda - sha256: 2aa30a7d877a61cce833cc9393a96295a2bdd8da09ae19c6c93dc6be143599d5 - md5: 5741dbf1e41816bc7e52ac5372da021e + size: 3990396 + timestamp: 1730169098217 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyarrow-core-18.1.0-py312hc40f475_0_cpu.conda + sha256: 063eb168a29d4ce6d9ed865e9e1ad3b6e141712189955a79e06b24ddc0cbbc9c + md5: 9859e7c4b94bbf69772dbf0511101cec depends: - __osx >=11.0 - - libarrow 17.0.0.* *cpu - - libcxx >=17 + - libarrow 18.1.0.* *cpu + - libcxx >=18 - libzlib >=1.3.1,<2.0a0 - - numpy >=1.19,<3 - python >=3.12,<3.13.0a0 - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 constrains: + - numpy >=1.21,<3 - apache-arrow-proc =*=cpu license: Apache-2.0 license_family: APACHE purls: - pkg:pypi/pyarrow?source=project-defined-mapping - size: 3977905 - timestamp: 1722487471071 -- kind: conda - name: pycparser - version: '2.22' - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyhd8ed1ab_0.conda - sha256: 406001ebf017688b1a1554b49127ca3a4ac4626ec0fd51dc75ffa4415b720b64 - md5: 844d9eb3b43095b031874477f7d70088 + size: 3909116 + timestamp: 1732610863261 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pycocotools-2.0.8-py312hc0a28a1_1.conda + sha256: bf6d52676b791ebf9fa456b226c2b8970b88027cbe9078ce0cc704ed4f81a8e4 + md5: a816c75370c9d95321a28ccbab5118ba depends: - - python >=3.8 + - __glibc >=2.17,<3.0.a0 + - cython + - libgcc >=13 + - matplotlib-base + - numpy >=1.19,<3 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/pycocotools?source=project-defined-mapping + size: 117741 + timestamp: 1731600668698 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pycocotools-2.0.8-py312h755e627_1.conda + sha256: f59d993b5c5c00883eadf6243a36c1a71bb98be213b84ae4903102194dae4d2e + md5: a04663295a7c37c0ee04ea2d4316a67e + depends: + - __osx >=11.0 + - cython + - matplotlib-base + - numpy >=1.19,<3 + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/pycocotools?source=project-defined-mapping + size: 102991 + timestamp: 1731600789555 +- conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda + sha256: 79db7928d13fab2d892592223d7570f5061c192f27b9febd1a418427b719acc6 + md5: 12c566707c80111f9799308d9e265aef + depends: + - python >=3.9 + - python license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/pycparser?source=project-defined-mapping - size: 105098 - timestamp: 1711811634025 -- kind: pypi + size: 110100 + timestamp: 1733195786147 +- pypi: https://files.pythonhosted.org/packages/62/51/72c18c55cf2f46ff4f91ebcc8f75aa30f7305f3d726be3f4ebffb4ae972b/pydantic-2.10.3-py3-none-any.whl name: pydantic - version: 2.9.0 - url: https://files.pythonhosted.org/packages/54/38/95bdb5dfcebad2c11c88f7aa2d635fe53a0b7405ef39a6850c8bced455d4/pydantic-2.9.0-py3-none-any.whl - sha256: f66a7073abd93214a20c5f7b32d56843137a7a2e70d02111f3be287035c45370 + version: 2.10.3 + sha256: be04d85bbc7b65651c5f8e6b9976ed9c6f41782a55524cef079a34a0bb82144d requires_dist: - - annotated-types>=0.4.0 - - pydantic-core==2.23.2 - - typing-extensions>=4.12.2 ; python_full_version >= '3.13' - - typing-extensions>=4.6.1 ; python_full_version < '3.13' - - tzdata ; python_full_version >= '3.9' + - annotated-types>=0.6.0 + - pydantic-core==2.27.1 + - typing-extensions>=4.12.2 - email-validator>=2.0.0 ; extra == 'email' + - tzdata ; python_full_version >= '3.9' and platform_system == 'Windows' and extra == 'timezone' requires_python: '>=3.8' -- kind: pypi +- pypi: https://files.pythonhosted.org/packages/7b/9e/f8063952e4a7d0127f5d1181addef9377505dcce3be224263b25c4f0bfd9/pydantic_core-2.27.1-cp312-cp312-macosx_11_0_arm64.whl name: pydantic-core - version: 2.23.2 - url: https://files.pythonhosted.org/packages/9e/e3/5c29d8fa6dfabd7809fe623fd17959e1b672410681a8c3811eefa42b8051/pydantic_core-2.23.2-cp312-cp312-macosx_11_0_arm64.whl - sha256: 6294907eaaccf71c076abdd1c7954e272efa39bb043161b4b8aa1cd76a16ce43 + version: 2.27.1 + sha256: 5f8c4718cd44ec1580e180cb739713ecda2bdee1341084c1467802a417fe0f02 requires_dist: - typing-extensions>=4.6.0,!=4.7.0 requires_python: '>=3.8' -- kind: pypi +- pypi: https://files.pythonhosted.org/packages/8a/c6/8ae0831bf77f356bb73127ce5a95fe115b10f820ea480abbd72d3cc7ccf3/pydantic_core-2.27.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl name: pydantic-core - version: 2.23.2 - url: https://files.pythonhosted.org/packages/ad/fc/6b4f95c64bbeadaa6f84cffb51f469f6fdd61215d97b4ec8d89d027e574b/pydantic_core-2.23.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl - sha256: 2b1a195efd347ede8bcf723e932300292eb13a9d2a3c1f84eb8f37cbbc905b7f + version: 2.27.1 + sha256: 7597c07fbd11515f654d6ece3d0e4e5093edc30a436c63142d9a4b8e22f19c35 requires_dist: - typing-extensions>=4.6.0,!=4.7.0 requires_python: '>=3.8' -- kind: conda - name: pygments - version: 2.18.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/pygments-2.18.0-pyhd8ed1ab_0.conda - sha256: 78267adf4e76d0d64ea2ffab008c501156c108bb08fecb703816fb63e279780b - md5: b7f5c092b8f9800150d998a71b76d5a1 +- conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.18.0-pyhd8ed1ab_1.conda + sha256: 0d6133545f268b2b89c2617c196fc791f365b538d4057ecd636d658c3b1e885d + md5: b38dc0206e2a530e5c2cf11dc086b31a depends: - - python >=3.8 + - python >=3.9 license: BSD-2-Clause license_family: BSD purls: - pkg:pypi/pygments?source=project-defined-mapping - size: 879295 - timestamp: 1714846885370 -- kind: pypi + size: 876700 + timestamp: 1733221731178 +- pypi: https://files.pythonhosted.org/packages/c3/7e/e2b71b9221ccb8503dce9673e3cb36edcdc314ec374f9e69e6d38ed1abde/pykitti-0.3.1-py2.py3-none-any.whl name: pykitti version: 0.3.1 - url: https://files.pythonhosted.org/packages/c3/7e/e2b71b9221ccb8503dce9673e3cb36edcdc314ec374f9e69e6d38ed1abde/pykitti-0.3.1-py2.py3-none-any.whl sha256: 5cde227d6f8ae1cf75ecb656990eb6aaf1b31e6d6877f519d1570e0c9414c9c4 requires_dist: - numpy - matplotlib - pillow - pandas -- kind: pypi - name: pyliblzfse - version: 0.4.1 - url: git+https://github.com/ydkhatri/pyliblzfse.git@a8c00b6bf866410e658a82f88caa04b2cf0a5fea -- kind: conda - name: pyobjc-core - version: 10.3.1 - build: py312hbb55c70_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/pyobjc-core-10.3.1-py312hbb55c70_0.conda - sha256: 407fca7feca5dceb058a48b7272f342e4e8708eba4ac890a076d5499da3d7fe4 - md5: ce11aaac866b943dbb644b70a820385e +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyobjc-core-10.3.2-py312hb9d441b_0.conda + sha256: 6c110c64e7cc0a28416414446698ab310a9261525a6aa630b2c4f50891867719 + md5: 663e894deb5a24c8931fd8224f19a1fd depends: - __osx >=11.0 - libffi >=3.4,<4.0a0 @@ -14130,20 +13669,15 @@ packages: license_family: MIT purls: - pkg:pypi/pyobjc-core?source=project-defined-mapping - size: 491160 - timestamp: 1718171865193 -- kind: conda - name: pyobjc-framework-cocoa - version: 10.3.1 - build: py312hbb55c70_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/pyobjc-framework-cocoa-10.3.1-py312hbb55c70_0.conda - sha256: 9bd12bc17b6307dc3ca5bc3aac5f82a01bc9953bd448616b6f62577ba4e04148 - md5: ba19305f7b6e524edb92cefdd47fbbb1 + size: 484571 + timestamp: 1732987487536 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyobjc-framework-cocoa-10.3.2-py312hb9d441b_0.conda + sha256: 5a78f97cb7414cb4b78b777dcfcffb08da42ced866e8ef6455a57c2230908bfe + md5: 41e4f28d545565e48f1f819cf8dac5c7 depends: - __osx >=11.0 - libffi >=3.4,<4.0a0 - - pyobjc-core 10.3.1.* + - pyobjc-core 10.3.2.* - python >=3.12,<3.13.0a0 - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 @@ -14151,87 +13685,69 @@ packages: license_family: MIT purls: - pkg:pypi/pyobjc-framework-cocoa?source=project-defined-mapping - size: 379357 - timestamp: 1718645762924 -- kind: conda - name: pyparsing - version: 3.1.4 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.1.4-pyhd8ed1ab_0.conda - sha256: 8714a83f1aeac278b3eb33c7cb880c95c9a5924e7a5feeb9e87e7d0837afa085 - md5: 4d91352a50949d049cf9714c8563d433 + size: 380414 + timestamp: 1733168930888 +- conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.2.0-pyhd8ed1ab_2.conda + sha256: 09a5484532e24a33649ab612674fd0857bbdcfd6640a79d13a6690fb742a36e1 + md5: 4c05a2bcf87bb495512374143b57cf28 depends: - - python >=3.6 + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/pyparsing?source=project-defined-mapping - size: 90129 - timestamp: 1724616224956 -- kind: pypi + size: 92319 + timestamp: 1733222687746 +- pypi: https://files.pythonhosted.org/packages/68/6b/a4cc6a28ac80d3bccef0bf869634ee21731e1a85e5ce508c41e1ba0c8437/pyransac3d-0.6.0-py3-none-any.whl name: pyransac3d version: 0.6.0 - url: https://files.pythonhosted.org/packages/68/6b/a4cc6a28ac80d3bccef0bf869634ee21731e1a85e5ce508c41e1ba0c8437/pyransac3d-0.6.0-py3-none-any.whl sha256: d081abf704b97b5c087418202acac385872da60d7af08556e91faf290784443f requires_python: '>=3.6' -- kind: conda - name: pyright - version: 1.1.379 - build: py312h024a12e_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/pyright-1.1.379-py312h024a12e_0.conda - sha256: 34bab9d9b307a45413e9a0cdd34f1710c278557f249e1f1020c4ffa9aaa15e76 - md5: 35999ba62315adbc5b52b3b1a897ba00 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pyright-1.1.390-py312h66e93f0_0.conda + sha256: b84cb909a8feab12dd6ca63842edb8f872f6e430f0b9032253ac418195f55e37 + md5: 1247197520c3a57c4e169299b7b36a65 depends: - - __osx >=11.0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 - nodeenv >=1.6.0 - nodejs - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 + - typing_extensions >=4.1 license: MIT license_family: MIT purls: - pkg:pypi/pyright?source=project-defined-mapping - size: 41238 - timestamp: 1725471047244 -- kind: conda - name: pyright - version: 1.1.379 - build: py312h66e93f0_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/pyright-1.1.379-py312h66e93f0_0.conda - sha256: 1995c4b0d282eab43e27d0d8367abb2bc5e5dde57b9ea9407a5bb5fd3eb6561e - md5: 3fff885ecb0ef2538e197c7262d69db5 + size: 41412 + timestamp: 1733360518015 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyright-1.1.390-py312hea69d52_0.conda + sha256: f2524d3c479ab328f587a9d76b0b01ed56fb2c6cc5615709d8d7a6aa5411924e + md5: cd56338591f63420b6c50ea50913edac depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=13 + - __osx >=11.0 - nodeenv >=1.6.0 - nodejs - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 + - typing_extensions >=4.1 license: MIT license_family: MIT purls: - pkg:pypi/pyright?source=project-defined-mapping - size: 40873 - timestamp: 1725471023354 -- kind: conda - name: pyside6 - version: 6.7.2 - build: py312hb5137db_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/pyside6-6.7.2-py312hb5137db_2.conda - sha256: d270c55f5874867c2c258fcc54bda2bb9d03f2e9f2e184c3edd92a71f4deca2f - md5: 99889d0c042cc4dfb9a758619d487282 + size: 42322 + timestamp: 1733360649191 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pyside6-6.7.2-py312h91f0f75_4.conda + sha256: 04e65bdd98b8de001f6f52861958b0f593cdc255613e729972ddcfa4c4a5b75d + md5: ee40e3e211a123bfc389f8baffc232df depends: - __glibc >=2.17,<3.0.a0 - - libclang13 >=18.1.8 - - libgcc-ng >=12 - - libstdcxx-ng >=12 + - libclang13 >=19.1.0 + - libegl >=1.7.0,<2.0a0 + - libgcc >=13 + - libgl >=1.7.0,<2.0a0 + - libopengl >=1.7.0,<2.0a0 + - libstdcxx >=13 - libxml2 >=2.12.7,<3.0a0 - libxslt >=1.1.39,<2.0a0 - python >=3.12,<3.13.0a0 @@ -14242,43 +13758,53 @@ packages: license_family: LGPL purls: - pkg:pypi/pyside6?source=project-defined-mapping - size: 10639049 - timestamp: 1723107283396 -- kind: conda - name: pysocks - version: 1.7.1 - build: pyha2e5f31_6 - build_number: 6 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyha2e5f31_6.tar.bz2 - sha256: a42f826e958a8d22e65b3394f437af7332610e43ee313393d1cf143f0a2d274b - md5: 2a7de29fb590ca14b5243c4c812c8025 + size: 10545427 + timestamp: 1727246336535 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pyside6-6.7.3-py312h91f0f75_1.conda + sha256: e9d26444e4a554a71e885017898b101d388855277b6604f3235e50b63cc66fe0 + md5: 64a74d686fd29fa04c4c313a688e2421 + depends: + - __glibc >=2.17,<3.0.a0 + - libclang13 >=19.1.0 + - libegl >=1.7.0,<2.0a0 + - libgcc >=13 + - libgl >=1.7.0,<2.0a0 + - libopengl >=1.7.0,<2.0a0 + - libstdcxx >=13 + - libxml2 >=2.12.7,<3.0a0 + - libxslt >=1.1.39,<2.0a0 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - qt6-main 6.7.3.* + - qt6-main >=6.7.3,<6.8.0a0 + license: LGPL-3.0-only + license_family: LGPL + purls: + - pkg:pypi/pyside6?source=project-defined-mapping + size: 10458409 + timestamp: 1727987584620 +- conda: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyha55dd90_7.conda + sha256: ba3b032fa52709ce0d9fd388f63d330a026754587a2f461117cac9ab73d8d0d8 + md5: 461219d1a5bd61342293efa2c0c90eac depends: - __unix - - python >=3.8 + - python >=3.9 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/pysocks?source=project-defined-mapping - size: 18981 - timestamp: 1661604969727 -- kind: conda - name: pytest - version: 8.3.2 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/pytest-8.3.2-pyhd8ed1ab_0.conda - sha256: 72c84a3cd9fe82835a88e975fd2a0dbf2071d1c423ea4f79e7930578c1014873 - md5: e010a224b90f1f623a917c35addbb924 + size: 21085 + timestamp: 1733217331982 +- conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.3.4-pyhd8ed1ab_1.conda + sha256: 75245ca9d0cbd6d38bb45ec02430189a9d4c21c055c5259739d738a2298d61b3 + md5: 799ed216dc6af62520f32aa39bc1c2bb depends: - colorama - exceptiongroup >=1.0.0rc8 - iniconfig - packaging - pluggy <2,>=1.5 - - python >=3.8 + - python >=3.9 - tomli >=1 constrains: - pytest-faulthandler >=2 @@ -14286,109 +13812,101 @@ packages: license_family: MIT purls: - pkg:pypi/pytest?source=project-defined-mapping - size: 257671 - timestamp: 1721923749407 -- kind: conda - name: python - version: 3.12.5 - build: h2ad013b_0_cpython - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/python-3.12.5-h2ad013b_0_cpython.conda - sha256: e2aad83838988725d4ffba4e9717b9328054fd18a668cff3377e0c50f109e8bd - md5: 9c56c4df45f6571b13111d8df2448692 + size: 259195 + timestamp: 1733217599806 +- conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.12.8-h9e4cc4f_1_cpython.conda + build_number: 1 + sha256: 3f0e0518c992d8ccfe62b189125721309836fe48a010dc424240583e157f9ff0 + md5: 7fd2fd79436d9b473812f14e86746844 depends: - __glibc >=2.17,<3.0.a0 - bzip2 >=1.0.8,<2.0a0 - ld_impl_linux-64 >=2.36.1 - - libexpat >=2.6.2,<3.0a0 + - libexpat >=2.6.4,<3.0a0 - libffi >=3.4,<4.0a0 - - libgcc-ng >=12 + - libgcc >=13 + - liblzma >=5.6.3,<6.0a0 - libnsl >=2.0.1,<2.1.0a0 - - libsqlite >=3.46.0,<4.0a0 + - libsqlite >=3.47.0,<4.0a0 - libuuid >=2.38.1,<3.0a0 - libxcrypt >=4.4.36 - libzlib >=1.3.1,<2.0a0 - ncurses >=6.5,<7.0a0 - - openssl >=3.3.1,<4.0a0 + - openssl >=3.4.0,<4.0a0 - readline >=8.2,<9.0a0 - tk >=8.6.13,<8.7.0a0 - tzdata - - xz >=5.2.6,<6.0a0 constrains: - python_abi 3.12.* *_cp312 license: Python-2.0 purls: [] - size: 31663253 - timestamp: 1723143721353 -- kind: conda - name: python - version: 3.12.5 - build: h30c5eda_0_cpython - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.12.5-h30c5eda_0_cpython.conda - sha256: 1319e918fb54c9491832a9731cad00235a76f61c6f9b23fc0f70cdfb74c950ea - md5: 5e315581e2948dfe3bcac306540e9803 + size: 31565686 + timestamp: 1733410597922 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.12.8-hc22306f_1_cpython.conda + build_number: 1 + sha256: 7586a711b1b08a9df8864e26efdc06980bdfb0e18d5ac4651d0fee30a8d3e3a0 + md5: 54ca5b5d92ef3a3ba61e195ee882a518 depends: - __osx >=11.0 - bzip2 >=1.0.8,<2.0a0 - - libexpat >=2.6.2,<3.0a0 + - libexpat >=2.6.4,<3.0a0 - libffi >=3.4,<4.0a0 - - libsqlite >=3.46.0,<4.0a0 + - liblzma >=5.6.3,<6.0a0 + - libsqlite >=3.47.0,<4.0a0 - libzlib >=1.3.1,<2.0a0 - ncurses >=6.5,<7.0a0 - - openssl >=3.3.1,<4.0a0 + - openssl >=3.4.0,<4.0a0 - readline >=8.2,<9.0a0 - tk >=8.6.13,<8.7.0a0 - tzdata - - xz >=5.2.6,<6.0a0 constrains: - python_abi 3.12.* *_cp312 license: Python-2.0 purls: [] - size: 12926356 - timestamp: 1723142203193 -- kind: conda - name: python-dateutil - version: 2.9.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0-pyhd8ed1ab_0.conda - sha256: f3ceef02ac164a8d3a080d0d32f8e2ebe10dd29e3a685d240e38b3599e146320 - md5: 2cf4264fffb9e6eff6031c5b6884d61c + size: 12998673 + timestamp: 1733408900971 +- conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhff2d567_1.conda + sha256: a50052536f1ef8516ed11a844f9413661829aa083304dc624c5925298d078d79 + md5: 5ba79d7c71f03c678c8ead841f347d6e depends: - - python >=3.7 + - python >=3.9 - six >=1.5 license: Apache-2.0 license_family: APACHE purls: - pkg:pypi/python-dateutil?source=project-defined-mapping - size: 222742 - timestamp: 1709299922152 -- kind: conda - name: python-fastjsonschema - version: 2.20.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.20.0-pyhd8ed1ab_0.conda - sha256: 7d8c931b89c9980434986b4deb22c2917b58d9936c3974139b9c10ae86fdfe60 - md5: b98d2018c01ce9980c03ee2850690fab + size: 222505 + timestamp: 1733215763718 +- conda: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.21.1-pyhd8ed1ab_0.conda + sha256: 1b09a28093071c1874862422696429d0d35bd0b8420698003ac004746c5e82a2 + md5: 38e34d2d1d9dca4fb2b9a0a04f604e2c depends: - - python >=3.3 + - python >=3.9 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/fastjsonschema?source=project-defined-mapping - size: 226165 - timestamp: 1718477110630 -- kind: conda - name: python-json-logger - version: 2.0.7 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/python-json-logger-2.0.7-pyhd8ed1ab_0.conda + size: 226259 + timestamp: 1733236073335 +- pypi: https://files.pythonhosted.org/packages/08/be/4781f7da7dde661d32925c0a129d268e03e6bbe00aaa86e48af59c70da61/python_fcl-0.7.0.6-cp312-cp312-macosx_11_0_arm64.whl + name: python-fcl + version: 0.7.0.6 + sha256: 3783f1f806006d78641e9b8cd5c2ba09af0f5e750b263582fe5f0103d7822251 + requires_dist: + - cython + - numpy ; python_full_version < '3.12' + - numpy>=1.26.0b1 ; python_full_version >= '3.12' + requires_python: '>=3.7' +- pypi: https://files.pythonhosted.org/packages/c0/00/cdb2afde2d7700d26b2df90bc40d72d18585e4f9a5d63d49b210a8d6bad0/python_fcl-0.7.0.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl + name: python-fcl + version: 0.7.0.6 + sha256: bf5c46915eec67343c4072ab13d5704edd58f19b4cb0040a1f9014a1f1a27af2 + requires_dist: + - cython + - numpy ; python_full_version < '3.12' + - numpy>=1.26.0b1 ; python_full_version >= '3.12' + requires_python: '>=3.7' +- conda: https://conda.anaconda.org/conda-forge/noarch/python-json-logger-2.0.7-pyhd8ed1ab_0.conda sha256: 4790787fe1f4e8da616edca4acf6a4f8ed4e7c6967aa31b920208fc8f95efcca md5: a61bf9ec79426938ff785eb69dbb1960 depends: @@ -14399,33 +13917,21 @@ packages: - pkg:pypi/python-json-logger?source=project-defined-mapping size: 13383 timestamp: 1677079727691 -- kind: conda - name: python-lzf - version: 0.2.6 - build: py312h41a817b_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/python-lzf-0.2.6-py312h41a817b_2.conda - sha256: 4be1c41f8cc0b288c07afc9e84302bbdc36a41804b2156d904797e43339ff8bd - md5: 289804bbcb832d22128ec63e10fcbb30 +- conda: https://conda.anaconda.org/conda-forge/linux-64/python-lzf-0.2.6-py312h318bf5b_4.conda + sha256: 84bb7073e7efabbf9cb72a1b58864d40e7d901bb22b317e42b1595a0172ffa13 + md5: 0b2ec4f29a823bb10d72b996849c60fc depends: + - python 3.12.* *_cpython - __glibc >=2.17,<3.0.a0 - - libgcc-ng >=12 - - python >=3.12,<3.13.0a0 + - libgcc >=13 - python_abi 3.12.* *_cp312 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/python-lzf?source=project-defined-mapping - size: 15514 - timestamp: 1722963404335 -- kind: conda - name: python-lzf - version: 0.2.6 - build: pyh568cf5c_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/python-lzf-0.2.6-pyh568cf5c_0.conda + size: 18941 + timestamp: 1731412215238 +- conda: https://conda.anaconda.org/conda-forge/noarch/python-lzf-0.2.6-pyh568cf5c_0.conda sha256: 74402a98c3e3051dbc4141a171481f74b49890c307133b767311a7c5e5e2611b md5: 9be656ca095abc55199aaaf0198b805c depends: @@ -14436,34 +13942,13 @@ packages: - pkg:pypi/python-lzf?source=project-defined-mapping size: 15522 timestamp: 1722611370852 -- kind: pypi +- pypi: https://files.pythonhosted.org/packages/45/58/38b5afbc1a800eeea951b9285d3912613f2603bdf897a4ab0f4bd7f405fc/python_multipart-0.0.20-py3-none-any.whl name: python-multipart - version: 0.0.9 - url: https://files.pythonhosted.org/packages/3d/47/444768600d9e0ebc82f8e347775d24aef8f6348cf00e9fa0e81910814e6d/python_multipart-0.0.9-py3-none-any.whl - sha256: 97ca7b8ea7b05f977dc3849c3ba99d51689822fab725c3703af7c866a0c2b215 - requires_dist: - - atomicwrites==1.4.1 ; extra == 'dev' - - attrs==23.2.0 ; extra == 'dev' - - coverage==7.4.1 ; extra == 'dev' - - hatch ; extra == 'dev' - - invoke==2.2.0 ; extra == 'dev' - - more-itertools==10.2.0 ; extra == 'dev' - - pbr==6.0.0 ; extra == 'dev' - - pluggy==1.4.0 ; extra == 'dev' - - py==1.11.0 ; extra == 'dev' - - pytest-cov==4.1.0 ; extra == 'dev' - - pytest-timeout==2.2.0 ; extra == 'dev' - - pytest==8.0.0 ; extra == 'dev' - - pyyaml==6.0.1 ; extra == 'dev' - - ruff==0.2.1 ; extra == 'dev' + version: 0.0.20 + sha256: 8a62d3a8335e06589fe01f2a3e178cdcc632f3fbe0d492ad9ee0ec35aab1f104 requires_python: '>=3.8' -- kind: conda - name: python_abi - version: '3.12' - build: 5_cp312 +- conda: https://conda.anaconda.org/conda-forge/linux-64/python_abi-3.12-5_cp312.conda build_number: 5 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/python_abi-3.12-5_cp312.conda sha256: d10e93d759931ffb6372b45d65ff34d95c6000c61a07e298d162a3bc2accebb0 md5: 0424ae29b104430108f5218a66db7260 constrains: @@ -14473,13 +13958,8 @@ packages: purls: [] size: 6238 timestamp: 1723823388266 -- kind: conda - name: python_abi - version: '3.12' - build: 5_cp312 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/python_abi-3.12-5_cp312.conda build_number: 5 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/python_abi-3.12-5_cp312.conda sha256: 49d624e4b809c799d2bf257b22c23cf3fc4460f5570d9a58e7ad86350aeaa1f4 md5: b76f9b1c862128e56ac7aa8cd2333de9 constrains: @@ -14489,73 +13969,39 @@ packages: purls: [] size: 6278 timestamp: 1723823099686 -- kind: conda - name: pytorch - version: 2.3.0 - build: cpu_generic_py312h2aa0b4f_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/pytorch-2.3.0-cpu_generic_py312h2aa0b4f_1.conda - sha256: 1c19d12e2e220f836ab53f717dadb0023798127dfb0bd79555e05caec86c09d2 - md5: 87261deefc70335ec2235cfcbf8b4bf9 - depends: - - __osx >=11.0 - - filelock - - fsspec - - jinja2 - - libabseil * cxx17* - - libabseil >=20240116.2,<20240117.0a0 - - libcblas >=3.9.0,<4.0a0 - - libcxx >=16 - - liblapack >=3.9.0,<4.0a0 - - libprotobuf >=4.25.3,<4.25.4.0a0 - - libtorch 2.3.0.* - - libuv >=1.48.0,<2.0a0 - - llvm-openmp >=16.0.6 - - networkx - - nomkl - - numpy >=1.19,<3 - - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - - python_abi 3.12.* *_cp312 - - sleef >=3.5.1,<4.0a0 - - sympy - - typing_extensions - constrains: - - pytorch-gpu ==99999999 - - pytorch-cpu ==2.3.0 - license: BSD-3-Clause - license_family: BSD - purls: - - pkg:pypi/torch?source=project-defined-mapping - size: 52751144 - timestamp: 1716588414838 -- kind: conda - name: pytorch - version: 2.3.0 - build: cpu_generic_py312h2f1fc2b_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/pytorch-2.3.0-cpu_generic_py312h2f1fc2b_1.conda - sha256: 8d7e52a0dcb54f3ac35b8e413be70151fdfcfa502cd65bf84e040962023d450b - md5: bbe259e532ec22bcb09c966c389d7a0d +- conda: https://conda.anaconda.org/conda-forge/linux-64/pytorch-2.3.0-cuda120_py312h26b3cf7_301.conda + sha256: c45a2745b7de3c801815b3e58d1660ff3787d4a0da5982f2ea914dcb62e421cd + md5: 0606ae18769a5cc272d6ccf9d1b339c6 depends: + - __cuda - __glibc >=2.17,<3.0.a0 - _openmp_mutex >=4.5 + - cuda-cudart >=12.0.107,<13.0a0 + - cuda-nvrtc >=12.0.76,<13.0a0 + - cuda-nvtx >=12.0.76,<13.0a0 + - cuda-version >=12.0,<13 + - cudnn >=8.9.7.29,<9.0a0 - filelock - fsspec - jinja2 - libabseil * cxx17* - libabseil >=20240116.2,<20240117.0a0 - libcblas >=3.9.0,<4.0a0 + - libcublas >=12.0.1.189,<13.0a0 + - libcufft >=11.0.0.21,<12.0a0 + - libcurand >=10.3.1.50,<11.0a0 + - libcusolver >=11.4.2.57,<12.0a0 + - libcusparse >=12.0.0.76,<13.0a0 - libgcc-ng >=12 - - liblapack >=3.9.0,<4.0a0 + - libmagma >=2.7.2,<2.7.3.0a0 + - libmagma_sparse >=2.7.2,<2.7.3.0a0 - libprotobuf >=4.25.3,<4.25.4.0a0 - libstdcxx-ng >=12 - libtorch 2.3.0.* - libuv >=1.48.0,<2.0a0 + - mkl >=2023.2.0,<2024.0a0 + - nccl >=2.21.5.1,<3.0a0 - networkx - - nomkl - numpy >=1.19,<3 - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 @@ -14563,53 +14009,34 @@ packages: - sympy - typing_extensions constrains: - - pytorch-gpu ==99999999 - - pytorch-cpu ==2.3.0 + - pytorch-gpu ==2.3.0 + - pytorch-cpu ==99999999 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/torch?source=project-defined-mapping - size: 24269584 - timestamp: 1716588456984 -- kind: conda - name: pytorch - version: 2.3.0 - build: cuda120_py312h26b3cf7_301 - build_number: 301 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/pytorch-2.3.0-cuda120_py312h26b3cf7_301.conda - sha256: c45a2745b7de3c801815b3e58d1660ff3787d4a0da5982f2ea914dcb62e421cd - md5: 0606ae18769a5cc272d6ccf9d1b339c6 + size: 24505855 + timestamp: 1716610192371 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pytorch-2.3.1-cpu_generic_py312h2f1fc2b_0.conda + sha256: db6ed4ff85005f35fc04f957a969bf6fcc849c850247a736ce7f78aeb402406a + md5: 9fe5c6acaa17a9d4d9dc656fa20a832a depends: - - __cuda - __glibc >=2.17,<3.0.a0 - _openmp_mutex >=4.5 - - cuda-cudart >=12.0.107,<13.0a0 - - cuda-nvrtc >=12.0.76,<13.0a0 - - cuda-nvtx >=12.0.76,<13.0a0 - - cuda-version >=12.0,<13 - - cudnn >=8.9.7.29,<9.0a0 - filelock - fsspec - jinja2 - libabseil * cxx17* - libabseil >=20240116.2,<20240117.0a0 - libcblas >=3.9.0,<4.0a0 - - libcublas >=12.0.1.189,<13.0a0 - - libcufft >=11.0.0.21,<12.0a0 - - libcurand >=10.3.1.50,<11.0a0 - - libcusolver >=11.4.2.57,<12.0a0 - - libcusparse >=12.0.0.76,<13.0a0 - libgcc-ng >=12 - - libmagma >=2.7.2,<2.7.3.0a0 - - libmagma_sparse >=2.7.2,<2.7.3.0a0 + - liblapack >=3.9.0,<4.0a0 - libprotobuf >=4.25.3,<4.25.4.0a0 - libstdcxx-ng >=12 - - libtorch 2.3.0.* + - libtorch 2.3.1.* - libuv >=1.48.0,<2.0a0 - - mkl >=2023.2.0,<2024.0a0 - - nccl >=2.21.5.1,<3.0a0 - networkx + - nomkl - numpy >=1.19,<3 - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 @@ -14617,21 +14044,15 @@ packages: - sympy - typing_extensions constrains: - - pytorch-gpu ==2.3.0 - - pytorch-cpu ==99999999 + - pytorch-gpu ==99999999 + - pytorch-cpu ==2.3.1 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/torch?source=project-defined-mapping - size: 24505855 - timestamp: 1716610192371 -- kind: conda - name: pytorch - version: 2.3.1 - build: cpu_generic_py312h2aa0b4f_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/pytorch-2.3.1-cpu_generic_py312h2aa0b4f_1.conda + size: 24260223 + timestamp: 1718627067963 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pytorch-2.3.1-cpu_generic_py312h2aa0b4f_1.conda sha256: 7bd006c2b31f97b5a4a4b6579bbb70b1abb670dc00f750cbfb5620454df8d35b md5: b496bef0c76cef679572c2ea09497cb9 depends: @@ -14666,74 +14087,50 @@ packages: - pkg:pypi/torch?source=project-defined-mapping size: 23428922 timestamp: 1719369950286 -- kind: conda - name: pytz - version: '2024.1' - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/pytz-2024.1-pyhd8ed1ab_0.conda - sha256: 1a7d6b233f7e6e3bbcbad054c8fd51e690a67b129a899a056a5e45dd9f00cb41 - md5: 3eeeeb9e4827ace8c0c1419c85d590ad +- conda: https://conda.anaconda.org/conda-forge/noarch/pytz-2024.2-pyhd8ed1ab_1.conda + sha256: 0a7c706b2eb13f7da5692d9ddf1567209964875710b471de6f2743b33d1ba960 + md5: f26ec986456c30f6dff154b670ae140f depends: - - python >=3.7 + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/pytz?source=project-defined-mapping - size: 188538 - timestamp: 1706886944988 -- kind: conda - name: pyyaml - version: 6.0.2 - build: py312h024a12e_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/pyyaml-6.0.2-py312h024a12e_1.conda - sha256: b06f1c15fb39695bbf707ae8fb554b9a77519af577b5556784534c7db10b52e3 - md5: 1ee23620cf46cb15900f70a1300bae55 + size: 185890 + timestamp: 1733215766006 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pyyaml-6.0.2-py312h66e93f0_1.conda + sha256: a60705971e958724168f2ebbb8ed4853067f1d3f7059843df3903e3092bbcffa + md5: 549e5930e768548a89c23f595dac5a95 depends: - - __osx >=11.0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 - yaml >=0.2.5,<0.3.0a0 license: MIT license_family: MIT purls: - pkg:pypi/pyyaml?source=project-defined-mapping - size: 187143 - timestamp: 1725456547263 -- kind: conda - name: pyyaml - version: 6.0.2 - build: py312h66e93f0_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/pyyaml-6.0.2-py312h66e93f0_1.conda - sha256: a60705971e958724168f2ebbb8ed4853067f1d3f7059843df3903e3092bbcffa - md5: 549e5930e768548a89c23f595dac5a95 + size: 206553 + timestamp: 1725456256213 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyyaml-6.0.2-py312h024a12e_1.conda + sha256: b06f1c15fb39695bbf707ae8fb554b9a77519af577b5556784534c7db10b52e3 + md5: 1ee23620cf46cb15900f70a1300bae55 depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=13 + - __osx >=11.0 - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 - yaml >=0.2.5,<0.3.0a0 license: MIT license_family: MIT purls: - pkg:pypi/pyyaml?source=project-defined-mapping - size: 206553 - timestamp: 1725456256213 -- kind: conda - name: pyzmq - version: 26.2.0 - build: py312hbf22597_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/pyzmq-26.2.0-py312hbf22597_2.conda - sha256: a2431644cdef4111f7120565090114f52897e687e83c991bd76a3baef8de77c4 - md5: 44f46ddfdd01d242d2fff2d69a0d7cba + size: 187143 + timestamp: 1725456547263 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pyzmq-26.2.0-py312hbf22597_3.conda + sha256: bc303f9b11e04a515f79cd5ad3bfa0e84b9dfec76552626d6263b38789fe6678 + md5: 746ce19f0829ec3e19c93007b1a224d3 depends: - __glibc >=2.17,<3.0.a0 - libgcc >=13 @@ -14746,17 +14143,11 @@ packages: license_family: BSD purls: - pkg:pypi/pyzmq?source=project-defined-mapping - size: 378667 - timestamp: 1725449078945 -- kind: conda - name: pyzmq - version: 26.2.0 - build: py312hc6335d2_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/pyzmq-26.2.0-py312hc6335d2_2.conda - sha256: 8d46c0f1af50989f308b9da68e6123bc3560f3a3a741b4e7cb8867c603b5a9f1 - md5: ca61d76f24d66c2938af62e882c9a02d + size: 378126 + timestamp: 1728642454632 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyzmq-26.2.0-py312hf8a1cbd_3.conda + sha256: 2e0ca1bb9ab3af5d1f9b38548d65be7097ba0246e7e63c908c9b1323df3f45b5 + md5: 7bdaa4c2a84b744ef26c8b2ba65c3d0e depends: - __osx >=11.0 - libcxx >=17 @@ -14769,15 +14160,20 @@ packages: license_family: BSD purls: - pkg:pypi/pyzmq?source=project-defined-mapping - size: 359594 - timestamp: 1725449428595 -- kind: conda - name: qhull - version: '2020.2' - build: h420ef59_5 - build_number: 5 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/qhull-2020.2-h420ef59_5.conda + size: 361674 + timestamp: 1728642457661 +- conda: https://conda.anaconda.org/conda-forge/linux-64/qhull-2020.2-h434a139_5.conda + sha256: 776363493bad83308ba30bcb88c2552632581b143e8ee25b1982c8c743e73abc + md5: 353823361b1d27eb3960efb076dfcaf6 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + license: LicenseRef-Qhull + purls: [] + size: 552937 + timestamp: 1720813982144 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/qhull-2020.2-h420ef59_5.conda sha256: 873ac689484262a51fd79bc6103c1a1bedbf524924d7f0088fb80703042805e4 md5: 6483b1f59526e05d7d894e466b5b6924 depends: @@ -14787,32 +14183,63 @@ packages: purls: [] size: 516376 timestamp: 1720814307311 -- kind: conda - name: qhull - version: '2020.2' - build: h434a139_5 - build_number: 5 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/qhull-2020.2-h434a139_5.conda - sha256: 776363493bad83308ba30bcb88c2552632581b143e8ee25b1982c8c743e73abc - md5: 353823361b1d27eb3960efb076dfcaf6 +- conda: https://conda.anaconda.org/conda-forge/linux-64/qt6-main-6.7.2-h402ef58_0.conda + sha256: 56e44896400990043d35fa1487269334159ff82196e6a76a05f6e09a90d232bc + md5: 9395047d376de6d9393157763a0c4e7e depends: - __glibc >=2.17,<3.0.a0 + - alsa-lib >=1.2.12,<1.3.0a0 + - dbus >=1.13.6,<2.0a0 + - double-conversion >=3.3.0,<3.4.0a0 + - fontconfig >=2.14.2,<3.0a0 + - fonts-conda-ecosystem + - freetype >=2.12.1,<3.0a0 + - harfbuzz >=8.5.0,<9.0a0 + - icu >=73.2,<74.0a0 + - krb5 >=1.21.2,<1.22.0a0 + - libclang-cpp18.1 >=18.1.7,<18.2.0a0 + - libclang13 >=18.1.7 + - libcups >=2.3.3,<2.4.0a0 + - libdrm >=2.4.120,<2.5.0a0 - libgcc-ng >=12 + - libglib >=2.80.2,<3.0a0 + - libjpeg-turbo >=3.0.0,<4.0a0 + - libllvm18 >=18.1.7,<18.2.0a0 + - libpng >=1.6.43,<1.7.0a0 + - libpq >=16.3,<17.0a0 + - libsqlite >=3.46.0,<4.0a0 - libstdcxx-ng >=12 - license: LicenseRef-Qhull + - libtiff >=4.6.0,<4.8.0a0 + - libwebp-base >=1.4.0,<2.0a0 + - libxcb >=1.15,<1.16.0a0 + - libxkbcommon >=1.7.0,<2.0a0 + - libxml2 >=2.12.7,<3.0a0 + - libzlib >=1.3.1,<2.0a0 + - mysql-libs >=8.3.0,<8.4.0a0 + - openssl >=3.3.1,<4.0a0 + - pcre2 >=10.43,<10.44.0a0 + - wayland >=1.23.0,<2.0a0 + - xcb-util >=0.4.0,<0.5.0a0 + - xcb-util-cursor >=0.1.4,<0.2.0a0 + - xcb-util-image >=0.4.0,<0.5.0a0 + - xcb-util-keysyms >=0.4.0,<0.5.0a0 + - xcb-util-renderutil >=0.3.9,<0.4.0a0 + - xcb-util-wm >=0.4.1,<0.5.0a0 + - xorg-libice >=1.1.1,<2.0a0 + - xorg-libsm >=1.2.4,<2.0a0 + - xorg-libx11 >=1.8.9,<2.0a0 + - xorg-libxext >=1.3.4,<2.0a0 + - zstd >=1.5.6,<1.6.0a0 + constrains: + - qt 6.7.2 + license: LGPL-3.0-only + license_family: LGPL purls: [] - size: 552937 - timestamp: 1720813982144 -- kind: conda - name: qt6-main - version: 6.7.2 - build: hb12f9c5_5 - build_number: 5 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/qt6-main-6.7.2-hb12f9c5_5.conda - sha256: 712c5e6fef0b121bd62d941f8e11fff2ac5e1b36b7af570f4465f51e14193104 - md5: 8c662388c2418f293266f5e7f50df7d7 + size: 46717541 + timestamp: 1718730999684 +- conda: https://conda.anaconda.org/conda-forge/linux-64/qt6-main-6.7.3-h6e8976b_1.conda + sha256: f5e4cefa82edec73c9bfc99566391463aeb339cfae8446f9b3c7950fefec6555 + md5: f3234422a977b5d400ccf503ad55c5d1 depends: - __glibc >=2.17,<3.0.a0 - alsa-lib >=1.2.12,<1.3.0a0 @@ -14824,83 +14251,75 @@ packages: - harfbuzz >=9.0.0,<10.0a0 - icu >=75.1,<76.0a0 - krb5 >=1.21.3,<1.22.0a0 - - libclang-cpp18.1 >=18.1.8,<18.2.0a0 - - libclang13 >=18.1.8 + - libclang-cpp19.1 >=19.1.0,<19.2.0a0 + - libclang13 >=19.1.0 - libcups >=2.3.3,<2.4.0a0 - - libdrm >=2.4.122,<2.5.0a0 + - libdrm >=2.4.123,<2.5.0a0 - libegl >=1.7.0,<2.0a0 - - libgcc-ng >=12 + - libgcc >=13 - libgl >=1.7.0,<2.0a0 - - libglib >=2.80.3,<3.0a0 + - libglib >=2.82.1,<3.0a0 - libjpeg-turbo >=3.0.0,<4.0a0 - - libllvm18 >=18.1.8,<18.2.0a0 - - libpng >=1.6.43,<1.7.0a0 - - libpq >=16.4,<17.0a0 - - libsqlite >=3.46.0,<4.0a0 - - libstdcxx-ng >=12 - - libtiff >=4.6.0,<4.7.0a0 + - libllvm19 >=19.1.0,<19.2.0a0 + - libpng >=1.6.44,<1.7.0a0 + - libpq >=17.0,<18.0a0 + - libsqlite >=3.46.1,<4.0a0 + - libstdcxx >=13 + - libtiff >=4.7.0,<4.8.0a0 - libwebp-base >=1.4.0,<2.0a0 - - libxcb >=1.16,<1.17.0a0 + - libxcb >=1.17.0,<2.0a0 - libxkbcommon >=1.7.0,<2.0a0 - libxml2 >=2.12.7,<3.0a0 - libzlib >=1.3.1,<2.0a0 - mysql-libs >=9.0.1,<9.1.0a0 - - openssl >=3.3.1,<4.0a0 + - openssl >=3.3.2,<4.0a0 - pcre2 >=10.44,<10.45.0a0 - - wayland >=1.23.0,<2.0a0 + - wayland >=1.23.1,<2.0a0 - xcb-util >=0.4.1,<0.5.0a0 - - xcb-util-cursor >=0.1.4,<0.2.0a0 + - xcb-util-cursor >=0.1.5,<0.2.0a0 - xcb-util-image >=0.4.0,<0.5.0a0 - xcb-util-keysyms >=0.4.1,<0.5.0a0 - xcb-util-renderutil >=0.3.10,<0.4.0a0 - xcb-util-wm >=0.4.2,<0.5.0a0 - xorg-libice >=1.1.1,<2.0a0 - xorg-libsm >=1.2.4,<2.0a0 - - xorg-libx11 >=1.8.9,<2.0a0 - - xorg-libxext >=1.3.4,<2.0a0 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxcomposite >=0.4.6,<1.0a0 + - xorg-libxcursor >=1.2.2,<2.0a0 + - xorg-libxdamage >=1.1.6,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + - xorg-libxrandr >=1.5.4,<2.0a0 - xorg-libxtst >=1.2.5,<2.0a0 - xorg-libxxf86vm >=1.1.5,<2.0a0 - zstd >=1.5.6,<1.6.0a0 constrains: - - qt 6.7.2 + - qt 6.7.3 license: LGPL-3.0-only license_family: LGPL purls: [] - size: 46904534 - timestamp: 1724536870579 -- kind: conda - name: qtconsole-base - version: 5.6.0 - build: pyha770c72_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/qtconsole-base-5.6.0-pyha770c72_0.conda - sha256: 90acc0377a6a0d23d1c091ae3b25c30ca26d20fb88273ae54f3605f5e5225c10 - md5: 98495833b9b9bc9c3a2711d8cc252684 + size: 47378301 + timestamp: 1727940486113 +- conda: https://conda.anaconda.org/conda-forge/noarch/qtconsole-base-5.6.1-pyha770c72_1.conda + sha256: 4bc30bd908eadcb787231bbfb2d0a8a13d488f8ea1e2cf1655428a7fb705ae4c + md5: 90318750c409c282625318fdb4465b52 depends: - ipykernel >=4.1 - jupyter_client >=4.1 - jupyter_core - packaging - pygments - - python >=3.8 + - python >=3.9 - qtpy >=2.4.0 - traitlets license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/qtconsole?source=project-defined-mapping - size: 100847 - timestamp: 1724884249491 -- kind: conda - name: qtpy - version: 2.4.1 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/qtpy-2.4.1-pyhd8ed1ab_0.conda - sha256: 925bf48e747af6ceff1b073c10b12fc94ef79c88a34729059d253e43466a33f1 - md5: 7f391bd70d2abfb70f304ba5aa4e1261 + size: 101538 + timestamp: 1733730564548 +- conda: https://conda.anaconda.org/conda-forge/noarch/qtpy-2.4.2-pyhdecd6ff_0.conda + sha256: b1b148dfcdd9f343729f39e68851600b13c6e16c041d6cb13aaf37fb86033da3 + md5: 5060d07c9a66612192a3f6f0609fa36f depends: - packaging - python >=3.7 @@ -14908,15 +14327,29 @@ packages: license_family: MIT purls: - pkg:pypi/qtpy?source=project-defined-mapping - size: 61808 - timestamp: 1698112171285 -- kind: conda - name: re2 - version: 2023.09.01 - build: h4cba328_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/re2-2023.09.01-h4cba328_2.conda + size: 62425 + timestamp: 1730763884592 +- conda: https://conda.anaconda.org/conda-forge/linux-64/re2-2023.09.01-h7f4b329_2.conda + sha256: f0f520f57e6b58313e8c41abc7dfa48742a05f1681f05654558127b667c769a8 + md5: 8f70e36268dea8eb666ef14c29bd3cda + depends: + - libre2-11 2023.09.01 h5a48ba9_2 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 26617 + timestamp: 1708946796423 +- conda: https://conda.anaconda.org/conda-forge/linux-64/re2-2024.07.02-h77b4e00_1.conda + sha256: c1721cb80f7201652fc9801f49c214c88aee835d957f2376e301bd40a8415742 + md5: 01093ff37c1b5e6bf9f17c0116747d11 + depends: + - libre2-11 2024.07.02 hbbce691_1 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 26665 + timestamp: 1728778975855 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/re2-2023.09.01-h4cba328_2.conda sha256: 0e0d44414381c39a7e6f3da442cb41c637df0dcb383a07425f19c19ccffa0118 md5: 0342882197116478a42fa4ea35af79c1 depends: @@ -14926,29 +14359,17 @@ packages: purls: [] size: 26770 timestamp: 1708947220914 -- kind: conda - name: re2 - version: 2023.09.01 - build: h7f4b329_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/re2-2023.09.01-h7f4b329_2.conda - sha256: f0f520f57e6b58313e8c41abc7dfa48742a05f1681f05654558127b667c769a8 - md5: 8f70e36268dea8eb666ef14c29bd3cda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/re2-2024.07.02-hcd0e937_1.conda + sha256: eebddde6cb10b146507810b701ef6df122d5309cd5151a39d0828aa44dc53725 + md5: 19e29f2ccc9168eb0a39dc40c04c0e21 depends: - - libre2-11 2023.09.01 h5a48ba9_2 + - libre2-11 2024.07.02 h2348fd5_1 license: BSD-3-Clause license_family: BSD purls: [] - size: 26617 - timestamp: 1708946796423 -- kind: conda - name: readline - version: '8.2' - build: h8228510_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8228510_1.conda + size: 26860 + timestamp: 1728779123653 +- conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8228510_1.conda sha256: 5435cf39d039387fbdc977b0a762357ea909a7694d9528ab40f005e9208744d7 md5: 47d31b792659ce70f470b5c82fdfb7a4 depends: @@ -14959,13 +14380,7 @@ packages: purls: [] size: 281456 timestamp: 1679532220005 -- kind: conda - name: readline - version: '8.2' - build: h92ec313_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.2-h92ec313_1.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.2-h92ec313_1.conda sha256: a1dfa679ac3f6007362386576a704ad2d0d7a02e98f5d0b115f207a2da63e884 md5: 8cbb776a2f641b943d413b3e19df71f4 depends: @@ -14975,39 +14390,27 @@ packages: purls: [] size: 250351 timestamp: 1679532511311 -- kind: conda - name: referencing - version: 0.35.1 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/referencing-0.35.1-pyhd8ed1ab_0.conda - sha256: be8d6d9e86b1a3fef5424127ff81782f8ca63d3058980859609f6f1ecdd34cb3 - md5: 0fc8b52192a8898627c3efae1003e9f6 +- conda: https://conda.anaconda.org/conda-forge/noarch/referencing-0.35.1-pyhd8ed1ab_1.conda + sha256: f972eecb4dc8e06257af37642f92b0f2df04a7fe4c950f2e1045505e5e93985f + md5: 8c9083612c1bfe6878715ed5732605f8 depends: - attrs >=22.2.0 - - python >=3.8 + - python >=3.9 - rpds-py >=0.7.0 license: MIT license_family: MIT purls: - pkg:pypi/referencing?source=project-defined-mapping - size: 42210 - timestamp: 1714619625532 -- kind: conda - name: requests - version: 2.32.3 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.3-pyhd8ed1ab_0.conda - sha256: 5845ffe82a6fa4d437a2eae1e32a1ad308d7ad349f61e337c0a890fe04c513cc - md5: 5ede4753180c7a550a443c430dc8ab52 + size: 42201 + timestamp: 1733366868091 +- conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.3-pyhd8ed1ab_1.conda + sha256: d701ca1136197aa121bbbe0e8c18db6b5c94acbd041c2b43c70e5ae104e1d8ad + md5: a9b9368f3701a417eac9edbcae7cb737 depends: - certifi >=2017.4.17 - charset-normalizer >=2,<4 - idna >=2.5,<4 - - python >=3.8 + - python >=3.9 - urllib3 >=1.21.1,<3 constrains: - chardet >=3.0.2,<6 @@ -15015,89 +14418,79 @@ packages: license_family: APACHE purls: - pkg:pypi/requests?source=project-defined-mapping - size: 58810 - timestamp: 1717057174842 -- kind: conda - name: rerun-sdk - version: 0.17.0 - build: py312h5c2e7bc_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/rerun-sdk-0.17.0-py312h5c2e7bc_0.conda - sha256: eb2d76e75b040e61a842a1d4a9c3c654d91eb63dd1ff987f5fee81f48f97fb5b - md5: 5590357fe9020f0ee6d643090ee60fd7 + size: 58723 + timestamp: 1733217126197 +- conda: https://conda.anaconda.org/conda-forge/linux-64/rerun-sdk-0.17.0-py312hbe4c86d_0.conda + sha256: b94bfc7a6ee9ff2bd9560c177556f9aef3b910defa0abfaf4e305b9494bf4f5d + md5: 71b045c1ad3177620f508dcdf65ca52c depends: - - __osx >=11.0 + - __glibc >=2.17,<3.0.a0 - anywidget - attrs >=23.1.0 - jupyter-ui-poll - - libcxx >=16 + - libgcc-ng >=12 + - libstdcxx-ng >=12 - numpy >=1.23 - pillow - pyarrow >=14.0.2 - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 - typing_extensions >=4.5 constrains: - - __osx >=10.13 + - __glibc >=2.17 license: MIT OR Apache-2.0 purls: - pkg:pypi/rerun-sdk?source=project-defined-mapping - size: 24250058 - timestamp: 1720501514420 -- kind: conda - name: rerun-sdk - version: 0.17.0 - build: py312hbe4c86d_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/rerun-sdk-0.17.0-py312hbe4c86d_0.conda - sha256: b94bfc7a6ee9ff2bd9560c177556f9aef3b910defa0abfaf4e305b9494bf4f5d - md5: 71b045c1ad3177620f508dcdf65ca52c + size: 27083048 + timestamp: 1720501755148 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/rerun-sdk-0.17.0-py312h5c2e7bc_0.conda + sha256: eb2d76e75b040e61a842a1d4a9c3c654d91eb63dd1ff987f5fee81f48f97fb5b + md5: 5590357fe9020f0ee6d643090ee60fd7 depends: - - __glibc >=2.17,<3.0.a0 + - __osx >=11.0 - anywidget - attrs >=23.1.0 - jupyter-ui-poll - - libgcc-ng >=12 - - libstdcxx-ng >=12 + - libcxx >=16 - numpy >=1.23 - pillow - pyarrow >=14.0.2 - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 - typing_extensions >=4.5 constrains: - - __glibc >=2.17 + - __osx >=10.13 license: MIT OR Apache-2.0 purls: - pkg:pypi/rerun-sdk?source=project-defined-mapping - size: 27083048 - timestamp: 1720501755148 -- kind: conda - name: rfc3339-validator - version: 0.1.4 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/rfc3339-validator-0.1.4-pyhd8ed1ab_0.tar.bz2 - sha256: 7c7052b51de0b5c558f890bb11f8b5edbb9934a653d76be086b1182b9f54185d - md5: fed45fc5ea0813240707998abe49f520 + size: 24250058 + timestamp: 1720501514420 +- conda: https://conda.anaconda.org/conda-forge/noarch/retrying-1.3.3-pyhd8ed1ab_3.conda + sha256: e2cc03b3cbabc543c042579cd21fd99cf37d6d0c009f62eefc4e577704a5a154 + md5: 1f7482562f2082f1b2abf8a3e2a41b63 depends: - - python >=3.5 + - python >=3.6 + - six >=1.7.0 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/retrying?source=project-defined-mapping + size: 16012 + timestamp: 1721646406817 +- conda: https://conda.anaconda.org/conda-forge/noarch/rfc3339-validator-0.1.4-pyhd8ed1ab_1.conda + sha256: 2e4372f600490a6e0b3bac60717278448e323cab1c0fecd5f43f7c56535a99c5 + md5: 36de09a8d3e5d5e6f4ee63af49e59706 + depends: + - python >=3.9 - six license: MIT license_family: MIT purls: - pkg:pypi/rfc3339-validator?source=project-defined-mapping - size: 8064 - timestamp: 1638811838081 -- kind: conda - name: rfc3986-validator - version: 0.1.1 - build: pyh9f0ad1d_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/rfc3986-validator-0.1.1-pyh9f0ad1d_0.tar.bz2 + size: 10209 + timestamp: 1733600040800 +- conda: https://conda.anaconda.org/conda-forge/noarch/rfc3986-validator-0.1.1-pyh9f0ad1d_0.tar.bz2 sha256: 2a5b495a1de0f60f24d8a74578ebc23b24aa53279b1ad583755f223097c41c37 md5: 912a71cc01012ee38e6b90ddd561e36f depends: @@ -15108,15 +14501,9 @@ packages: - pkg:pypi/rfc3986-validator?source=project-defined-mapping size: 7818 timestamp: 1598024297745 -- kind: conda - name: rpds-py - version: 0.20.0 - build: py312h12e396e_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/rpds-py-0.20.0-py312h12e396e_1.conda - sha256: c1b876198b565af674e3cbc66d872791e09d6b10ca2c663b1cec40517f836509 - md5: 9ae193ac9c1ead5024d5a4ee0024e9a6 +- conda: https://conda.anaconda.org/conda-forge/linux-64/rpds-py-0.22.3-py312h12e396e_0.conda + sha256: e8662d21ca3c912ac8941725392b838a29458b106ef22d9489cdf0f8de145fad + md5: bfb49da0cc9098597d527def04d66f8b depends: - __glibc >=2.17,<3.0.a0 - libgcc >=13 @@ -15128,17 +14515,11 @@ packages: license_family: MIT purls: - pkg:pypi/rpds-py?source=project-defined-mapping - size: 334627 - timestamp: 1725327239912 -- kind: conda - name: rpds-py - version: 0.20.0 - build: py312he431725_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/rpds-py-0.20.0-py312he431725_1.conda - sha256: 2d9a484f01c15644d2ae22d7ccc3f77697f0b0cfb35f3caa03ae36dda9e7ad9d - md5: 50ee5ea6188046514d7ad107c6bbd4ef + size: 354410 + timestamp: 1733366814237 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/rpds-py-0.22.3-py312hcd83bfe_0.conda + sha256: 0a8b50bf22400004a706ba160d7cb31f82b8d8c328a59aec73a9e0d3372d1964 + md5: 2f7c4d01946fa2ce73d7ef3eeb041877 depends: - __osx >=11.0 - python >=3.12,<3.13.0a0 @@ -15150,83 +14531,77 @@ packages: license_family: MIT purls: - pkg:pypi/rpds-py?source=project-defined-mapping - size: 291984 - timestamp: 1725327553881 -- kind: conda - name: ruff - version: 0.6.4 - build: py312h42f095d_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/ruff-0.6.4-py312h42f095d_0.conda - sha256: ba67bdeb0bd04f99aabe0cc6ce2014058d44cdad0487cd14ae526414d47bb689 - md5: 8e0585cac6fa5db2b428e20f3d57034c + size: 318920 + timestamp: 1733367225496 +- conda: https://conda.anaconda.org/conda-forge/linux-64/ruff-0.8.3-py312h2156523_0.conda + sha256: b82016bd9bacb9ea14491760555c2c04f7df05b10e588008cbbc9051c516e85f + md5: 81b3ae5bcf1d0d3a1cef657f7905a15e depends: - - __osx >=11.0 - - libcxx >=17 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 constrains: - - __osx >=11.0 + - __glibc >=2.17 license: MIT license_family: MIT purls: - pkg:pypi/ruff?source=project-defined-mapping - size: 6006996 - timestamp: 1725618425532 -- kind: conda - name: ruff - version: 0.6.4 - build: py312hd18ad41_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/ruff-0.6.4-py312hd18ad41_0.conda - sha256: 64e89828218eb52ba71fee66d74fbc19817ca0f914cb6e9ad3c82423e9f6d40e - md5: bbb52fcabbc926d506bed70d70e44776 + size: 7935974 + timestamp: 1734066982690 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ruff-0.8.3-py312h5d18b81_0.conda + sha256: 531f511df85e20ba67e66e5b57bacb720cd20c16aaad5104b2da275aae44d9db + md5: 7c4e4e2a3ee597c7ac79bc08269aadb5 depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=13 - - libstdcxx >=13 + - __osx >=11.0 + - libcxx >=18 - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 + constrains: + - __osx >=11.0 license: MIT license_family: MIT purls: - pkg:pypi/ruff?source=project-defined-mapping - size: 6554879 - timestamp: 1725618160547 -- kind: conda - name: s2n - version: 1.5.1 - build: h3400bea_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/s2n-1.5.1-h3400bea_0.conda - sha256: 2717b0fa534aee9aca152ae980731f3d201542d12c19403563aaa07194021041 - md5: bf136eb7f8e15fcf8915c1a04b0aec6f + size: 6969927 + timestamp: 1734067388336 +- conda: https://conda.anaconda.org/conda-forge/linux-64/s2n-1.5.10-hb5b8611_0.conda + sha256: f6d451821fddc26b93f45e9313e1ea15e09e5ef049d4e137413a5225d2a5dfba + md5: 999f3673f2a011f59287f2969e3749e4 depends: - __glibc >=2.17,<3.0.a0 - - libgcc-ng >=12 - - openssl >=3.3.1,<4.0a0 + - libgcc >=13 + - openssl >=3.4.0,<4.0a0 license: Apache-2.0 license_family: Apache purls: [] - size: 356808 - timestamp: 1724194797671 -- kind: conda - name: scikit-learn - version: 1.5.1 - build: py312h1b546db_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/scikit-learn-1.5.1-py312h1b546db_0.conda - sha256: 84dbdad6be17824cc188cd9f80d13707bb6e75afb64444476269b06643526225 - md5: e9448f28dfa360ab849f89319fc145f4 + size: 355142 + timestamp: 1734415467047 +- conda: https://conda.anaconda.org/conda-forge/linux-64/s2n-1.5.5-h3931f03_0.conda + sha256: a6fa0afa836f8f26dea0abc180ca2549bb517932d9a88a121e707135d4bcb715 + md5: 334dba9982ab9f5d62033c61698a8683 depends: - - __osx >=11.0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - openssl >=3.3.2,<4.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 353081 + timestamp: 1728534228471 +- conda: https://conda.anaconda.org/conda-forge/linux-64/scikit-learn-1.5.2-py312h7a48858_1.conda + sha256: 3118b687c7cfb4484cc5c65591b611d834e3ea2424cb75e1e0b0980d0de72afc + md5: 6b5f4c68483bd0c22bca9094dafc606b + depends: + - __glibc >=2.17,<3.0.a0 + - _openmp_mutex >=4.5 - joblib >=1.2.0 - - libcxx >=16 - - llvm-openmp >=16.0.6 + - libgcc >=13 + - libstdcxx >=13 - numpy >=1.19,<3 - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 - scipy - threadpoolctl >=3.1.0 @@ -15234,24 +14609,19 @@ packages: license_family: BSD purls: - pkg:pypi/scikit-learn?source=project-defined-mapping - size: 9546176 - timestamp: 1719998598002 -- kind: conda - name: scikit-learn - version: 1.5.1 - build: py312h775a589_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/scikit-learn-1.5.1-py312h775a589_0.conda - sha256: cf9735937209d01febf1f912559e28dc3bb753906460e5b85dc24f0d57a78d96 - md5: bd8c79ccb9498336cbb174cf0151024a + size: 10393222 + timestamp: 1726083382159 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/scikit-learn-1.5.2-py312h387f99c_1.conda + sha256: 9a5b51f8699d233a87d67c200aceb5a4b1bd9a899596c2eb958fddc6c2ddb60b + md5: 7a6a47b8182f8c5bdabdc772f1357e01 depends: - - __glibc >=2.17,<3.0.a0 - - _openmp_mutex >=4.5 + - __osx >=11.0 - joblib >=1.2.0 - - libgcc-ng >=12 - - libstdcxx-ng >=12 + - libcxx >=17 + - llvm-openmp >=17.0.6 - numpy >=1.19,<3 - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 - scipy - threadpoolctl >=3.1.0 @@ -15259,229 +14629,160 @@ packages: license_family: BSD purls: - pkg:pypi/scikit-learn?source=project-defined-mapping - size: 10384469 - timestamp: 1719998679827 -- kind: conda - name: scipy - version: 1.14.0 - build: py312h14ffa8f_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/scipy-1.14.0-py312h14ffa8f_2.conda - sha256: becb2ec6dc6e0037f4bcc2f87970527201812cfde90ec8134e3e0b97bc761b85 - md5: b5a0e5c90405203a6c704f830fdb3c32 + size: 9581309 + timestamp: 1726083218204 +- conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.14.1-py312h62794b6_2.conda + sha256: 6e4916d610dc15f9b504517bd6c1f3dbbae019a3c7abf0aeb55f310c452a4474 + md5: 94688dd449f6c092e5f951780235aca1 depends: - - __osx >=11.0 + - __glibc >=2.17,<3.0.a0 - libblas >=3.9.0,<4.0a0 - libcblas >=3.9.0,<4.0a0 - - libcxx >=16 - - libgfortran 5.* - - libgfortran5 >=12.3.0 - - libgfortran5 >=13.2.0 + - libgcc >=13 + - libgfortran + - libgfortran5 >=13.3.0 - liblapack >=3.9.0,<4.0a0 - - numpy >=1.23.5,<2.3 + - libstdcxx >=13 + - numpy <2.3 - numpy >=1.19,<3 - numpy >=1.23.5 - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/scipy?source=project-defined-mapping - size: 15060217 - timestamp: 1723856264902 -- kind: conda - name: scipy - version: 1.14.1 - build: py312h7d485d2_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.14.1-py312h7d485d2_0.conda - sha256: 79903e307183e08b19c7ef607672fd304ed4968b2a7530904147aa79536e70d1 - md5: 7418a22e73008356d9aba99d93dfeeee + size: 17444442 + timestamp: 1733621582568 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/scipy-1.14.0-py312h14ffa8f_2.conda + sha256: becb2ec6dc6e0037f4bcc2f87970527201812cfde90ec8134e3e0b97bc761b85 + md5: b5a0e5c90405203a6c704f830fdb3c32 depends: - - __glibc >=2.17,<3.0.a0 + - __osx >=11.0 - libblas >=3.9.0,<4.0a0 - libcblas >=3.9.0,<4.0a0 - - libgcc-ng >=13 - - libgfortran-ng - - libgfortran5 >=13.3.0 + - libcxx >=16 + - libgfortran 5.* + - libgfortran5 >=12.3.0 + - libgfortran5 >=13.2.0 - liblapack >=3.9.0,<4.0a0 - - libstdcxx-ng >=13 - - numpy <2.3 + - numpy >=1.23.5,<2.3 - numpy >=1.19,<3 - numpy >=1.23.5 - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/scipy?source=project-defined-mapping - size: 17700161 - timestamp: 1724328333870 -- kind: conda - name: send2trash - version: 1.8.3 - build: pyh0d859eb_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/send2trash-1.8.3-pyh0d859eb_0.conda - sha256: c4401b071e86ddfa0ea4f34b85308db2516b6aeca50053535996864cfdee7b3f - md5: 778594b20097b5a948c59e50ae42482a + size: 15060217 + timestamp: 1723856264902 +- conda: https://conda.anaconda.org/conda-forge/noarch/send2trash-1.8.3-pyh0d859eb_1.conda + sha256: 00926652bbb8924e265caefdb1db100f86a479e8f1066efe395d5552dde54d02 + md5: 938c8de6b9de091997145b3bf25cdbf9 depends: - __linux - - python >=3.7 + - python >=3.9 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/send2trash?source=project-defined-mapping - size: 22868 - timestamp: 1712585140895 -- kind: conda - name: send2trash - version: 1.8.3 - build: pyh31c8845_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/send2trash-1.8.3-pyh31c8845_0.conda - sha256: f911307db932c92510da6c3c15b461aef935720776643a1fbf3683f61001068b - md5: c3cb67fc72fb38020fe7923dbbcf69b0 + size: 22736 + timestamp: 1733322148326 +- conda: https://conda.anaconda.org/conda-forge/noarch/send2trash-1.8.3-pyh31c8845_1.conda + sha256: 5282eb5b462502c38df8cb37cd1542c5bbe26af2453a18a0a0602d084ca39f53 + md5: e67b1b1fa7a79ff9e8e326d0caf55854 depends: - __osx - pyobjc-framework-cocoa - - python >=3.7 + - python >=3.9 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/send2trash?source=project-defined-mapping - size: 23165 - timestamp: 1712585504123 -- kind: conda - name: setuptools - version: 73.0.1 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/setuptools-73.0.1-pyhd8ed1ab_0.conda - sha256: c9f5e110e3fe5a7c4cd5b9da445c05a1fae000b43ab3a97cb6a501f4267515fc - md5: f0b618d7673d1b2464f600b34d912f6f + size: 23100 + timestamp: 1733322309409 +- conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-75.6.0-pyhff2d567_1.conda + sha256: abb12e1dd515b13660aacb5d0fd43835bc2186cab472df25b7716cd65e095111 + md5: fc80f7995e396cbaeabd23cf46c413dc depends: - - python >=3.8 + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/setuptools?source=project-defined-mapping - size: 1460460 - timestamp: 1725348602179 -- kind: conda - name: six - version: 1.16.0 - build: pyh6c4a22f_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/six-1.16.0-pyh6c4a22f_0.tar.bz2 - sha256: a85c38227b446f42c5b90d9b642f2c0567880c15d72492d8da074a59c8f91dd6 - md5: e5f25f8dbc060e9a8d912e432202afc2 + size: 774252 + timestamp: 1732632769210 +- conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhd8ed1ab_0.conda + sha256: 41db0180680cc67c3fa76544ffd48d6a5679d96f4b71d7498a759e94edc9a2db + md5: a451d576819089b0d672f18768be0f65 depends: - - python + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/six?source=project-defined-mapping - size: 14259 - timestamp: 1620240338595 -- kind: conda - name: sleef - version: 3.6.1 - build: h1b44611_3 - build_number: 3 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/sleef-3.6.1-h1b44611_3.conda - sha256: 06f1f324fc01481a85bcdf3e62e944101c60c31faa7920ebac6b8d153c2fef11 - md5: af4dbe128af0840dcaeb4d40eb27ab73 + size: 16385 + timestamp: 1733381032766 +- conda: https://conda.anaconda.org/conda-forge/linux-64/sleef-3.7-h1b44611_2.conda + sha256: 38ad951d30052522693d21b247105744c7c6fb7cefcf41edca36f0688322e76d + md5: 4792f3259c6fdc0b730563a85b211dc0 depends: - __glibc >=2.17,<3.0.a0 - _openmp_mutex >=4.5 - - libgcc-ng >=13 - - libstdcxx-ng >=13 + - libgcc >=13 + - libstdcxx >=13 license: BSL-1.0 purls: [] - size: 1914535 - timestamp: 1724609202130 -- kind: conda - name: sleef - version: 3.6.1 - build: h7783ee8_3 - build_number: 3 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/sleef-3.6.1-h7783ee8_3.conda - sha256: 82de3a7bbdba94d216bc19de5d6e004d8aff6c8f977a86688fccf8677d30219e - md5: c31578d67107457a879cfb25516bf896 + size: 1919287 + timestamp: 1731180933533 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/sleef-3.7-h8391f65_2.conda + sha256: 244a788a52c611c91c6b2dc73fdbb4a486261d9d321123d76500a99322bae26a + md5: 00ecdc12398192a5a3a4aaf3d5d10a7c depends: - __osx >=11.0 - - libcxx >=17 - - llvm-openmp >=17.0.6 + - libcxx >=18 + - llvm-openmp >=18.1.8 license: BSL-1.0 purls: [] - size: 568928 - timestamp: 1724609366064 -- kind: conda - name: snappy - version: 1.2.1 - build: ha2e4443_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/snappy-1.2.1-ha2e4443_0.conda - sha256: dc7c8e0e8c3e8702aae81c52d940bfaabe756953ee51b1f1757e891bab62cf7f - md5: 6b7dcc7349efd123d493d2dbe85a045f + size: 582928 + timestamp: 1731181097813 +- conda: https://conda.anaconda.org/conda-forge/linux-64/snappy-1.2.1-h8bd8927_1.conda + sha256: ec91e86eeb2c6bbf09d51351b851e945185d70661d2ada67204c9a6419d282d3 + md5: 3b3e64af585eadfb52bb90b553db5edf depends: - - libgcc-ng >=12 - - libstdcxx-ng >=12 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 license: BSD-3-Clause license_family: BSD purls: [] - size: 42465 - timestamp: 1720003704360 -- kind: conda - name: snappy - version: 1.2.1 - build: hd02b534_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/snappy-1.2.1-hd02b534_0.conda - sha256: cb7a9440241c6092e0f1c795fdca149c4767023e783eaf9cfebc501f906b4897 - md5: 69d0f9694f3294418ee935da3d5f7272 + size: 42739 + timestamp: 1733501881851 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/snappy-1.2.1-h98b9ce2_1.conda + sha256: 4242f95b215127a006eb664fe26ed5a82df87e90cbdbc7ce7ff4971f0720997f + md5: ded86dee325290da2967a3fea3800eb5 depends: - __osx >=11.0 - - libcxx >=16 + - libcxx >=18 license: BSD-3-Clause license_family: BSD purls: [] - size: 35708 - timestamp: 1720003794374 -- kind: conda - name: sniffio - version: 1.3.1 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/sniffio-1.3.1-pyhd8ed1ab_0.conda - sha256: bc12100b2d8836b93c55068b463190505b8064d0fc7d025e89f20ebf22fe6c2b - md5: 490730480d76cf9c8f8f2849719c6e2b + size: 35857 + timestamp: 1733502172664 +- conda: https://conda.anaconda.org/conda-forge/noarch/sniffio-1.3.1-pyhd8ed1ab_1.conda + sha256: c2248418c310bdd1719b186796ae50a8a77ce555228b6acd32768e2543a15012 + md5: bf7a226e58dfb8346c70df36065d86c9 depends: - - python >=3.7 + - python >=3.9 license: Apache-2.0 license_family: Apache purls: - pkg:pypi/sniffio?source=project-defined-mapping - size: 15064 - timestamp: 1708953086199 -- kind: conda - name: soupsieve - version: '2.5' - build: pyhd8ed1ab_1 - build_number: 1 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/soupsieve-2.5-pyhd8ed1ab_1.conda + size: 15019 + timestamp: 1733244175724 +- conda: https://conda.anaconda.org/conda-forge/noarch/soupsieve-2.5-pyhd8ed1ab_1.conda sha256: 54ae221033db8fbcd4998ccb07f3c3828b4d77e73b0c72b18c1d6a507059059c md5: 3f144b2c34f8cb5a9abd9ed23a39c561 depends: @@ -15492,33 +14793,40 @@ packages: - pkg:pypi/soupsieve?source=project-defined-mapping size: 36754 timestamp: 1693929424267 -- kind: conda - name: stack_data - version: 0.6.2 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/stack_data-0.6.2-pyhd8ed1ab_0.conda - sha256: a58433e75229bec39f3be50c02efbe9b7083e53a1f31d8ee247564f370191eec - md5: e7df0fdd404616638df5ece6e69ba7af +- conda: https://conda.anaconda.org/conda-forge/linux-64/sqlite-3.47.2-h9eae976_0.conda + sha256: 8bda8238ee98e318aad2c54ab3c85c533c830ecba72486c616b7c8546b9b51f7 + md5: 64a954de15d114281535a26fd4d1f294 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libsqlite 3.47.2 hee588c1_0 + - libzlib >=1.3.1,<2.0a0 + - ncurses >=6.5,<7.0a0 + - readline >=8.2,<9.0a0 + license: Unlicense + purls: [] + size: 884362 + timestamp: 1733761834904 +- conda: https://conda.anaconda.org/conda-forge/noarch/stack_data-0.6.3-pyhd8ed1ab_1.conda + sha256: 570da295d421661af487f1595045760526964f41471021056e993e73089e9c41 + md5: b1b505328da7a6b246787df4b5a49fbc depends: - asttokens - executing - pure_eval - - python >=3.5 + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/stack-data?source=project-defined-mapping - size: 26205 - timestamp: 1669632203115 -- kind: pypi + size: 26988 + timestamp: 1733569565672 +- pypi: https://files.pythonhosted.org/packages/96/00/2b325970b3060c7cecebab6d295afe763365822b1306a12eeab198f74323/starlette-0.41.3-py3-none-any.whl name: starlette - version: 0.38.4 - url: https://files.pythonhosted.org/packages/69/13/fa916b69d7c21f80a9c5bde0445cbbbdb9542a9d8df73ea3d588aae55c26/starlette-0.38.4-py3-none-any.whl - sha256: 526f53a77f0e43b85f583438aee1a940fd84f8fd610353e8b0c1a77ad8a87e76 + version: 0.41.3 + sha256: 44cedb2b7c77a9de33a8b74b2b90e9f50d11fcf25d8270ea525ad71a25374ff7 requires_dist: - - anyio<5,>=3.4.0 + - anyio>=3.4.0,<5 - typing-extensions>=3.10.0 ; python_full_version < '3.10' - httpx>=0.22.0 ; extra == 'full' - itsdangerous ; extra == 'full' @@ -15526,117 +14834,129 @@ packages: - python-multipart>=0.0.7 ; extra == 'full' - pyyaml ; extra == 'full' requires_python: '>=3.8' -- kind: conda - name: svt-av1 - version: 2.2.1 - build: h5888daf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/svt-av1-2.2.1-h5888daf_0.conda - sha256: a1c197ea17dac43ad6c223e42d78726b9f37f31f63d65e0c062e418cb98c7a8f - md5: 0d9c441855be3d8dfdb2e800fe755059 +- conda: https://conda.anaconda.org/conda-forge/linux-64/svt-av1-2.1.0-hac33072_0.conda + sha256: 7c2f1bb1e84c16aaa76f0d73acab7f6a6aec839c120229ac340e24b47a3db595 + md5: 2a08edb7cd75e56623f2712292a97325 + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 2624396 + timestamp: 1716038239983 +- conda: https://conda.anaconda.org/conda-forge/linux-64/svt-av1-2.3.0-h5888daf_0.conda + sha256: df30a9be29f1a8b5a2e314dd5b16ccfbcbd1cc6a4f659340e8bc2bd4de37bc6f + md5: 355898d24394b2af353eb96358db9fdd depends: - __glibc >=2.17,<3.0.a0 - - libgcc-ng >=13 - - libstdcxx-ng >=13 + - libgcc >=13 + - libstdcxx >=13 license: BSD-2-Clause license_family: BSD purls: [] - size: 2404332 - timestamp: 1724459503486 -- kind: conda - name: svt-av1 - version: 2.2.1 - build: ha39b806_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/svt-av1-2.2.1-ha39b806_0.conda - sha256: 4199d3344d4f305e2d9c5f2fd58d4ac744b08565ee0ea8c08944e3fc9129ad76 - md5: b2761a20146810d3c03380576ae5c4fb + size: 2746291 + timestamp: 1730246036363 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/svt-av1-2.3.0-hf24288c_0.conda + sha256: ab876ed8bdd20e22a868dcb8d03e9ce9bbba7762d7e652d49bfff6af768a5b8f + md5: 114c33e9eec335a379c9ee6c498bb807 depends: - __osx >=11.0 - libcxx >=17 license: BSD-2-Clause license_family: BSD purls: [] - size: 1326484 - timestamp: 1724459521607 -- kind: conda - name: sympy - version: 1.13.2 - build: pypyh2585a3b_103 - build_number: 103 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/sympy-1.13.2-pypyh2585a3b_103.conda - sha256: ef2e841c53aff71fcbf5922883543374040a9799d064d152516b30ff6694e022 - md5: 7327125b427c98b81564f164c4a75d4c + size: 1387330 + timestamp: 1730246134730 +- conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.13.3-pyh2585a3b_104.conda + sha256: 35b2620d109c8a01a301222b4f546690316b7ed61d5c0325ec4a317fa27ea8d7 + md5: 68085d736d2b2f54498832b65059875d depends: - __unix + - cpython - gmpy2 >=2.0.8 - mpmath >=0.19 - - python * *_cpython - python >=3.8 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/sympy?source=project-defined-mapping - size: 4568532 - timestamp: 1723500430872 -- kind: conda - name: sysroot_linux-64 - version: '2.17' - build: h4a8ded7_16 - build_number: 16 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.17-h4a8ded7_16.conda - sha256: b892b0b9c6dc8efe8b9b5442597d1ab8d65c0dc7e4e5a80f822cbdf0a639bd77 - md5: 223fe8a3ff6d5e78484a9d58eb34d055 + size: 4561387 + timestamp: 1728484644967 +- conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.17-h4a8ded7_18.conda + sha256: 23c7ab371c1b74d01a187e05aa7240e3f5654599e364a9adff7f0b02e26f471f + md5: 0ea96f90a10838f58412aa84fdd9df09 depends: - - _sysroot_linux-64_curr_repodata_hack 3.* - - kernel-headers_linux-64 3.10.0 h4a8ded7_16 + - kernel-headers_linux-64 3.10.0 he073ed8_18 - tzdata license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later AND MPL-2.0 license_family: GPL purls: [] - size: 15513240 - timestamp: 1720621429816 -- kind: conda - name: tbb - version: 2021.13.0 - build: h7b3277c_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/tbb-2021.13.0-h7b3277c_0.conda - sha256: 4a16118d5f71da9e8177921be996da87112a55fe53a700ab5dffe14ae2b6ecba - md5: a8a0feb11d51d4a0a2e56fbd53c628cf + size: 15500960 + timestamp: 1729794510631 +- conda: https://conda.anaconda.org/conda-forge/linux-64/tbb-2021.13.0-hceb3a55_1.conda + sha256: 65463732129899770d54b1fbf30e1bb82fdebda9d7553caf08d23db4590cd691 + md5: ba7726b8df7b9d34ea80e82b097a4893 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libhwloc >=2.11.2,<2.11.3.0a0 + - libstdcxx >=13 + license: Apache-2.0 + license_family: APACHE + purls: [] + size: 175954 + timestamp: 1732982638805 +- conda: https://conda.anaconda.org/conda-forge/linux-64/tbb-2022.0.0-hceb3a55_0.conda + sha256: 2f7931cad1682d8b6bdc90dbb51edf01f6f5c33fc00392c396d63e24437df1e8 + md5: 79f0161f3ca73804315ca980f65d9c60 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libhwloc >=2.11.2,<2.11.3.0a0 + - libstdcxx >=13 + license: Apache-2.0 + license_family: APACHE + purls: [] + size: 178584 + timestamp: 1730477634943 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/tbb-2022.0.0-h0cbf7ec_0.conda + sha256: f436517a16494c93e2d779b9cdb91e8f4a9b48cef67fe20a4e75e494c8631dff + md5: 44ba5ad9819821b9b176ba2bb937a79c depends: - __osx >=11.0 - libcxx >=17 - - libhwloc >=2.11.1,<2.11.2.0a0 + - libhwloc >=2.11.2,<2.11.3.0a0 license: Apache-2.0 + license_family: APACHE purls: [] - size: 115213 - timestamp: 1725532720037 -- kind: conda - name: tbb - version: 2021.13.0 - build: h84d6215_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/tbb-2021.13.0-h84d6215_0.conda - sha256: 7d4d3ad608dc6ae5a7e0f431f784985398a18bcde2ba3ce19cc32f61e2defd98 - md5: ee6f7fd1e76061ef1fa307d41fa86a96 + size: 117825 + timestamp: 1730477755617 +- conda: https://conda.anaconda.org/conda-forge/linux-64/tbb-devel-2021.13.0-h1f99690_1.conda + sha256: a4f4d9c17057e047406f855a31093183cb4e30bda221506e024cf826e29f9399 + md5: 0200638907d55c2aadc1ca9d39566316 depends: - __glibc >=2.17,<3.0.a0 - libgcc >=13 - - libhwloc >=2.11.1,<2.11.2.0a0 - libstdcxx >=13 - license: Apache-2.0 + - tbb 2021.13.0 hceb3a55_1 purls: [] - size: 175779 - timestamp: 1725532539822 -- kind: pypi + size: 1053549 + timestamp: 1732982652385 +- conda: https://conda.anaconda.org/conda-forge/noarch/tenacity-9.0.0-pyhd8ed1ab_1.conda + sha256: dcf2155fb959773fb102066bfab8e7d79aff67054d142716979274a43fc85735 + md5: a09f66fe95a54a92172e56a4a97ba271 + depends: + - python >=3.9 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/tenacity?source=project-defined-mapping + size: 24808 + timestamp: 1733649153624 +- pypi: https://files.pythonhosted.org/packages/1e/90/4e8c686f2e691f48e40e16a539c61a6e9880743733d8c4dc3f275d12268e/tensorflow_probability-0.23.0-py2.py3-none-any.whl name: tensorflow-probability version: 0.23.0 - url: https://files.pythonhosted.org/packages/1e/90/4e8c686f2e691f48e40e16a539c61a6e9880743733d8c4dc3f275d12268e/tensorflow_probability-0.23.0-py2.py3-none-any.whl sha256: dda5cacfe50cb19ecd96f3ce81e6ff8680d84213bcfe94ca0aaf6e5f51c88061 requires_dist: - absl-py @@ -15650,30 +14970,18 @@ packages: - jaxlib ; extra == 'jax' - tensorflow-datasets>=2.2.0 ; extra == 'tfds' requires_python: '>=3.9' -- kind: conda - name: termcolor - version: 2.4.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/termcolor-2.4.0-pyhd8ed1ab_0.conda - sha256: 59588d41f2c02d599fd6528583013d85bd47d17b1acec11edbb29deadd81fbca - md5: a5033708ad9283907c3b1bc1f90d0d0d +- conda: https://conda.anaconda.org/conda-forge/noarch/termcolor-2.5.0-pyhd8ed1ab_1.conda + sha256: 4a7e13776ebd78afcdba3985ea42317e4e0a20722d2c27ecaae3d9f8849e6516 + md5: 1ce02d60767af357e864ce61895268d2 depends: - - python >=3.8 + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/termcolor?source=project-defined-mapping - size: 12721 - timestamp: 1704358124294 -- kind: conda - name: terminado - version: 0.18.1 - build: pyh0d859eb_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/terminado-0.18.1-pyh0d859eb_0.conda + size: 12665 + timestamp: 1733754731291 +- conda: https://conda.anaconda.org/conda-forge/noarch/terminado-0.18.1-pyh0d859eb_0.conda sha256: b300557c0382478cf661ddb520263508e4b3b5871b471410450ef2846e8c352c md5: efba281bbdae5f6b0a1d53c6d4a97c93 depends: @@ -15687,13 +14995,7 @@ packages: - pkg:pypi/terminado?source=project-defined-mapping size: 22452 timestamp: 1710262728753 -- kind: conda - name: terminado - version: 0.18.1 - build: pyh31c8845_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/terminado-0.18.1-pyh31c8845_0.conda +- conda: https://conda.anaconda.org/conda-forge/noarch/terminado-0.18.1-pyh31c8845_0.conda sha256: 4daae56fc8da17784578fbdd064f17e3b3076b394730a14119e571707568dc8a md5: 00b54981b923f5aefcd5e8547de056d5 depends: @@ -15707,13 +15009,7 @@ packages: - pkg:pypi/terminado?source=project-defined-mapping size: 22717 timestamp: 1710265922593 -- kind: conda - name: threadpoolctl - version: 3.5.0 - build: pyhc1e730c_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/threadpoolctl-3.5.0-pyhc1e730c_0.conda +- conda: https://conda.anaconda.org/conda-forge/noarch/threadpoolctl-3.5.0-pyhc1e730c_0.conda sha256: 45e402941f6bed094022c5726a2ca494e6224b85180d2367fb6ddd9aea68079d md5: df68d78237980a159bd7149f33c0e8fd depends: @@ -15724,15 +15020,9 @@ packages: - pkg:pypi/threadpoolctl?source=project-defined-mapping size: 23548 timestamp: 1714400228771 -- kind: conda - name: tinycss2 - version: 1.3.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/tinycss2-1.3.0-pyhd8ed1ab_0.conda - sha256: bc55e5899e66805589c02061e315bfc23ae6cc2f2811f5cc13fb189a5ed9d90f - md5: 8662629d9a05f9cff364e31ca106c1ac +- conda: https://conda.anaconda.org/conda-forge/noarch/tinycss2-1.4.0-pyhd8ed1ab_0.conda + sha256: cad582d6f978276522f84bd209a5ddac824742fe2d452af6acf900f8650a73a2 + md5: f1acf5fdefa8300de697982bcb1761c9 depends: - python >=3.5 - webencodings >=0.4 @@ -15740,31 +15030,20 @@ packages: license_family: BSD purls: - pkg:pypi/tinycss2?source=project-defined-mapping - size: 25405 - timestamp: 1713975078735 -- kind: conda - name: tk - version: 8.6.13 - build: h5083fa2_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h5083fa2_1.conda - sha256: 72457ad031b4c048e5891f3f6cb27a53cb479db68a52d965f796910e71a403a8 - md5: b50a57ba89c32b62428b71a875291c9b + size: 28285 + timestamp: 1729802975370 +- conda: https://conda.anaconda.org/conda-forge/linux-64/tinyobjloader-1.0.7-h59595ed_2.conda + sha256: 72628067e594f1431968143aed6a5d4e6f0f5d6d1aac0c5165b04143b4f03119 + md5: 3d75225b64bcbdc86128e693104a409d depends: - - libzlib >=1.2.13,<2.0.0a0 - license: TCL - license_family: BSD + - libgcc-ng >=12 + - libstdcxx-ng >=12 + license: MIT + license_family: MIT purls: [] - size: 3145523 - timestamp: 1699202432999 -- kind: conda - name: tk - version: 8.6.13 - build: noxft_h4845f30_101 - build_number: 101 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h4845f30_101.conda + size: 71746 + timestamp: 1704450371417 +- conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h4845f30_101.conda sha256: e0569c9caa68bf476bead1bed3d79650bb080b532c64a4af7d8ca286c08dea4e md5: d453b98d9c83e71da0741bb0ff4d76bc depends: @@ -15775,46 +15054,39 @@ packages: purls: [] size: 3318875 timestamp: 1699202167581 -- kind: conda - name: tomli - version: 2.0.1 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 - sha256: 4cd48aba7cd026d17e86886af48d0d2ebc67ed36f87f6534f4b67138f5a5a58f - md5: 5844808ffab9ebdb694585b50ba02a96 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h5083fa2_1.conda + sha256: 72457ad031b4c048e5891f3f6cb27a53cb479db68a52d965f796910e71a403a8 + md5: b50a57ba89c32b62428b71a875291c9b depends: - - python >=3.7 + - libzlib >=1.2.13,<2.0.0a0 + license: TCL + license_family: BSD + purls: [] + size: 3145523 + timestamp: 1699202432999 +- conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.2.1-pyhd8ed1ab_1.conda + sha256: 18636339a79656962723077df9a56c0ac7b8a864329eb8f847ee3d38495b863e + md5: ac944244f1fed2eb49bae07193ae8215 + depends: + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/tomli?source=project-defined-mapping - size: 15940 - timestamp: 1644342331069 -- kind: conda - name: toolz - version: 0.12.1 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/toolz-0.12.1-pyhd8ed1ab_0.conda - sha256: 22b0a9790317526e08609d5dfdd828210ae89e6d444a9e954855fc29012e90c6 - md5: 2fcb582444635e2c402e8569bb94e039 + size: 19167 + timestamp: 1733256819729 +- conda: https://conda.anaconda.org/conda-forge/noarch/toolz-1.0.0-pyhd8ed1ab_1.conda + sha256: eda38f423c33c2eaeca49ed946a8d3bf466cc3364970e083a65eb2fd85258d87 + md5: 40d0ed782a8aaa16ef248e68c06c168d depends: - - python >=3.7 + - python >=3.9 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/toolz?source=project-defined-mapping - size: 52358 - timestamp: 1706112720607 -- kind: conda - name: torchvision - version: 0.18.0 - build: cpu_py312h83765ac_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/torchvision-0.18.0-cpu_py312h83765ac_0.conda + size: 52475 + timestamp: 1733736126261 +- conda: https://conda.anaconda.org/conda-forge/linux-64/torchvision-0.18.0-cpu_py312h83765ac_0.conda sha256: 6273eb9ec798831a86d7a089f07d67925aae9d39a89b77b7618599a2a7c21af2 md5: b9691b63fbcc560f77537f0af868d489 depends: @@ -15837,40 +15109,7 @@ packages: - pkg:pypi/torchvision?source=project-defined-mapping size: 6864739 timestamp: 1715847927859 -- kind: conda - name: torchvision - version: 0.18.0 - build: cpu_py312ha63f1fc_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/torchvision-0.18.0-cpu_py312ha63f1fc_0.conda - sha256: 35ba200d11d3a2c51ccc862b60a97af4b907dd47f8a8c3d5b6599bd63c18f408 - md5: 87f328a2aff02ce5082b7b884adc3e41 - depends: - - __osx >=11.0 - - libcxx >=16 - - libjpeg-turbo >=3.0.0,<4.0a0 - - libpng >=1.6.43,<1.7.0a0 - - libtorch >=2.3.0,<2.4.0a0 - - numpy >=1.26.4,<2.0a0 - - pillow >=5.3.0,!=8.3.0,!=8.3.1 - - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - - python_abi 3.12.* *_cp312 - - pytorch 2.3.* cpu* - - pytorch >=2.3.0,<2.4.0a0 - - requests - license: BSD-3-Clause - license_family: BSD - purls: - - pkg:pypi/torchvision?source=project-defined-mapping - size: 6782575 - timestamp: 1715848703077 -- kind: conda - name: torchvision - version: 0.18.0 - build: cuda120py312h85ee0b7_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/torchvision-0.18.0-cuda120py312h85ee0b7_0.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/torchvision-0.18.0-cuda120py312h85ee0b7_0.conda sha256: 4ca0338111c5e77f73a6dad35cc2c6c865794a37e245549c0568ed25155ec171 md5: cf73a802136eb79685573e591a7935b5 depends: @@ -15898,87 +15137,80 @@ packages: - pkg:pypi/torchvision?source=project-defined-mapping size: 8175226 timestamp: 1715848786466 -- kind: conda - name: tornado - version: 6.4.1 - build: py312h024a12e_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/tornado-6.4.1-py312h024a12e_1.conda - sha256: 5eefede1d8a2f55892bc582dbcb574b1806f19bc1e3939ce56b79721b9406db7 - md5: 967bc97bb9e258993289546479af971f +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/torchvision-0.18.0-cpu_py312ha63f1fc_0.conda + sha256: 35ba200d11d3a2c51ccc862b60a97af4b907dd47f8a8c3d5b6599bd63c18f408 + md5: 87f328a2aff02ce5082b7b884adc3e41 depends: - __osx >=11.0 + - libcxx >=16 + - libjpeg-turbo >=3.0.0,<4.0a0 + - libpng >=1.6.43,<1.7.0a0 + - libtorch >=2.3.0,<2.4.0a0 + - numpy >=1.26.4,<2.0a0 + - pillow >=5.3.0,!=8.3.0,!=8.3.1 - python >=3.12,<3.13.0a0 - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 + - pytorch 2.3.* cpu* + - pytorch >=2.3.0,<2.4.0a0 + - requests + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/torchvision?source=project-defined-mapping + size: 6782575 + timestamp: 1715848703077 +- conda: https://conda.anaconda.org/conda-forge/linux-64/tornado-6.4.2-py312h66e93f0_0.conda + sha256: 062a3a3a37fa8615ce57929ba7e982c76f5a5810bcebd435950f6d6c4147c310 + md5: e417822cb989e80a0d2b1b576fdd1657 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 license: Apache-2.0 license_family: Apache purls: - pkg:pypi/tornado?source=project-defined-mapping - size: 841722 - timestamp: 1724956439106 -- kind: conda - name: tornado - version: 6.4.1 - build: py312h66e93f0_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/tornado-6.4.1-py312h66e93f0_1.conda - sha256: c0c9cc7834e8f43702956afaa5af7b0639c4835c285108a43e6b91687ce53ab8 - md5: af648b62462794649066366af4ecd5b0 + size: 840414 + timestamp: 1732616043734 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/tornado-6.4.2-py312hea69d52_0.conda + sha256: 964a2705a36c50040c967b18b45b9cc8de3c2aff4af546979a574e0b38e58e39 + md5: fb0605888a475d6a380ae1d1a819d976 depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=13 + - __osx >=11.0 - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 license: Apache-2.0 license_family: Apache purls: - pkg:pypi/tornado?source=project-defined-mapping - size: 837665 - timestamp: 1724956252424 -- kind: conda - name: tqdm - version: 4.66.5 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/tqdm-4.66.5-pyhd8ed1ab_0.conda - sha256: f2384902cef72048b0e9bad5c03d7a843de02ba6bc8618a9ecab6ff81a131312 - md5: c6e94fc2b2ec71ea33fe7c7da259acb4 + size: 842549 + timestamp: 1732616081362 +- conda: https://conda.anaconda.org/conda-forge/noarch/tqdm-4.67.1-pyhd8ed1ab_0.conda + sha256: 5673b7104350a6998cb86cccf1d0058217d86950e8d6c927d8530606028edb1d + md5: 4085c9db273a148e149c03627350e22c depends: - colorama - python >=3.7 license: MPL-2.0 or MIT purls: - pkg:pypi/tqdm?source=project-defined-mapping - size: 89519 - timestamp: 1722737568509 -- kind: conda - name: traitlets - version: 5.14.3 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.14.3-pyhd8ed1ab_0.conda - sha256: 8a64fa0f19022828513667c2c7176cfd125001f3f4b9bc00d33732e627dd2592 - md5: 3df84416a021220d8b5700c613af2dc5 + size: 89484 + timestamp: 1732497312317 +- conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.14.3-pyhd8ed1ab_1.conda + sha256: f39a5620c6e8e9e98357507262a7869de2ae8cc07da8b7f84e517c9fd6c2b959 + md5: 019a7385be9af33791c989871317e1ed depends: - - python >=3.8 + - python >=3.9 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/traitlets?source=project-defined-mapping - size: 110187 - timestamp: 1713535244513 -- kind: conda - name: trimesh - version: 4.2.4 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/trimesh-4.2.4-pyhd8ed1ab_0.conda + size: 110051 + timestamp: 1733367480074 +- conda: https://conda.anaconda.org/conda-forge/noarch/trimesh-4.2.4-pyhd8ed1ab_0.conda sha256: 4124f4536e09b4ca7cc89858ab814e79ecf848b8bb7baee8e1de09c074514d74 md5: 5d6794698cf7953d5275f46984e39313 depends: @@ -16012,175 +15244,224 @@ packages: - pkg:pypi/trimesh?source=project-defined-mapping size: 559157 timestamp: 1711932340288 -- kind: pypi - name: typeguard - version: 2.13.3 - url: https://files.pythonhosted.org/packages/9a/bb/d43e5c75054e53efce310e79d63df0ac3f25e34c926be5dffb7d283fb2a8/typeguard-2.13.3-py3-none-any.whl - sha256: 5e3e3be01e887e7eafae5af63d1f36c849aaa94e3a0112097312aabfa16284f1 - requires_dist: - - sphinx-rtd-theme ; extra == 'doc' - - sphinx-autodoc-typehints>=1.2.0 ; extra == 'doc' - - pytest ; extra == 'test' - - typing-extensions ; extra == 'test' - - mypy ; platform_python_implementation != 'PyPy' and extra == 'test' - requires_python: '>=3.5.3' -- kind: conda - name: types-python-dateutil - version: 2.9.0.20240906 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/types-python-dateutil-2.9.0.20240906-pyhd8ed1ab_0.conda - sha256: 737fecb4b6f85a6a85f3fff6cdf5e90c5922b468e036b98f6c1559780cb79664 - md5: 07c483202a209cd23594b62b3451045e +- conda: https://conda.anaconda.org/conda-forge/noarch/types-python-dateutil-2.9.0.20241206-pyhd8ed1ab_0.conda + sha256: 8b98cd9464837174ab58aaa912fc95d5831879864676650a383994033533b8d1 + md5: 1dbc4a115e2ad9fb7f9d5b68397f66f9 depends: - - python >=3.6 + - python >=3.9 license: Apache-2.0 AND MIT purls: - pkg:pypi/types-python-dateutil?source=project-defined-mapping - size: 21789 - timestamp: 1725623878468 -- kind: pypi + size: 22104 + timestamp: 1733612458611 +- pypi: https://files.pythonhosted.org/packages/f2/5d/865e17349564eb1772688d8afc5e3081a5964c640d64d1d2880ebaed002d/typing-3.10.0.0-py3-none-any.whl name: typing - version: 3.7.4.3 - url: https://files.pythonhosted.org/packages/05/d9/6eebe19d46bd05360c9a9aae822e67a80f9242aabbfc58b641b957546607/typing-3.7.4.3.tar.gz - sha256: 1187fb9c82fd670d10aa07bbb6cfcfe4bdda42d6fab8d5134f04e8c4d0b71cc9 - requires_python: '>=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*' -- kind: conda - name: typing-extensions - version: 4.12.2 - build: hd8ed1ab_0 - subdir: noarch + version: 3.10.0.0 + sha256: 12fbdfbe7d6cca1a42e485229afcb0b0c8259258cfb919b8a5e2a5c953742f89 + requires_python: '>=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,<3.5' +- conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_1.conda noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda - sha256: d3b9a8ed6da7c9f9553c5fd8a4fca9c3e0ab712fa5f497859f82337d67533b73 - md5: 52d648bd608f5737b123f510bb5514b5 + sha256: c8e9c1c467b5f960b627d7adc1c65fece8e929a3de89967e91ef0f726422fd32 + md5: b6a408c64b78ec7b779a3e5c7a902433 depends: - - typing_extensions 4.12.2 pyha770c72_0 + - typing_extensions 4.12.2 pyha770c72_1 license: PSF-2.0 license_family: PSF purls: [] - size: 10097 - timestamp: 1717802659025 -- kind: conda - name: typing_extensions - version: 4.12.2 - build: pyha770c72_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda - sha256: 0fce54f8ec3e59f5ef3bb7641863be4e1bf1279623e5af3d3fa726e8f7628ddb - md5: ebe6952715e1d5eb567eeebf25250fa7 + size: 10075 + timestamp: 1733188758872 +- conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_1.conda + sha256: 337be7af5af8b2817f115b3b68870208b30c31d3439bec07bfb2d8f4823e3568 + md5: d17f13df8b65464ca316cbc000a3cb64 depends: - - python >=3.8 + - python >=3.9 license: PSF-2.0 license_family: PSF purls: - pkg:pypi/typing-extensions?source=project-defined-mapping - size: 39888 - timestamp: 1717802653893 -- kind: conda - name: typing_utils - version: 0.1.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/typing_utils-0.1.0-pyhd8ed1ab_0.tar.bz2 - sha256: 9e3758b620397f56fb709f796969de436d63b7117897159619b87938e1f78739 - md5: eb67e3cace64c66233e2d35949e20f92 + size: 39637 + timestamp: 1733188758212 +- conda: https://conda.anaconda.org/conda-forge/noarch/typing_utils-0.1.0-pyhd8ed1ab_1.conda + sha256: 3088d5d873411a56bf988eee774559335749aed6f6c28e07bf933256afb9eb6c + md5: f6d7aa696c67756a650e91e15e88223c depends: - - python >=3.6.1 + - python >=3.9 license: Apache-2.0 license_family: APACHE purls: - pkg:pypi/typing-utils?source=project-defined-mapping - size: 13829 - timestamp: 1622899345711 -- kind: pypi + size: 15183 + timestamp: 1733331395943 +- pypi: https://files.pythonhosted.org/packages/a6/ab/7e5f53c3b9d14972843a647d8d7a853969a58aecc7559cb3267302c94774/tzdata-2024.2-py2.py3-none-any.whl name: tzdata - version: '2024.1' - url: https://files.pythonhosted.org/packages/65/58/f9c9e6be752e9fcb8b6a0ee9fb87e6e7a1f6bcab2cdc73f02bb7ba91ada0/tzdata-2024.1-py2.py3-none-any.whl - sha256: 9068bc196136463f5245e51efda838afa15aaeca9903f49050dfa2679db4d252 + version: '2024.2' + sha256: a48093786cdcde33cad18c2555e8532f34422074448fbc874186f0abd79565cd requires_python: '>=2' -- kind: conda - name: tzdata - version: 2024a - build: h8827d51_1 - build_number: 1 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h8827d51_1.conda - sha256: 7d21c95f61319dba9209ca17d1935e6128af4235a67ee4e57a00908a1450081e - md5: 8bfdead4e0fff0383ae4c9c50d0531bd +- conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024b-hc8b5060_0.conda + sha256: 4fde5c3008bf5d2db82f2b50204464314cc3c91c1d953652f7bd01d9e52aefdf + md5: 8ac3367aafb1cc0a068483c580af8015 license: LicenseRef-Public-Domain purls: [] - size: 124164 - timestamp: 1724736371498 -- kind: conda - name: uri-template - version: 1.3.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/uri-template-1.3.0-pyhd8ed1ab_0.conda - sha256: b76904b53721dc88a46352324c79d2b077c2f74a9f7208ad2c4249892669ae94 - md5: 0944dc65cb4a9b5b68522c3bb585d41c + size: 122354 + timestamp: 1728047496079 +- conda: https://conda.anaconda.org/conda-forge/linux-64/unicodedata2-15.1.0-py312h66e93f0_1.conda + sha256: 1fcba6d363d901d9a06381e1aee2d5634f82389965dd7a339f19b3ae81ce6da0 + md5: 588486a61153f94c7c13816f7069e440 depends: - - python >=3.7 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/unicodedata2?source=project-defined-mapping + size: 368550 + timestamp: 1729704685856 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/unicodedata2-15.1.0-py312h0bf5046_1.conda + sha256: 236961004c088f190d8b27863b2898f1d43c2d5dc769f135abdacc644b033fab + md5: eda2082df9c9c6259af246424b7f3db1 + depends: + - __osx >=11.0 + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/unicodedata2?source=project-defined-mapping + size: 372492 + timestamp: 1729704995151 +- conda: https://conda.anaconda.org/conda-forge/noarch/uri-template-1.3.0-pyhd8ed1ab_1.conda + sha256: e0eb6c8daf892b3056f08416a96d68b0a358b7c46b99c8a50481b22631a4dfc0 + md5: e7cb0f5745e4c5035a460248334af7eb + depends: + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/uri-template?source=project-defined-mapping - size: 23999 - timestamp: 1688655976471 -- kind: conda - name: urllib3 - version: 2.2.2 - build: pyhd8ed1ab_1 - build_number: 1 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.2.2-pyhd8ed1ab_1.conda - sha256: 00c47c602c03137e7396f904eccede8cc64cc6bad63ce1fc355125df8882a748 - md5: e804c43f58255e977093a2298e442bb8 + size: 23990 + timestamp: 1733323714454 +- conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.2.3-pyhd8ed1ab_1.conda + sha256: 416e30a1c3262275f01a3e22e783118d9e9d2872a739a9ed860d06fa9c7593d5 + md5: 4a2d8ef7c37b8808c5b9b750501fffce depends: - brotli-python >=1.0.9 - h2 >=4,<5 - pysocks >=1.5.6,<2.0,!=1.5.7 - - python >=3.8 + - python >=3.9 - zstandard >=0.18.0 license: MIT license_family: MIT purls: - pkg:pypi/urllib3?source=project-defined-mapping - size: 95048 - timestamp: 1719391384778 -- kind: pypi + size: 98077 + timestamp: 1733206968917 +- conda: https://conda.anaconda.org/conda-forge/linux-64/utfcpp-4.0.6-h005c6e1_0.conda + sha256: ec540ff477cd6d209b98f9b201e9c440908ea3a8b62e9e02dd12fcb60fff6d08 + md5: 9464e297fa2bf08030c65a54342b48c3 + license: BSL-1.0 + purls: [] + size: 13447 + timestamp: 1730672182037 +- pypi: https://files.pythonhosted.org/packages/61/14/33a3a1352cfa71812a3a21e8c9bfb83f60b0011f5e36f2b1399d51928209/uvicorn-0.34.0-py3-none-any.whl name: uvicorn - version: 0.30.6 - url: https://files.pythonhosted.org/packages/f5/8e/cdc7d6263db313030e4c257dd5ba3909ebc4e4fb53ad62d5f09b1a2f5458/uvicorn-0.30.6-py3-none-any.whl - sha256: 65fd46fe3fda5bdc1b03b94eb634923ff18cd35b2f084813ea79d1f103f711b5 + version: 0.34.0 + sha256: 023dc038422502fa28a09c7a30bf2b6991512da7dcdb8fd35fe57cfc154126f4 requires_dist: - click>=7.0 - h11>=0.8 - typing-extensions>=4.0 ; python_full_version < '3.11' - colorama>=0.4 ; sys_platform == 'win32' and extra == 'standard' - - httptools>=0.5.0 ; extra == 'standard' + - httptools>=0.6.3 ; extra == 'standard' - python-dotenv>=0.13 ; extra == 'standard' - pyyaml>=5.1 ; extra == 'standard' - - uvloop!=0.15.0,!=0.15.1,>=0.14.0 ; platform_python_implementation != 'PyPy' and sys_platform != 'cygwin' and sys_platform != 'win32' and extra == 'standard' + - uvloop>=0.14.0,!=0.15.0,!=0.15.1 ; platform_python_implementation != 'PyPy' and sys_platform != 'cygwin' and sys_platform != 'win32' and extra == 'standard' - watchfiles>=0.13 ; extra == 'standard' - websockets>=10.4 ; extra == 'standard' - requires_python: '>=3.8' -- kind: conda - name: watchfiles - version: 0.24.0 - build: py312h12e396e_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/watchfiles-0.24.0-py312h12e396e_1.conda - sha256: 04227e72c1e8c30afca18860491462461d35ffa1dba552770adce61794aa7114 - md5: fa5bb5b364b0f8162d67c31009c985c9 + requires_python: '>=3.9' +- conda: https://conda.anaconda.org/conda-forge/linux-64/vtk-9.3.0-qt_py312h1234567_200.conda + sha256: 4c24ca644195df50f55f3caaa6d613cd07a3520ec0255a6af12f8c3afcb76588 + md5: 0006750ce0138b2f412daab8b56f92cf + depends: + - vtk-base 9.3.0 qt_py312h1234567_200 + - vtk-io-ffmpeg 9.3.0 qt_py312h1234567_200 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 21247 + timestamp: 1718291956251 +- conda: https://conda.anaconda.org/conda-forge/linux-64/vtk-base-9.3.0-qt_py312h1234567_200.conda + sha256: 9130d3fb28c933bb73518bb14ee2a5d35f99e88c1afd7d29c525e3b988315058 + md5: e607cc4bdc97ffbdc83cbf5f18537f93 + depends: + - __glibc >=2.17,<3.0.a0 + - double-conversion >=3.3.0,<3.4.0a0 + - eigen + - expat + - freetype >=2.12.1,<3.0a0 + - gl2ps >=1.4.2,<1.4.3.0a0 + - glew >=2.1.0,<2.2.0a0 + - hdf5 >=1.14.3,<1.14.4.0a0 + - jsoncpp >=1.9.5,<1.9.6.0a0 + - libexpat >=2.6.2,<3.0a0 + - libgcc-ng >=12 + - libjpeg-turbo >=3.0.0,<4.0a0 + - libnetcdf >=4.9.2,<4.9.3.0a0 + - libogg >=1.3.4,<1.4.0a0 + - libpng >=1.6.43,<1.7.0a0 + - libsqlite >=3.46.0,<4.0a0 + - libstdcxx-ng >=12 + - libtheora >=1.1.1,<1.2.0a0 + - libtiff >=4.6.0,<4.8.0a0 + - libuuid >=2.38.1,<3.0a0 + - libxcb >=1.15,<1.16.0a0 + - libxml2 >=2.12.7,<3.0a0 + - libzlib >=1.2.13,<2.0a0 + - loguru + - lz4-c >=1.9.3,<1.10.0a0 + - nlohmann_json + - numpy + - proj >=9.3.1,<9.3.2.0a0 + - pugixml >=1.14,<1.15.0a0 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - qt6-main >=6.7.1,<6.8.0a0 + - sqlite + - tbb >=2021.12.0 + - tbb-devel + - tk >=8.6.13,<8.7.0a0 + - utfcpp + - wslink + - xorg-libice >=1.1.1,<2.0a0 + - xorg-libsm >=1.2.4,<2.0a0 + - xorg-libx11 >=1.8.9,<2.0a0 + - xorg-libxau >=1.0.11,<2.0a0 + - xorg-libxext >=1.3.4,<2.0a0 + - xorg-libxt >=1.3.0,<2.0a0 + - zlib + constrains: + - paraview ==9999999999 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 46227273 + timestamp: 1718291806072 +- conda: https://conda.anaconda.org/conda-forge/linux-64/vtk-io-ffmpeg-9.3.0-qt_py312h1234567_200.conda + sha256: d9a16ff9e54c196a890ba786d9675c76b1ff3ad6017ccdaf2d5f55f3d6af3e56 + md5: 382886acb577233f449a85cd82d7b266 + depends: + - ffmpeg >=6.1.1,<7.0a0 + - vtk-base 9.3.0 qt_py312h1234567_200 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 79564 + timestamp: 1718291952480 +- conda: https://conda.anaconda.org/conda-forge/linux-64/watchfiles-1.0.3-py312h12e396e_0.conda + sha256: c89755d8e8f6384b3ba13e41dcabb40bf690c38b9d61512e963129badb1ad332 + md5: b76a5ad00856af6e74da9c3e85fed0cc depends: - __glibc >=2.17,<3.0.a0 - anyio >=3.0.0 @@ -16193,17 +15474,11 @@ packages: license_family: MIT purls: - pkg:pypi/watchfiles?source=project-defined-mapping - size: 397205 - timestamp: 1725347165866 -- kind: conda - name: watchfiles - version: 0.24.0 - build: py312he431725_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/watchfiles-0.24.0-py312he431725_1.conda - sha256: e92ec8593fee0ce6cb2b565900eb9792c73efacc129d2bf92dba074bca505598 - md5: 7fd741404e6fcab22a988ee6742dc778 + size: 410432 + timestamp: 1733998892675 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/watchfiles-1.0.3-py312hcd83bfe_0.conda + sha256: b64b78a7d6384bf72a878256802c783c692fe641ab4b806fd7e9f45e18a5e3b4 + md5: 13b89e1aa72aa773806b1f59ec018b67 depends: - __osx >=11.0 - anyio >=3.0.0 @@ -16216,14 +15491,9 @@ packages: license_family: MIT purls: - pkg:pypi/watchfiles?source=project-defined-mapping - size: 342896 - timestamp: 1725347401713 -- kind: conda - name: wayland - version: 1.23.1 - build: h3e06ad9_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/wayland-1.23.1-h3e06ad9_0.conda + size: 363162 + timestamp: 1733999215646 +- conda: https://conda.anaconda.org/conda-forge/linux-64/wayland-1.23.1-h3e06ad9_0.conda sha256: 0884b2023a32d2620192cf2e2fc6784b8d1e31cf9f137e49e00802d4daf7d1c1 md5: 0a732427643ae5e0486a727927791da1 depends: @@ -16237,13 +15507,7 @@ packages: purls: [] size: 321561 timestamp: 1724530461598 -- kind: conda - name: wayland-protocols - version: '1.37' - build: hd8ed1ab_0 - subdir: noarch - noarch: generic - url: https://conda.anaconda.org/conda-forge/noarch/wayland-protocols-1.37-hd8ed1ab_0.conda +- conda: https://conda.anaconda.org/conda-forge/noarch/wayland-protocols-1.37-hd8ed1ab_0.conda sha256: f6cac1efd4d2a6e30c1671f0566d4e6ac3fe2dc34c9ff7f309bbbc916520ebcf md5: 73ec79a77d31eb7e4a3276cd246b776c depends: @@ -16253,139 +15517,115 @@ packages: purls: [] size: 95953 timestamp: 1725657284103 -- kind: conda - name: wcwidth - version: 0.2.13 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.2.13-pyhd8ed1ab_0.conda - sha256: b6cd2fee7e728e620ec736d8dfee29c6c9e2adbd4e695a31f1d8f834a83e57e3 - md5: 68f0738df502a14213624b288c60c9ad +- conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.2.13-pyhd8ed1ab_1.conda + sha256: f21e63e8f7346f9074fd00ca3b079bd3d2fa4d71f1f89d5b6934bf31446dc2a5 + md5: b68980f2495d096e71c7fd9d7ccf63e6 depends: - - python >=3.8 + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/wcwidth?source=project-defined-mapping - size: 32709 - timestamp: 1704731373922 -- kind: conda - name: webcolors - version: 24.8.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/webcolors-24.8.0-pyhd8ed1ab_0.conda - sha256: ec71f97c332a7d328ae038990b8090cbfa772f82845b5d2233defd167b7cc5ac - md5: eb48b812eb4fbb9ff238a6651fdbbcae + size: 32581 + timestamp: 1733231433877 +- conda: https://conda.anaconda.org/conda-forge/noarch/webcolors-24.11.1-pyhd8ed1ab_0.conda + sha256: 08315dc2e61766a39219b2d82685fc25a56b2817acf84d5b390176080eaacf99 + md5: b49f7b291e15494aafb0a7d74806f337 depends: - - python >=3.5 + - python >=3.9 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/webcolors?source=project-defined-mapping - size: 18378 - timestamp: 1723294800217 -- kind: conda - name: webencodings - version: 0.5.1 - build: pyhd8ed1ab_2 - build_number: 2 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/webencodings-0.5.1-pyhd8ed1ab_2.conda - sha256: 2adf9bd5482802837bc8814cbe28d7b2a4cbd2e2c52e381329eaa283b3ed1944 - md5: daf5160ff9cde3a468556965329085b9 + size: 18431 + timestamp: 1733359823938 +- conda: https://conda.anaconda.org/conda-forge/noarch/webencodings-0.5.1-pyhd8ed1ab_3.conda + sha256: 19ff205e138bb056a46f9e3839935a2e60bd1cf01c8241a5e172a422fed4f9c6 + md5: 2841eb5bfc75ce15e9a0054b98dcd64d depends: - - python >=2.6 + - python >=3.9 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/webencodings?source=project-defined-mapping - size: 15600 - timestamp: 1694681458271 -- kind: conda - name: websocket-client - version: 1.8.0 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/websocket-client-1.8.0-pyhd8ed1ab_0.conda - sha256: 44a5e3b97feef24cd719f7851cca9af9799dc9c17d3e0298d5856baab2d682f5 - md5: f372c576b8774922da83cda2b12f9d29 + size: 15496 + timestamp: 1733236131358 +- conda: https://conda.anaconda.org/conda-forge/noarch/websocket-client-1.8.0-pyhd8ed1ab_1.conda + sha256: 1dd84764424ffc82030c19ad70607e6f9e3b9cb8e633970766d697185652053e + md5: 84f8f77f0a9c6ef401ee96611745da8f depends: - - python >=3.8 + - python >=3.9 license: Apache-2.0 license_family: APACHE purls: - pkg:pypi/websocket-client?source=project-defined-mapping - size: 47066 - timestamp: 1713923494501 -- kind: conda - name: widgetsnbextension - version: 4.0.13 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/widgetsnbextension-4.0.13-pyhd8ed1ab_0.conda - sha256: d155adc10f8c96f76d4468dbe37b33b4334dadf5cd4a95841aa009ca9bced5fa - md5: 6372cd99502721bd7499f8d16b56268d + size: 46718 + timestamp: 1733157432924 +- conda: https://conda.anaconda.org/conda-forge/noarch/werkzeug-3.1.3-pyhd8ed1ab_1.conda + sha256: cd9a603beae0b237be7d9dfae8ae0b36ad62666ac4bb073969bce7da6f55157c + md5: 0a9b57c159d56b508613cc39022c1b9e depends: - - python >=3.7 + - markupsafe >=2.1.1 + - python >=3.9 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/werkzeug?source=project-defined-mapping + size: 243546 + timestamp: 1733160561258 +- conda: https://conda.anaconda.org/conda-forge/noarch/widgetsnbextension-4.0.13-pyhd8ed1ab_1.conda + sha256: a750202ae2a31d8e5ee5a5c127fcc7fa783cd0fbedbc0bf1ab549a109881fa9f + md5: 237db148cc37a466e4222d589029b53e + depends: + - python >=3.9 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/widgetsnbextension?source=project-defined-mapping - size: 898656 - timestamp: 1724331433259 -- kind: conda - name: wrapt - version: 1.16.0 - build: py312h024a12e_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/wrapt-1.16.0-py312h024a12e_1.conda - sha256: 54a5d3d9e1b45022b28c5ca3ceaa7ec2db4a40968b2b556804becfdff98f4efe - md5: f97c9abfeb8292f5f8353607ca8a1127 + size: 898402 + timestamp: 1733128654300 +- conda: https://conda.anaconda.org/conda-forge/linux-64/wrapt-1.17.0-py312h66e93f0_0.conda + sha256: a6fc0f4e90643d0c1fd4aab669b6a79f44a305a5474256f6f2da3354d2310fb4 + md5: ddbe3bb0e1356cb9074dd848570694f9 depends: - - __osx >=11.0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 license: BSD-2-Clause license_family: BSD purls: - pkg:pypi/wrapt?source=project-defined-mapping - size: 59642 - timestamp: 1724958200454 -- kind: conda - name: wrapt - version: 1.16.0 - build: py312h66e93f0_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/wrapt-1.16.0-py312h66e93f0_1.conda - sha256: 3a15a399eb61a999f0f14b4d243acc14e2dff1ead92ef52fcff30c84be89b21c - md5: 2eebcffe80e2a7bb2f0a77e621a7f124 + size: 63807 + timestamp: 1732523690292 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/wrapt-1.17.0-py312hea69d52_0.conda + sha256: 0fb35c3d1642f9f47db87bdb33148f88ef19a3af1eb0ee99b5491551c57269c7 + md5: 73414acdb779a8694a14527865b4357a depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=13 + - __osx >=11.0 - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 license: BSD-2-Clause license_family: BSD purls: - pkg:pypi/wrapt?source=project-defined-mapping - size: 62624 - timestamp: 1724958046744 -- kind: conda - name: x264 - version: 1!164.3095 - build: h166bdaf_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/x264-1!164.3095-h166bdaf_2.tar.bz2 + size: 61043 + timestamp: 1732523852129 +- conda: https://conda.anaconda.org/conda-forge/noarch/wslink-2.2.1-pyhd8ed1ab_1.conda + sha256: c5710a9637faf9c1391741f5bbe3445745f758f01575517c6cb403cd2f55f82b + md5: af249fc92d1344913ff6c811f5b9096b + depends: + - aiohttp <4 + - msgpack-python >=1,<2 + - python >=3.9 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/wslink?source=project-defined-mapping + size: 34575 + timestamp: 1733083632985 +- conda: https://conda.anaconda.org/conda-forge/linux-64/x264-1!164.3095-h166bdaf_2.tar.bz2 sha256: 175315eb3d6ea1f64a6ce470be00fa2ee59980108f246d3072ab8b977cb048a5 md5: 6c99772d483f566d59e25037fea2c4b1 depends: @@ -16395,13 +15635,7 @@ packages: purls: [] size: 897548 timestamp: 1660323080555 -- kind: conda - name: x264 - version: 1!164.3095 - build: h57fd34a_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/x264-1!164.3095-h57fd34a_2.tar.bz2 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/x264-1!164.3095-h57fd34a_2.tar.bz2 sha256: debdf60bbcfa6a60201b12a1d53f36736821db281a28223a09e0685edcce105a md5: b1f6dccde5d3a1f911960b6e567113ff license: GPL-2.0-or-later @@ -16409,13 +15643,7 @@ packages: purls: [] size: 717038 timestamp: 1660323292329 -- kind: conda - name: x265 - version: '3.5' - build: h924138e_3 - build_number: 3 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/x265-3.5-h924138e_3.tar.bz2 +- conda: https://conda.anaconda.org/conda-forge/linux-64/x265-3.5-h924138e_3.tar.bz2 sha256: 76c7405bcf2af639971150f342550484efac18219c0203c5ee2e38b8956fe2a0 md5: e7f6ed84d4623d52ee581325c1587a6b depends: @@ -16426,13 +15654,7 @@ packages: purls: [] size: 3357188 timestamp: 1646609687141 -- kind: conda - name: x265 - version: '3.5' - build: hbc6ce65_3 - build_number: 3 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/x265-3.5-hbc6ce65_3.tar.bz2 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/x265-3.5-hbc6ce65_3.tar.bz2 sha256: 2fed6987dba7dee07bd9adc1a6f8e6c699efb851431bcb6ebad7de196e87841d md5: b1f7f2780feffe310b068c021e8ff9b2 depends: @@ -16442,115 +15664,150 @@ packages: purls: [] size: 1832744 timestamp: 1646609481185 -- kind: conda - name: xcb-util - version: 0.4.1 - build: hb711507_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-0.4.1-hb711507_2.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-0.4.0-hd590300_1.conda + sha256: 0c91d87f0efdaadd4e56a5f024f8aab20ec30f90aa2ce9e4ebea05fbc20f71ad + md5: 9bfac7ccd94d54fd21a0501296d60424 + depends: + - libgcc-ng >=12 + - libxcb >=1.13 + - libxcb >=1.15,<1.16.0a0 + license: MIT + license_family: MIT + purls: [] + size: 19728 + timestamp: 1684639166048 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-0.4.1-hb711507_2.conda sha256: 416aa55d946ce4ab173ab338796564893a2f820e80e04e098ff00c25fb981263 md5: 8637c3e5821654d0edf97e2b0404b443 depends: - libgcc-ng >=12 - - libxcb >=1.16,<1.17.0a0 + - libxcb >=1.16,<2.0.0a0 license: MIT license_family: MIT purls: [] size: 19965 timestamp: 1718843348208 -- kind: conda - name: xcb-util-cursor - version: 0.1.4 - build: h4ab18f5_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-cursor-0.1.4-h4ab18f5_2.conda - sha256: c72e58bae4a7972ca4dee5e850e82216222c06d53b3651e1ca7db8b5d2fc95fe - md5: 79e46d4a6ccecb7ee1912042958a8758 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-cursor-0.1.4-hd590300_1.conda + sha256: df147500874761501030227d6bb8889443480cd6fe00361bb046d9840f04d17b + md5: 1ecae8461689e44fe0f0e3d18e58e799 depends: - libgcc-ng >=12 - libxcb >=1.13 - - libxcb >=1.16,<1.17.0a0 + - libxcb >=1.15,<1.16.0a0 + - xcb-util-image >=0.4.0,<0.5.0a0 + - xcb-util-renderutil >=0.3.9,<0.4.0a0 + license: MIT + license_family: MIT + purls: [] + size: 20170 + timestamp: 1684687482843 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-cursor-0.1.5-hb9d3cd8_0.conda + sha256: c7b35db96f6e32a9e5346f97adc968ef2f33948e3d7084295baebc0e33abdd5b + md5: eb44b3b6deb1cab08d72cb61686fe64c + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libxcb >=1.13 + - libxcb >=1.16,<2.0.0a0 - xcb-util-image >=0.4.0,<0.5.0a0 - xcb-util-renderutil >=0.3.10,<0.4.0a0 license: MIT license_family: MIT purls: [] - size: 20397 - timestamp: 1718899451268 -- kind: conda - name: xcb-util-image - version: 0.4.0 - build: hb711507_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-image-0.4.0-hb711507_2.conda + size: 20296 + timestamp: 1726125844850 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-image-0.4.0-h8ee46fc_1.conda + sha256: 92ffd68d2801dbc27afe223e04ae7e78ef605fc8575f107113c93c7bafbd15b0 + md5: 9d7bcddf49cbf727730af10e71022c73 + depends: + - libgcc-ng >=12 + - libxcb >=1.15,<1.16.0a0 + - xcb-util >=0.4.0,<0.5.0a0 + license: MIT + license_family: MIT + purls: [] + size: 24474 + timestamp: 1684679894554 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-image-0.4.0-hb711507_2.conda sha256: 94b12ff8b30260d9de4fd7a28cca12e028e572cbc504fd42aa2646ec4a5bded7 md5: a0901183f08b6c7107aab109733a3c91 depends: - libgcc-ng >=12 - - libxcb >=1.16,<1.17.0a0 + - libxcb >=1.16,<2.0.0a0 - xcb-util >=0.4.1,<0.5.0a0 license: MIT license_family: MIT purls: [] size: 24551 timestamp: 1718880534789 -- kind: conda - name: xcb-util-keysyms - version: 0.4.1 - build: hb711507_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-keysyms-0.4.1-hb711507_0.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-keysyms-0.4.0-h8ee46fc_1.conda + sha256: 8451d92f25d6054a941b962179180728c48c62aab5bf20ac10fef713d5da6a9a + md5: 632413adcd8bc16b515cab87a2932913 + depends: + - libgcc-ng >=12 + - libxcb >=1.15,<1.16.0a0 + license: MIT + license_family: MIT + purls: [] + size: 14186 + timestamp: 1684680497805 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-keysyms-0.4.1-hb711507_0.conda sha256: 546e3ee01e95a4c884b6401284bb22da449a2f4daf508d038fdfa0712fe4cc69 md5: ad748ccca349aec3e91743e08b5e2b50 depends: - libgcc-ng >=12 - - libxcb >=1.16,<1.17.0a0 + - libxcb >=1.16,<2.0.0a0 + license: MIT + license_family: MIT + purls: [] + size: 14314 + timestamp: 1718846569232 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-renderutil-0.3.10-hb711507_0.conda + sha256: 2d401dadc43855971ce008344a4b5bd804aca9487d8ebd83328592217daca3df + md5: 0e0cbe0564d03a99afd5fd7b362feecd + depends: + - libgcc-ng >=12 + - libxcb >=1.16,<2.0.0a0 + license: MIT + license_family: MIT + purls: [] + size: 16978 + timestamp: 1718848865819 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-renderutil-0.3.9-hd590300_1.conda + sha256: 6987588e6fff5892056021c2ea52f7a0deefb2c7348e70d24750e2d60dabf009 + md5: e995b155d938b6779da6ace6c6b13816 + depends: + - libgcc-ng >=12 + - libxcb >=1.13 + - libxcb >=1.15,<1.16.0a0 license: MIT license_family: MIT purls: [] - size: 14314 - timestamp: 1718846569232 -- kind: conda - name: xcb-util-renderutil - version: 0.3.10 - build: hb711507_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-renderutil-0.3.10-hb711507_0.conda - sha256: 2d401dadc43855971ce008344a4b5bd804aca9487d8ebd83328592217daca3df - md5: 0e0cbe0564d03a99afd5fd7b362feecd + size: 16955 + timestamp: 1684639112393 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-wm-0.4.1-h8ee46fc_1.conda + sha256: 08ba7147c7579249b6efd33397dc1a8c2404278053165aaecd39280fee705724 + md5: 90108a432fb5c6150ccfee3f03388656 depends: - libgcc-ng >=12 - - libxcb >=1.16,<1.17.0a0 + - libxcb >=1.15,<1.16.0a0 license: MIT license_family: MIT purls: [] - size: 16978 - timestamp: 1718848865819 -- kind: conda - name: xcb-util-wm - version: 0.4.2 - build: hb711507_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-wm-0.4.2-hb711507_0.conda + size: 52114 + timestamp: 1684679248466 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-wm-0.4.2-hb711507_0.conda sha256: 31d44f297ad87a1e6510895740325a635dd204556aa7e079194a0034cdd7e66a md5: 608e0ef8256b81d04456e8d211eee3e8 depends: - libgcc-ng >=12 - - libxcb >=1.16,<1.17.0a0 + - libxcb >=1.16,<2.0.0a0 license: MIT license_family: MIT purls: [] size: 51689 timestamp: 1718844051451 -- kind: conda - name: xkeyboard-config - version: '2.42' - build: h4ab18f5_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xkeyboard-config-2.42-h4ab18f5_0.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/xkeyboard-config-2.42-h4ab18f5_0.conda sha256: 240caab7d9d85154ef373ecbac3ff9fb424add2029dbb124e949c6cbab2996dd md5: b193af204da1bfb8c13882d131a14bd2 depends: @@ -16561,190 +15818,157 @@ packages: purls: [] size: 388998 timestamp: 1717817668629 -- kind: conda - name: xorg-compositeproto - version: 0.4.2 - build: h7f98852_1001 - build_number: 1001 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-compositeproto-0.4.2-h7f98852_1001.tar.bz2 - sha256: 8127541fb7ee4ba81cabd3ac464953ec928489bf01d647e5819cd7cd9428730c - md5: 8bf27eeb636d3acce5c6cb570ba63487 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xkeyboard-config-2.43-hb9d3cd8_0.conda + sha256: 0d89b5873515a1f05d311f37ea4e087bbccc0418afa38f2f6189e97280db3179 + md5: f725c7425d6d7c15e31f3b99a88ea02f depends: - - libgcc-ng >=9.3.0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 license: MIT license_family: MIT purls: [] - size: 12391 - timestamp: 1612964792999 -- kind: conda - name: xorg-damageproto - version: 1.2.1 - build: h7f98852_1002 - build_number: 1002 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-damageproto-1.2.1-h7f98852_1002.tar.bz2 - sha256: b0a62b8eedc3e1b47fbbe3bbe6011542d36867b90f9b4bf251b78109ee1f0d9b - md5: 58c9bb067637c5a13a045a7124eeb027 + size: 389475 + timestamp: 1727840188958 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-compositeproto-0.4.2-hb9d3cd8_1002.conda + sha256: b800b09a090e4acef0b8653bcb1a4811e8f44559d4eff050886770fdfa77857b + md5: 317d35860cab6c16d91a81f67303023d depends: - - libgcc-ng >=9.3.0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 license: MIT license_family: MIT purls: [] - size: 25425 - timestamp: 1620067841828 -- kind: conda - name: xorg-fixesproto - version: '5.0' - build: h7f98852_1002 - build_number: 1002 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-fixesproto-5.0-h7f98852_1002.tar.bz2 - sha256: 5d2af1b40f82128221bace9466565eca87c97726bb80bbfcd03871813f3e1876 - md5: 65ad6e1eb4aed2b0611855aff05e04f6 + size: 14808 + timestamp: 1726801836848 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-damageproto-1.2.1-hb9d3cd8_1003.conda + sha256: 424a9202255359a75770eaca534e4e8b07464242f0146871915e1bb76fb3ffae + md5: 5135d24c55235da88c2fe48a8662927a depends: - - libgcc-ng >=9.3.0 - - xorg-xextproto + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 license: MIT license_family: MIT purls: [] - size: 9122 - timestamp: 1617479697350 -- kind: conda - name: xorg-glproto - version: 1.4.17 - build: h7f98852_1002 - build_number: 1002 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-glproto-1.4.17-h7f98852_1002.tar.bz2 - sha256: 41d9c567d3867e630d1dbb790371b8419784d70cb0ae98f5c60bceed3ccc92f6 - md5: e41bf01f80d46be87dcae2333a766e75 + size: 27720 + timestamp: 1726801874619 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-fixesproto-5.0-hb9d3cd8_1003.conda + sha256: 07268980b659a84a4bac64b475329348e9cf5fa4aee255fa94aa0407ae5b804c + md5: 19fe37721037acc0a1ed76b8cf937359 depends: - - libgcc-ng >=9.3.0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-xextproto >=7.3.0,<8.0a0 license: MIT license_family: MIT purls: [] - size: 21299 - timestamp: 1620611690111 -- kind: conda - name: xorg-inputproto - version: 2.3.2 - build: h7f98852_1002 - build_number: 1002 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-inputproto-2.3.2-h7f98852_1002.tar.bz2 - sha256: 6c8c2803de0f643f8bad16ece3f9a7259e4a49247543239c182d66d5e3a129a7 - md5: bcd1b3396ec6960cbc1d2855a9e60b2b + size: 11311 + timestamp: 1727033761080 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-glproto-1.4.17-hb9d3cd8_1003.conda + sha256: cd29d1023230078cf83a06d01f4f013d9bbfbc7f8082ba59b40090c4f2f4eec3 + md5: 8361b4e3d72dc700eb46422470b34901 depends: - - libgcc-ng >=9.3.0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 license: MIT license_family: MIT purls: [] - size: 19602 - timestamp: 1610027678228 -- kind: conda - name: xorg-kbproto - version: 1.0.7 - build: h7f98852_1002 - build_number: 1002 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-kbproto-1.0.7-h7f98852_1002.tar.bz2 - sha256: e90b0a6a5d41776f11add74aa030f789faf4efd3875c31964d6f9cfa63a10dd1 - md5: 4b230e8381279d76131116660f5a241a + size: 23473 + timestamp: 1726801830878 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-inputproto-2.3.2-hb9d3cd8_1003.conda + sha256: 77eea289f9d3fa753a290f988533c842694b826fe1900abd6d7b142c528512ba + md5: 32623b33f2047dbc9ae2f2e8fd3880e9 depends: - - libgcc-ng >=9.3.0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 license: MIT license_family: MIT purls: [] - size: 27338 - timestamp: 1610027759842 -- kind: conda - name: xorg-libice - version: 1.1.1 - build: hd590300_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-libice-1.1.1-hd590300_0.conda - sha256: 5aa9b3682285bb2bf1a8adc064cb63aff76ef9178769740d855abb42b0d24236 - md5: b462a33c0be1421532f28bfe8f4a7514 + size: 22320 + timestamp: 1726802558171 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-kbproto-1.0.7-hb9d3cd8_1003.conda + sha256: 849555ddf7fee334a5a6be9f159d2931c9d076ffb310a9e75b9124f789049d3e + md5: e87bfacb110d85e1eb6099c9ed8e7236 depends: - - libgcc-ng >=12 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 license: MIT license_family: MIT purls: [] - size: 58469 - timestamp: 1685307573114 -- kind: conda - name: xorg-libsm - version: 1.2.4 - build: h7391055_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-libsm-1.2.4-h7391055_0.conda - sha256: 089ad5f0453c604e18985480218a84b27009e9e6de9a0fa5f4a20b8778ede1f1 - md5: 93ee23f12bc2e684548181256edd2cf6 + size: 30242 + timestamp: 1726846706299 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libice-1.1.2-hb9d3cd8_0.conda + sha256: c12396aabb21244c212e488bbdc4abcdef0b7404b15761d9329f5a4a39113c4b + md5: fb901ff28063514abb6046c9ec2c4a45 depends: - - libgcc-ng >=12 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + license: MIT + license_family: MIT + purls: [] + size: 58628 + timestamp: 1734227592886 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libsm-1.2.5-he73a12e_0.conda + sha256: 760f43df6c2ce8cbbbcb8f2f3b7fc0f306716c011e28d1d340f3dfa8ccf29185 + md5: 4c3e9fab69804ec6077697922d70c6e2 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 - libuuid >=2.38.1,<3.0a0 - - xorg-libice >=1.1.1,<2.0a0 + - xorg-libice >=1.1.2,<2.0a0 license: MIT license_family: MIT purls: [] - size: 27433 - timestamp: 1685453649160 -- kind: conda - name: xorg-libx11 - version: 1.8.9 - build: hb711507_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-libx11-1.8.9-hb711507_1.conda - sha256: 66eabe62b66c1597c4a755dcd3f4ce2c78adaf7b32e25dfee45504d67d7735c1 - md5: 4a6d410296d7e39f00bacdee7df046e9 + size: 27198 + timestamp: 1734229639785 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libx11-1.8.10-h4f16b4b_1.conda + sha256: f53994d54f0604df881c4e984279b3cf6a1648a22d4b2113e2c89829968784c9 + md5: 125f34a17d7b4bea418a83904ea82ea6 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libxcb >=1.17.0,<2.0a0 + license: MIT + license_family: MIT + purls: [] + size: 837524 + timestamp: 1733324962639 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libx11-1.8.9-h8ee46fc_0.conda + sha256: 3e53ba247f1ad68353f18aceba5bf8ce87e3dea930de85d36946844a7658c9fb + md5: 077b6e8ad6a3ddb741fce2496dd01bec depends: - libgcc-ng >=12 - - libxcb >=1.16,<1.17.0a0 + - libxcb >=1.15,<1.16.0a0 - xorg-kbproto - xorg-xextproto >=7.3.0,<8.0a0 - xorg-xproto license: MIT license_family: MIT purls: [] - size: 832198 - timestamp: 1718846846409 -- kind: conda - name: xorg-libxau - version: 1.0.11 - build: hb547adb_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxau-1.0.11-hb547adb_0.conda - sha256: 02c313a1cada46912e5b9bdb355cfb4534bfe22143b4ea4ecc419690e793023b - md5: ca73dc4f01ea91e44e3ed76602c5ea61 + size: 828060 + timestamp: 1712415742569 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.12-hb9d3cd8_0.conda + sha256: ed10c9283974d311855ae08a16dfd7e56241fac632aec3b92e3cfe73cff31038 + md5: f6ebe2cb3f82ba6c057dde5d9debe4f7 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 license: MIT license_family: MIT purls: [] - size: 13667 - timestamp: 1684638272445 -- kind: conda - name: xorg-libxau - version: 1.0.11 - build: hd590300_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.11-hd590300_0.conda - sha256: 309751371d525ce50af7c87811b435c176915239fc9e132b99a25d5e1703f2d4 - md5: 2c80dc38fface310c9bd81b17037fee5 + size: 14780 + timestamp: 1734229004433 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxau-1.0.12-h5505292_0.conda + sha256: f33e6f013fc36ebc200f09ddead83468544cb5c353a3b50499b07b8c34e28a8d + md5: 50901e0764b7701d8ed7343496f4f301 depends: - - libgcc-ng >=12 + - __osx >=11.0 license: MIT license_family: MIT purls: [] - size: 14468 - timestamp: 1684637984591 -- kind: conda - name: xorg-libxcomposite - version: 0.4.6 - build: h0b41bf4_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcomposite-0.4.6-h0b41bf4_1.conda + size: 13593 + timestamp: 1734229104321 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcomposite-0.4.6-h0b41bf4_1.conda sha256: 7c5806a8de1ce0d4e0c7aae8d29565f11fba6c6da4a787c3e09f1fcc428725a4 md5: ada6777364a0ea2407a1894e54779cc4 depends: @@ -16758,13 +15982,34 @@ packages: purls: [] size: 13436 timestamp: 1676978990631 -- kind: conda - name: xorg-libxdamage - version: 1.1.5 - build: h7f98852_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdamage-1.1.5-h7f98852_1.tar.bz2 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcomposite-0.4.6-hb9d3cd8_2.conda + sha256: 753f73e990c33366a91fd42cc17a3d19bb9444b9ca5ff983605fa9e953baf57f + md5: d3c295b50f092ab525ffe3c2aa4b7413 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxfixes >=6.0.1,<7.0a0 + license: MIT + license_family: MIT + purls: [] + size: 13603 + timestamp: 1727884600744 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcursor-1.2.3-hb9d3cd8_0.conda + sha256: 832f538ade441b1eee863c8c91af9e69b356cd3e9e1350fff4fe36cc573fc91a + md5: 2ccd714aa2242315acaf0a67faea780b + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxfixes >=6.0.1,<7.0a0 + - xorg-libxrender >=0.9.11,<0.10.0a0 + license: MIT + license_family: MIT + purls: [] + size: 32533 + timestamp: 1730908305254 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdamage-1.1.5-h7f98852_1.tar.bz2 sha256: 4cab878855e48669b64dd7522a518433ac83bb56fa79743d12db316326e2e39e md5: bebd3814ec2355fab6a474b07ed73093 depends: @@ -16780,41 +16025,42 @@ packages: purls: [] size: 11964 timestamp: 1641830754492 -- kind: conda - name: xorg-libxdmcp - version: 1.1.3 - build: h27ca646_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxdmcp-1.1.3-h27ca646_0.tar.bz2 - sha256: d9a2fb4762779994718832f05a7d62ab2dcf6103a312235267628b5187ce88f7 - md5: 6738b13f7fadc18725965abdd4129c36 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdamage-1.1.6-hb9d3cd8_0.conda + sha256: 43b9772fd6582bf401846642c4635c47a9b0e36ca08116b3ec3df36ab96e0ec0 + md5: b5fcc7172d22516e1f965490e65e33a4 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + - xorg-libxfixes >=6.0.1,<7.0a0 license: MIT license_family: MIT purls: [] - size: 18164 - timestamp: 1610071737668 -- kind: conda - name: xorg-libxdmcp - version: 1.1.3 - build: h7f98852_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.3-h7f98852_0.tar.bz2 - sha256: 4df7c5ee11b8686d3453e7f3f4aa20ceef441262b49860733066c52cfd0e4a77 - md5: be93aabceefa2fac576e971aef407908 + size: 13217 + timestamp: 1727891438799 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.5-hb9d3cd8_0.conda + sha256: 6b250f3e59db07c2514057944a3ea2044d6a8cdde8a47b6497c254520fade1ee + md5: 8035c64cb77ed555e3f150b7b3972480 depends: - - libgcc-ng >=9.3.0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 license: MIT license_family: MIT purls: [] - size: 19126 - timestamp: 1610071769228 -- kind: conda - name: xorg-libxext - version: 1.3.4 - build: h0b41bf4_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxext-1.3.4-h0b41bf4_2.conda + size: 19901 + timestamp: 1727794976192 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxdmcp-1.1.5-hd74edd7_0.conda + sha256: 9939a166d780700d81023546759102b33fdc2c5f11ef09f5f66c77210fd334c8 + md5: 77c447f48cab5d3a15ac224edb86a968 + depends: + - __osx >=11.0 + license: MIT + license_family: MIT + purls: [] + size: 18487 + timestamp: 1727795205022 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxext-1.3.4-h0b41bf4_2.conda sha256: 73e5cfbdff41ef8a844441f884412aa5a585a0f0632ec901da035a03e1fe1249 md5: 82b6df12252e6f32402b96dacc656fec depends: @@ -16826,13 +16072,19 @@ packages: purls: [] size: 50143 timestamp: 1677036907815 -- kind: conda - name: xorg-libxfixes - version: 5.0.3 - build: h7f98852_1004 - build_number: 1004 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxfixes-5.0.3-h7f98852_1004.tar.bz2 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxext-1.3.6-hb9d3cd8_0.conda + sha256: da5dc921c017c05f38a38bd75245017463104457b63a1ce633ed41f214159c14 + md5: febbab7d15033c913d53c7a2c102309d + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + license: MIT + license_family: MIT + purls: [] + size: 50060 + timestamp: 1727752228921 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxfixes-5.0.3-h7f98852_1004.tar.bz2 sha256: 1e426a1abb774ef1dcf741945ed5c42ad12ea2dc7aeed7682d293879c3e1e4c3 md5: e9a21aa4d5e3e5f1aed71e8cefd46b6a depends: @@ -16844,13 +16096,19 @@ packages: purls: [] size: 18145 timestamp: 1617717802636 -- kind: conda - name: xorg-libxi - version: 1.7.10 - build: h4bc722e_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxi-1.7.10-h4bc722e_1.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxfixes-6.0.1-hb9d3cd8_0.conda + sha256: 2fef37e660985794617716eb915865ce157004a4d567ed35ec16514960ae9271 + md5: 4bdb303603e9821baf5fe5fdff1dc8f8 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + license: MIT + license_family: MIT + purls: [] + size: 19575 + timestamp: 1727794961233 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxi-1.7.10-h4bc722e_1.conda sha256: e1416eb435e3d903bc658e3c637f0e87efd2dca290fe70daf29738b3a3d1f8ff md5: 749baebe7e2ff3360630e069175e528b depends: @@ -16867,12 +16125,21 @@ packages: purls: [] size: 46794 timestamp: 1722108216651 -- kind: conda - name: xorg-libxinerama - version: 1.1.5 - build: h27087fc_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxinerama-1.1.5-h27087fc_0.tar.bz2 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxi-1.8.2-hb9d3cd8_0.conda + sha256: 1a724b47d98d7880f26da40e45f01728e7638e6ec69f35a3e11f92acd05f9e7a + md5: 17dcc85db3c7886650b8908b183d6876 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + - xorg-libxfixes >=6.0.1,<7.0a0 + license: MIT + license_family: MIT + purls: [] + size: 47179 + timestamp: 1727799254088 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxinerama-1.1.5-h27087fc_0.tar.bz2 sha256: 0dc50f019ab9871bd9a8be0b00a1e0fa98172ef9c775a13e2dac2924844bb75e md5: 2e1c65825c586444df23784f68bef90e depends: @@ -16884,13 +16151,21 @@ packages: purls: [] size: 13350 timestamp: 1667399989190 -- kind: conda - name: xorg-libxrandr - version: 1.5.2 - build: h7f98852_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrandr-1.5.2-h7f98852_1.tar.bz2 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxinerama-1.1.5-h5888daf_1.conda + sha256: 1b9141c027f9d84a9ee5eb642a0c19457c788182a5a73c5a9083860ac5c20a8c + md5: 5e2eb9bf77394fc2e5918beefec9f9ab + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + license: MIT + license_family: MIT + purls: [] + size: 13891 + timestamp: 1727908521531 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrandr-1.5.2-h7f98852_1.tar.bz2 sha256: ffd075a463896ed86d9519e26dc36f754b695b9c1e1b6115d34fe138b36d8200 md5: 5b0f7da25a4556c9619c3e4b4a98ab07 depends: @@ -16906,12 +16181,21 @@ packages: purls: [] size: 29688 timestamp: 1621515728586 -- kind: conda - name: xorg-libxrender - version: 0.9.11 - build: hd590300_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrender-0.9.11-hd590300_0.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrandr-1.5.4-hb9d3cd8_0.conda + sha256: ac0f037e0791a620a69980914a77cb6bb40308e26db11698029d6708f5aa8e0d + md5: 2de7f99d6581a4a7adbff607b5c278ca + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + - xorg-libxrender >=0.9.11,<0.10.0a0 + license: MIT + license_family: MIT + purls: [] + size: 29599 + timestamp: 1727794874300 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrender-0.9.11-hd590300_0.conda sha256: 26da4d1911473c965c32ce2b4ff7572349719eaacb88a066db8d968a4132c3f7 md5: ed67c36f215b310412b2af935bf3e530 depends: @@ -16923,12 +16207,46 @@ packages: purls: [] size: 37770 timestamp: 1688300707994 -- kind: conda - name: xorg-libxtst - version: 1.2.5 - build: h4bc722e_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxtst-1.2.5-h4bc722e_0.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrender-0.9.12-hb9d3cd8_0.conda + sha256: 044c7b3153c224c6cedd4484dd91b389d2d7fd9c776ad0f4a34f099b3389f4a1 + md5: 96d57aba173e878a2089d5638016dc5e + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + license: MIT + license_family: MIT + purls: [] + size: 33005 + timestamp: 1734229037766 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxshmfence-1.3.3-hb9d3cd8_0.conda + sha256: c0830fe9fa78d609cd9021f797307e7e0715ef5122be3f784765dad1b4d8a193 + md5: 9a809ce9f65460195777f2f2116bae02 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + license: MIT + license_family: MIT + purls: + - pkg:pypi/xorg-libxshmfence + size: 12302 + timestamp: 1734168591429 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxt-1.3.0-hd590300_1.conda + sha256: e7648d1efe2e858c4bc63ccf4a637c841dc971b37ded85a01be97a5e240fecfa + md5: ae92aab42726eb29d16488924f7312cb + depends: + - libgcc-ng >=12 + - xorg-kbproto + - xorg-libice >=1.1.1,<2.0a0 + - xorg-libsm >=1.2.4,<2.0a0 + - xorg-libx11 >=1.8.6,<2.0a0 + - xorg-xproto + license: MIT + license_family: MIT + purls: [] + size: 379256 + timestamp: 1690288540492 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxtst-1.2.5-h4bc722e_0.conda sha256: 0139b52c3cbce57bfd1d120c41637bc239430faff4aa0445f58de0adf4c4b976 md5: 185159d666308204eca00295599b0a5c depends: @@ -16946,184 +16264,184 @@ packages: purls: [] size: 32931 timestamp: 1722575571554 -- kind: conda - name: xorg-libxxf86vm - version: 1.1.5 - build: h4bc722e_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxxf86vm-1.1.5-h4bc722e_1.conda - sha256: 109d6b1931d1482faa0bf6de83c7e6d9ca36bbf9d36a00a05df4f63b82fce5c3 - md5: 0c90ad87101001080484b91bd9d2cdef +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxtst-1.2.5-hb9d3cd8_3.conda + sha256: 752fdaac5d58ed863bbf685bb6f98092fe1a488ea8ebb7ed7b606ccfce08637a + md5: 7bbe9a0cc0df0ac5f5a8ad6d6a11af2f depends: - __glibc >=2.17,<3.0.a0 - - libgcc-ng >=12 - - xorg-libx11 >=1.8.9,<2.0a0 - - xorg-libxext >=1.3.4,<2.0a0 - - xorg-xextproto >=7.3.0,<8.0a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + - xorg-libxi >=1.7.10,<2.0a0 license: MIT license_family: MIT purls: [] - size: 18443 - timestamp: 1722110433983 -- kind: conda - name: xorg-randrproto - version: 1.5.0 - build: h7f98852_1001 - build_number: 1001 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-randrproto-1.5.0-h7f98852_1001.tar.bz2 - sha256: f5c7c2de3655a95153e900118959df6a50b6c104a3d7afaee3eadbf86b85fa2e - md5: 68cce654461713977dac6f9ac1bce89a + size: 32808 + timestamp: 1727964811275 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxxf86vm-1.1.6-hb9d3cd8_0.conda + sha256: 8a4e2ee642f884e6b78c20c0892b85dd9b2a6e64a6044e903297e616be6ca35b + md5: 5efa5fa6243a622445fdfd72aee15efa depends: - - libgcc-ng >=9.3.0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 license: MIT license_family: MIT purls: [] - size: 32984 - timestamp: 1621340029170 -- kind: conda - name: xorg-recordproto - version: 1.14.2 - build: h7f98852_1002 - build_number: 1002 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-recordproto-1.14.2-h7f98852_1002.tar.bz2 - sha256: 4b91d48fed368c83eafd03891ebfd5bae0a03adc087ebea8a680ae22da99a85f - md5: 2f835e6c386e73c6faaddfe9eda67e98 + size: 17819 + timestamp: 1734214575628 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-randrproto-1.5.0-hb9d3cd8_1002.conda + sha256: d742ac2970c05abb597dacccd411af0d5b7a280b0b3390c4f681022edf4541a2 + md5: b9485267c7eb6b8601b378e06a9e44d3 depends: - - libgcc-ng >=9.3.0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 license: MIT license_family: MIT purls: [] - size: 8014 - timestamp: 1621340029114 -- kind: conda - name: xorg-renderproto - version: 0.11.1 - build: h7f98852_1002 - build_number: 1002 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-renderproto-0.11.1-h7f98852_1002.tar.bz2 - sha256: 38942930f233d1898594dd9edf4b0c0786f3dbc12065a0c308634c37fd936034 - md5: 06feff3d2634e3097ce2fe681474b534 + size: 35658 + timestamp: 1726801844143 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-recordproto-1.14.2-hb9d3cd8_1003.conda + sha256: fa721a0a041453612f9dc03059905cf7426669ab8795e1b46d1b0f61c332b1ea + md5: 1d600d113f3e22a7eddd7e7d574be3fa depends: - - libgcc-ng >=9.3.0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 license: MIT license_family: MIT purls: [] - size: 9621 - timestamp: 1614866326326 -- kind: conda - name: xorg-util-macros - version: 1.19.3 - build: h7f98852_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-util-macros-1.19.3-h7f98852_0.tar.bz2 - sha256: 128591045b700d375de98be76f215a0b67c9d6939523b743edc0dca389cdb4be - md5: b1780cc89cf3949f670d6ca2aa6a7e42 + size: 10290 + timestamp: 1726846345776 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-renderproto-0.11.1-hb9d3cd8_1003.conda + sha256: 54dd934b0e1c942e54759eb13672fd59b7e523fabea6e69a32d5bf483e45b329 + md5: bf90782559bce8447609933a7d45995a depends: - - libgcc-ng >=9.3.0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 license: MIT license_family: MIT purls: [] - size: 52497 - timestamp: 1611584218114 -- kind: conda - name: xorg-xextproto - version: 7.3.0 - build: h0b41bf4_1003 - build_number: 1003 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-xextproto-7.3.0-h0b41bf4_1003.conda - sha256: b8dda3b560e8a7830fe23be1c58cc41f407b2e20ae2f3b6901eb5842ba62b743 - md5: bce9f945da8ad2ae9b1d7165a64d0f87 + size: 11867 + timestamp: 1726802820431 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-util-macros-1.20.2-hb9d3cd8_0.conda + sha256: c45a8af346e129f335f27634da8c89b70e6c380026366901ae9e5e479019ce82 + md5: 7958d1f0a3e1dd6419891e1e8e64614c depends: - - libgcc-ng >=12 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 license: MIT license_family: MIT purls: [] - size: 30270 - timestamp: 1677036833037 -- kind: conda - name: xorg-xf86vidmodeproto - version: 2.3.1 - build: h7f98852_1002 - build_number: 1002 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-xf86vidmodeproto-2.3.1-h7f98852_1002.tar.bz2 - sha256: 43398aeacad5b8753b7a1c12cb6bca36124e0c842330372635879c350c430791 - md5: 3ceea9668625c18f19530de98b15d5b0 + size: 44397 + timestamp: 1731683482561 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-xextproto-7.3.0-hb9d3cd8_1004.conda + sha256: f302a3f6284ee9ad3b39e45251d7ed15167896564dc33e006077a896fd3458a6 + md5: bc4cd53a083b6720d61a1519a1900878 depends: - - libgcc-ng >=9.3.0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 license: MIT license_family: MIT purls: [] - size: 23875 - timestamp: 1620067286978 -- kind: conda - name: xorg-xproto - version: 7.0.31 - build: h7f98852_1007 - build_number: 1007 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xorg-xproto-7.0.31-h7f98852_1007.tar.bz2 - sha256: f197bb742a17c78234c24605ad1fe2d88b1d25f332b75d73e5ba8cf8fbc2a10d - md5: b4a4381d54784606820704f7b5f05a15 + size: 30549 + timestamp: 1726846235301 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-xf86vidmodeproto-2.3.1-hb9d3cd8_1005.conda + sha256: d3189527c5b8e1fea2a2e391012d3e8f794e03bdabe9f4457a0ac4cb8fc7214c + md5: 1c08f67e3406550eef135e17263f8154 depends: - - libgcc-ng >=9.3.0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 license: MIT license_family: MIT purls: [] - size: 74922 - timestamp: 1607291557628 -- kind: conda - name: xz - version: 5.2.6 - build: h166bdaf_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/xz-5.2.6-h166bdaf_0.tar.bz2 - sha256: 03a6d28ded42af8a347345f82f3eebdd6807a08526d47899a42d62d319609162 - md5: 2161070d867d1b1204ea749c8eec4ef0 + size: 26134 + timestamp: 1731320782817 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-xproto-7.0.31-hb9d3cd8_1008.conda + sha256: ea02425c898d6694167952794e9a865e02e14e9c844efb067374f90b9ce8ce33 + md5: a63f5b66876bb1ec734ab4bdc4d11e86 depends: - - libgcc-ng >=12 - license: LGPL-2.1 and GPL-2.0 - purls: [] - size: 418368 - timestamp: 1660346797927 -- kind: conda - name: xz - version: 5.2.6 - build: h57fd34a_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/xz-5.2.6-h57fd34a_0.tar.bz2 - sha256: 59d78af0c3e071021cfe82dc40134c19dab8cdf804324b62940f5c8cd71803ec - md5: 39c6b54e94014701dd157f4f576ed211 - license: LGPL-2.1 and GPL-2.0 - purls: [] - size: 235693 - timestamp: 1660346961024 -- kind: conda - name: yaml - version: 0.2.5 - build: h3422bc3_2 - build_number: 2 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/yaml-0.2.5-h3422bc3_2.tar.bz2 - sha256: 93181a04ba8cfecfdfb162fc958436d868cc37db504c58078eab4c1a3e57fbb7 - md5: 4bb3f014845110883a3c5ee811fd84b4 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 license: MIT license_family: MIT purls: [] - size: 88016 - timestamp: 1641347076660 -- kind: conda - name: yaml - version: 0.2.5 - build: h7f98852_2 - build_number: 2 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/yaml-0.2.5-h7f98852_2.tar.bz2 + size: 73315 + timestamp: 1726845753874 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xz-5.6.3-hbcc6ac9_1.conda + sha256: 9cef529dcff25222427c9d90b9fc376888a59e138794b4336bbcd3331a5eea22 + md5: 62aae173382a8aae284726353c6a6a24 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - liblzma 5.6.3 hb9d3cd8_1 + - liblzma-devel 5.6.3 hb9d3cd8_1 + - xz-gpl-tools 5.6.3 hbcc6ac9_1 + - xz-tools 5.6.3 hb9d3cd8_1 + license: 0BSD AND LGPL-2.1-or-later AND GPL-2.0-or-later + purls: [] + size: 23477 + timestamp: 1733407455801 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/xz-5.6.3-h9a6d368_1.conda + sha256: 84f9405312032638a7c6249573c8f50423c314c8a4d149b34b720caecc0dc83c + md5: 1d79c34d99f1e839a06b4631df091b64 + depends: + - __osx >=11.0 + - liblzma 5.6.3 h39f12f2_1 + - liblzma-devel 5.6.3 h39f12f2_1 + - xz-gpl-tools 5.6.3 h9a6d368_1 + - xz-tools 5.6.3 h39f12f2_1 + license: 0BSD AND LGPL-2.1-or-later AND GPL-2.0-or-later + purls: [] + size: 23692 + timestamp: 1733407556613 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xz-gpl-tools-5.6.3-hbcc6ac9_1.conda + sha256: 4e104b7c75c2f26a96032a1c6cda51430da1dea318c74f9e3568902b2f5030e1 + md5: f529917bab7862aaad6867bf2ea47a99 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - liblzma 5.6.3 hb9d3cd8_1 + license: 0BSD AND LGPL-2.1-or-later AND GPL-2.0-or-later + purls: + - pkg:pypi/xz-gpl-tools + size: 33354 + timestamp: 1733407444641 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/xz-gpl-tools-5.6.3-h9a6d368_1.conda + sha256: 98f71ea5d19c9cf4daed3b26a5102862baf8c63210f039e305f283fe399554b0 + md5: cf05cc17aa7eb2ff843ca5c45d63a324 + depends: + - __osx >=11.0 + - liblzma 5.6.3 h39f12f2_1 + license: 0BSD AND LGPL-2.1-or-later AND GPL-2.0-or-later + purls: + - pkg:pypi/xz-gpl-tools + size: 33402 + timestamp: 1733407540403 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xz-tools-5.6.3-hb9d3cd8_1.conda + sha256: 6e80f838096345c35e8755b827814c083dd0274594006d6f76bff71bc969c3b8 + md5: de3f31a6eed01bc2b8c7dcad07ad9034 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - liblzma 5.6.3 hb9d3cd8_1 + license: 0BSD AND LGPL-2.1-or-later + purls: + - pkg:pypi/xz-tools + size: 90354 + timestamp: 1733407433418 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/xz-tools-5.6.3-h39f12f2_1.conda + sha256: b785955dd3d5eb1b00e3f1b1fbc3a9bf14276b2c0a950d0735a503d9abea7b5d + md5: 0fea5aff7b3a33856288c26326d937f7 + depends: + - __osx >=11.0 + - liblzma 5.6.3 h39f12f2_1 + license: 0BSD AND LGPL-2.1-or-later + purls: + - pkg:pypi/xz-tools + size: 81028 + timestamp: 1733407527563 +- conda: https://conda.anaconda.org/conda-forge/linux-64/yaml-0.2.5-h7f98852_2.tar.bz2 sha256: a4e34c710eeb26945bdbdaba82d3d74f60a78f54a874ec10d373811a5d217535 md5: 4cb3ad778ec2d5a7acbdf254eb1c42ae depends: @@ -17133,110 +16451,100 @@ packages: purls: [] size: 89141 timestamp: 1641346969816 -- kind: conda - name: zeromq - version: 4.3.5 - build: h64debc3_5 - build_number: 5 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/zeromq-4.3.5-h64debc3_5.conda - sha256: b4ba544a04129472651a5df3b8906ed68e7f43bf23e724fd0e368218083c920c - md5: c29dbe9343a0b55b027fa645644c59d9 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/yaml-0.2.5-h3422bc3_2.tar.bz2 + sha256: 93181a04ba8cfecfdfb162fc958436d868cc37db504c58078eab4c1a3e57fbb7 + md5: 4bb3f014845110883a3c5ee811fd84b4 + license: MIT + license_family: MIT + purls: [] + size: 88016 + timestamp: 1641347076660 +- conda: https://conda.anaconda.org/conda-forge/linux-64/yarl-1.18.3-py312h66e93f0_0.conda + sha256: a0d93c3bef723e384cff8a29a82a2c6b7a73b39328088f3a2d97c901f56e9a63 + md5: 91df2efaa08730416bec2a4502309275 depends: - - __osx >=11.0 + - __glibc >=2.17,<3.0.a0 + - idna >=2.0 + - libgcc >=13 + - multidict >=4.0 + - propcache >=0.2.1 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/yarl?source=project-defined-mapping + size: 151393 + timestamp: 1733428897813 +- conda: https://conda.anaconda.org/conda-forge/linux-64/zeromq-4.3.5-h3b0a872_7.conda + sha256: a4dc72c96848f764bb5a5176aa93dd1e9b9e52804137b99daeebba277b31ea10 + md5: 3947a35e916fcc6b9825449affbf4214 + depends: + - __glibc >=2.17,<3.0.a0 - krb5 >=1.21.3,<1.22.0a0 - - libcxx >=17 + - libgcc >=13 - libsodium >=1.0.20,<1.0.21.0a0 + - libstdcxx >=13 license: MPL-2.0 license_family: MOZILLA purls: [] - size: 296355 - timestamp: 1725430145243 -- kind: conda - name: zeromq - version: 4.3.5 - build: ha4adb4c_5 - build_number: 5 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/zeromq-4.3.5-ha4adb4c_5.conda - sha256: dd48adc07fcd029c86fbf82e68d0e4818c7744b768e08139379920b56b582814 - md5: e8372041ebb377237db9d0d24c7b5962 + size: 335400 + timestamp: 1731585026517 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/zeromq-4.3.5-hc1bb282_7.conda + sha256: 9e585569fe2e7d3bea71972cd4b9f06b1a7ab8fa7c5139f92a31cbceecf25a8a + md5: f7e6b65943cb73bce0143737fded08f1 depends: - - __glibc >=2.17,<3.0.a0 + - __osx >=11.0 - krb5 >=1.21.3,<1.22.0a0 - - libgcc >=13 + - libcxx >=18 - libsodium >=1.0.20,<1.0.21.0a0 - - libstdcxx >=13 license: MPL-2.0 license_family: MOZILLA purls: [] - size: 353159 - timestamp: 1725429777124 -- kind: conda - name: zipp - version: 3.20.1 - build: pyhd8ed1ab_0 - subdir: noarch - noarch: python - url: https://conda.anaconda.org/conda-forge/noarch/zipp-3.20.1-pyhd8ed1ab_0.conda - sha256: 30762bd25b6fc8714d5520a223ccf20ad4a6792dc439c54b59bf44b60bf51e72 - md5: 74a4befb4b38897e19a107693e49da20 + size: 281565 + timestamp: 1731585108039 +- conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.21.0-pyhd8ed1ab_1.conda + sha256: 567c04f124525c97a096b65769834b7acb047db24b15a56888a322bf3966c3e1 + md5: 0c3cc595284c5e8f0f9900a9b228a332 depends: - - python >=3.8 + - python >=3.9 license: MIT license_family: MIT purls: - pkg:pypi/zipp?source=project-defined-mapping - size: 21110 - timestamp: 1724731063145 -- kind: conda - name: zlib - version: 1.3.1 - build: h4ab18f5_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/zlib-1.3.1-h4ab18f5_1.conda - sha256: cee16ab07a11303de721915f0a269e8c7a54a5c834aa52f74b1cc3a59000ade8 - md5: 9653f1bf3766164d0e65fa723cabbc54 + size: 21809 + timestamp: 1732827613585 +- conda: https://conda.anaconda.org/conda-forge/linux-64/zlib-1.3.1-hb9d3cd8_2.conda + sha256: 5d7c0e5f0005f74112a34a7425179f4eb6e73c92f5d109e6af4ddeca407c92ab + md5: c9f075ab2f33b3bbee9e62d4ad0a6cd8 depends: - - libgcc-ng >=12 - - libzlib 1.3.1 h4ab18f5_1 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libzlib 1.3.1 hb9d3cd8_2 license: Zlib license_family: Other purls: [] - size: 93004 - timestamp: 1716874213487 -- kind: conda - name: zlib - version: 1.3.1 - build: hfb2fe0b_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/zlib-1.3.1-hfb2fe0b_1.conda - sha256: 87360c2dc662916aac37cf01e53324b4f4f78db6f399220818076752b093ede5 - md5: f27e021db7862b6ddbc1d3578f10d883 + size: 92286 + timestamp: 1727963153079 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/zlib-1.3.1-h8359307_2.conda + sha256: 58f8860756680a4831c1bf4f294e2354d187f2e999791d53b1941834c4b37430 + md5: e3170d898ca6cb48f1bb567afb92f775 depends: - __osx >=11.0 - - libzlib 1.3.1 hfb2fe0b_1 + - libzlib 1.3.1 h8359307_2 license: Zlib license_family: Other purls: [] - size: 78260 - timestamp: 1716874280334 -- kind: conda - name: zstandard - version: 0.23.0 - build: py312h15fbf35_1 - build_number: 1 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/zstandard-0.23.0-py312h15fbf35_1.conda - sha256: d00ca25c1e28fd31199b26a94f8c96574475704a825d244d7a6351ad3745eeeb - md5: a4cde595509a7ad9c13b1a3809bcfe51 + size: 77606 + timestamp: 1727963209370 +- conda: https://conda.anaconda.org/conda-forge/linux-64/zstandard-0.23.0-py312hef9b889_1.conda + sha256: b97015e146437283f2213ff0e95abdc8e2480150634d81fbae6b96ee09f5e50b + md5: 8b7069e9792ee4e5b4919a7a306d2e67 depends: - - __osx >=11.0 + - __glibc >=2.17,<3.0.a0 - cffi >=1.11 + - libgcc >=13 - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 - zstd >=1.5.6,<1.5.7.0a0 - zstd >=1.5.6,<1.6.0a0 @@ -17244,22 +16552,16 @@ packages: license_family: BSD purls: - pkg:pypi/zstandard?source=project-defined-mapping - size: 330788 - timestamp: 1725305806565 -- kind: conda - name: zstandard - version: 0.23.0 - build: py312hef9b889_1 - build_number: 1 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/zstandard-0.23.0-py312hef9b889_1.conda - sha256: b97015e146437283f2213ff0e95abdc8e2480150634d81fbae6b96ee09f5e50b - md5: 8b7069e9792ee4e5b4919a7a306d2e67 + size: 419552 + timestamp: 1725305670210 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstandard-0.23.0-py312h15fbf35_1.conda + sha256: d00ca25c1e28fd31199b26a94f8c96574475704a825d244d7a6351ad3745eeeb + md5: a4cde595509a7ad9c13b1a3809bcfe51 depends: - - __glibc >=2.17,<3.0.a0 + - __osx >=11.0 - cffi >=1.11 - - libgcc >=13 - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 - zstd >=1.5.6,<1.5.7.0a0 - zstd >=1.5.6,<1.6.0a0 @@ -17267,14 +16569,9 @@ packages: license_family: BSD purls: - pkg:pypi/zstandard?source=project-defined-mapping - size: 419552 - timestamp: 1725305670210 -- kind: conda - name: zstd - version: 1.5.6 - build: ha6fb4c9_0 - subdir: linux-64 - url: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.6-ha6fb4c9_0.conda + size: 330788 + timestamp: 1725305806565 +- conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.6-ha6fb4c9_0.conda sha256: c558b9cc01d9c1444031bd1ce4b9cff86f9085765f17627a6cd85fc623c8a02b md5: 4d056880988120e29d75bfff282e0f45 depends: @@ -17286,12 +16583,7 @@ packages: purls: [] size: 554846 timestamp: 1714722996770 -- kind: conda - name: zstd - version: 1.5.6 - build: hb46c0d2_0 - subdir: osx-arm64 - url: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.6-hb46c0d2_0.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.6-hb46c0d2_0.conda sha256: 2d4fd1ff7ee79cd954ca8e81abf11d9d49954dd1fef80f27289e2402ae9c2e09 md5: d96942c06c3e84bfcc5efb038724a7fd depends: diff --git a/playground.ipynb b/playground.ipynb new file mode 100644 index 00000000..1ca74bb5 --- /dev/null +++ b/playground.ipynb @@ -0,0 +1,1771 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import io\n", + "from PIL import Image\n", + "import numpy as np\n", + "import h5py\n", + "import matplotlib.pyplot as plt\n", + "from functools import reduce\n", + "# import jax" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def get_mask_area(seg_img, colors):\n", + " arrs = []\n", + " for color in colors:\n", + " arr = seg_img == color\n", + " arr = arr.min(-1).astype(\"float32\")\n", + " arr = arr.reshape((arr.shape[-1], arr.shape[-1])).astype(bool)\n", + " arrs.append(arr)\n", + " return reduce(np.logical_or, arrs)\n", + "\n", + "\n", + "def load_trial(hdf5_file_path, FINAL_T):\n", + " flow_arr = []\n", + " depth_arr = []\n", + " image_arr = []\n", + " seg_arr = []\n", + " with h5py.File(hdf5_file_path, \"r\") as f:\n", + " # extract depth info\n", + " for frame in f[\"frames\"].keys():\n", + " if int(frame) >= FINAL_T:\n", + " break\n", + " flow = np.array(f[\"frames\"][frame][\"images\"][\"_flow_cam0\"])\n", + " flow_arr.append(flow)\n", + " depth = np.array(f[\"frames\"][frame][\"images\"][\"_depth_cam0\"])\n", + " depth_arr.append(depth)\n", + " image = np.array(\n", + " Image.open(io.BytesIO(f[\"frames\"][frame][\"images\"][\"_img_cam0\"][:]))\n", + " )\n", + " image_arr.append(image)\n", + " im_seg = np.array(\n", + " Image.open(io.BytesIO(f[\"frames\"][frame][\"images\"][\"_id_cam0\"][:]))\n", + " )\n", + " seg_arr.append(im_seg)\n", + " # flow_arr = np.asarray(flow_arr)\n", + " depth_arr = np.asarray(depth_arr)\n", + " image_arr = np.asarray(image_arr) / 255\n", + " seg_arr = np.asarray(seg_arr)\n", + "\n", + " # extract object info\n", + " object_ids = np.array(f[\"static\"][\"object_ids\"])\n", + " object_segmentation_colors = np.array(\n", + " f[\"static\"][\"object_segmentation_colors\"]\n", + " )\n", + " assert len(object_ids) == len(object_segmentation_colors)\n", + "\n", + " distractors = (\n", + " np.array(f[\"static\"][\"distractors\"])\n", + " if np.array(f[\"static\"][\"distractors\"]).size != 0\n", + " else []\n", + " )\n", + " occluders = (\n", + " np.array(f[\"static\"][\"occluders\"])\n", + " if np.array(f[\"static\"][\"occluders\"]).size != 0\n", + " else []\n", + " )\n", + " distractors_occluders = np.concatenate([distractors, occluders])\n", + " if len(distractors_occluders):\n", + " object_ids = object_ids[: -len(distractors_occluders)]\n", + " object_segmentation_colors = object_segmentation_colors[\n", + " : -len(distractors_occluders)\n", + " ]\n", + " rgbds = np.concatenate(\n", + " [image_arr, np.reshape(depth_arr, depth_arr.shape + (1,))], axis=-1\n", + " )\n", + " return (\n", + " rgbds,\n", + " flow_arr,\n", + " seg_arr,\n", + " sorted(object_ids),\n", + " object_segmentation_colors,\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# rgbds[0].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# flow_arr[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# plt.imshow(flow_arr[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "hdf5_file_path = \"/home/haoliangwang/data/physion_hdf5/dominoes_all_movies/pilot_dominoes_0mid_d3chairs_o1plants_tdwroom_0001.hdf5\"\n", + "# hdf5_file_path = \"/home/haoliangwang/data/physion_hdf5/collide_all_movies/pilot_it2_collision_assorted_targets_box_0003.hdf5\"\n", + "rgbds, flow_arr, seg_arr, object_ids, object_segmentation_colors = load_trial(hdf5_file_path, 45)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# im_height = im_width = 150\n", + "# rgbds_resized = jax.image.resize(\n", + "# rgbds,\n", + "# (rgbds.shape[0], im_height, im_width, *rgbds.shape[3:]),\n", + "# method=\"linear\",\n", + "# )" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [-0.7372549019607844..0.7098039215686275].\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "t1 = 14\n", + "t2 = 15\n", + "\n", + "plt.imshow(rgbds[t2][...,:3] - rgbds[t1][...,:3])\n", + "# plt.imshow(rgbds[t2] - rgbds[t1])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "10\n", + "11\n", + "12\n", + "13\n", + "14\n", + "15\n", + "Object 3: -355.01615909454915\n", + "16\n", + "Object 3: -313.33152265221486\n", + "17\n", + "Object 3: -109.89374107753508\n", + "18\n", + "Object 2: -104.60095705986025\n", + "Object 3: 111.66126185024495\n", + "19\n", + "Object 2: -116.9554151983822\n", + "Object 3: 230.26728301048297\n", + "20\n", + "Object 2: -121.29666667826035\n", + "Object 3: 373.12218206630047\n", + "21\n", + "Object 2: -118.43038267902301\n", + "Object 3: 548.9409371319939\n", + "22\n", + "Object 2: -122.51209465195151\n", + "Object 3: 776.4019857425317\n", + "23\n", + "Object 2: -111.1570907265532\n", + "Object 3: 962.5086129581227\n", + "24\n", + "Object 2: -119.2036718938865\n", + "Object 3: 1113.034181359235\n", + "25\n", + "Object 2: -107.74143094829485\n", + "Object 3: 1221.503131090426\n", + "26\n", + "Object 2: -101.37659814778496\n", + "Object 3: 1409.5563994239355\n", + "27\n", + "Object 2: -100.06543566666397\n", + "Object 3: 1607.590265683567\n", + "28\n", + "Object 2: -107.25967102798761\n", + "Object 3: 1845.267572880726\n", + "29\n", + "Object 3: 2054.2142579462015\n", + "30\n", + "Object 2: -122.81764047005596\n", + "Object 3: 2168.249905906004\n", + "31\n", + "Object 2: -132.8718691956763\n", + "Object 3: 2450.5729126285105\n", + "32\n", + "Object 2: -119.63582028407676\n", + "Object 3: 2889.2921280945047\n", + "33\n", + "Object 2: -111.42183799650155\n", + "Object 3: 3305.5803870257205\n", + "34\n", + "Object 2: -104.62770393689473\n", + "Object 3: 3351.8587952913026\n", + "35\n", + "Object 3: 3410.9887062577645\n", + "36\n", + "Object 3: 3151.9062840143843\n", + "37\n", + "Object 3: 2469.9414661940405\n", + "38\n", + "Object 3: 1392.9987489129985\n", + "39\n", + "Object 3: 197.87527686848358\n", + "40\n", + "Object 3: -788.3296980222067\n", + "41\n", + "Object 3: -1184.9164162317913\n", + "42\n", + "Object 3: -1015.6375992008284\n", + "43\n", + "Object 2: -130.63072033395954\n", + "Object 3: -842.0996339236988\n", + "44\n", + "Object 3: -778.6210057660646\n" + ] + } + ], + "source": [ + "for t2 in range(1, 45):\n", + " print(t2)\n", + " t1 = t2-1\n", + " seg1 = seg_arr[t1]\n", + " seg2 = seg_arr[t2]\n", + " diff = rgbds[t2] - rgbds[t1]\n", + " # diff = rgbds[t2][...,:3] - rgbds[t1][...,:3]\n", + " for i, (o_id, color) in enumerate(zip(object_ids, object_segmentation_colors)):\n", + " mask1 = get_mask_area(seg1, [color])\n", + " area1 = diff[mask1]\n", + " diff_area1 = np.sum(area1)\n", + " mask2 = get_mask_area(seg2, [color])\n", + " area2 = diff[mask2]\n", + " diff_area2 = np.sum(area2)\n", + " if np.abs(diff_area1 + diff_area2) > 100.0:\n", + " print(f\"Object {o_id}: {diff_area2 + diff_area1}\")\n", + "\n", + " # fig = plt.figure(figsize=[10, 5])\n", + " # ax = fig.add_subplot(121)\n", + " # ax.imshow(area1)\n", + " # ax = fig.add_subplot(122)\n", + " # ax.imshow(area2)\n", + " # fig.suptitle(f'{diff_area2 + diff_area1}')\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Object 1: -1.9921568627451067\n", + "Object 2: -16.4392156862745\n", + "Object 3: -355.01615909454915\n" + ] + } + ], + "source": [ + "t1 = 14\n", + "t2 = 15\n", + "seg1 = seg_arr[t1]\n", + "seg2 = seg_arr[t2]\n", + "diff = rgbds[t2] - rgbds[t1]\n", + "# diff = rgbds[t2][...,:3] - rgbds[t1][...,:3]\n", + "for i, (o_id, color) in enumerate(zip(object_ids, object_segmentation_colors)):\n", + " mask1 = get_mask_area(seg1, [color])\n", + " area1 = diff[mask1]\n", + " diff_area1 = np.sum(area1)\n", + " mask2 = get_mask_area(seg2, [color])\n", + " area2 = diff[mask2]\n", + " diff_area2 = np.sum(area2)\n", + " print(f\"Object {o_id}: {diff_area2 + diff_area1}\")\n", + "\n", + " # fig = plt.figure(figsize=[10, 5])\n", + " # ax = fig.add_subplot(121)\n", + " # ax.imshow(area1)\n", + " # ax = fig.add_subplot(122)\n", + " # ax.imshow(area2)\n", + " # fig.suptitle(f'{diff_area2 + diff_area1}')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbwAAAGiCAYAAACcbHM0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9S49t65rXif3e+7jMOSNirbX32XlIIEG4ZCxklUkkRIOehUQLaNGia6GUGyhbYCRL0MlvABLfgC9AJ3tGQqoGomRbwgVkGc4lz9mXteIy57i892o8Y8UpnGULim04nIy3t2JFxJwx5hjv8z7/539RvffO23pbb+ttva239Su+9H/pN/C23tbbeltv623951hvBe9tva239bbe1h+K9Vbw3tbbeltv6239oVhvBe9tva239bbe1h+K9Vbw3tbbeltv6239oVhvBe9tva239bbe1h+K9Vbw3tbbeltv6239oVhvBe9tva239bbe1h+K9Vbw3tbbeltv6239oVhvBe9tva239bbe1h+K9Utf8P7BP/gH/Ik/8ScYhoHf/M3f5J/+03/6X/otva239bbe1tv6r3D9Uhe8f/yP/zF/62/9Lf7u3/27/It/8S/4i3/xL/KX//Jf5kc/+tF/6bf2tt7W23pbb+u/sqV+mc2j//yf//P82T/7Z/mH//Afvn7tT//pP81f/at/ld/5nd/5L/jO3tbbeltv623917bsf+k38P9tpZT45//8n/O3//bf/ve+/pf+0l/in/2zf/YHvj/GSIzx9d+tNT59+sT79+9RSv3//f2+rbf1tt7W2/p+V++d6/XKD3/4Q7T+Twckf2kL3nfffUetlR/84Af/3td/8IMf8POf//wPfP/v/M7v8Pf+3t/7z/X23tbbeltv6239Z1o//vGP+fVf//X/5N/zS1vwPq//z+6s9/6/2LH9nb/zd/jt3/7t138/Pz/zx/7YH+P/+Nf/T2hlKLVijMUYjdGa2jo5JcI4klMEpWmto7QGOlpBmCbW24K3hl4L1jpSytgQoFV5H9qyrgtGW4I35JyotRKGkRSjvJ6zlJyppTN4T+udmCJog3cOaxR7zJTa8N6DUhgDORWU1YzBk7bMOHpybmgjKHQpFWMtrTZqzYzDhNawrBu9dTodbR29F1RraGOJe8Eag3GadY9YbWm9Ya2j9Y7qHW8NSmv2uHG5O/PyslBKwWqDs5bWKmEMxJSppUGvDNMEaGiVmDN7ioQQMHT2bSP4AesttXY6GnpF0Si50lAYY6A3rPOUWmitAx1FB6VRysj9QAetCYNnX1asMbRWUdrQamMYRnLa0NqSG7RaaL0xOkuulVoLvXW2beUzmB/3HWMMWhtaa/K3eo/Vcp9tW8Q6h1LQOygF7bjPjDG0VBjGQE4FYxXaGkouoBRaKVotWOtRCmJMKKArUErTWsZoQ20AGkXDOsueEgqNVorPUwd13P/DOLKuN4YhkHMl54xzHq1Aa402iloatVY4Xsd7T6uV2iqxFHwIqFKP66tQSvHz3/t/sD5/w2me5XUe/gjzh1/HOkctBW0sxlk+/ewnXH/2/2IIgfd/8v/A09c/Ij1/zen9Dzh99af4+b/87zAaLl/9SeaHH1JqpbXKME68fP0jrl//HtZZuY4N3v/Gf0s3Xj6rVgGw1lFrpVV5XW0MpRToYJ2ltwZKkWLEjyN0iNuG9V6ulZYPq9eONRqlFK1XjJPnxVor16NUnJfXKjmjtaEfnzM9Y4yjlI7WllYi2loqnZwy1miafHBYY7Fa8dWH95zmgXd3dwTvMcqgUJSWsdbRW0Vr83rNtda0zzdil/1HKWj12F9QaKMxxh7Pg6L3Ru9d3mvvaK3l51Borcg5o5Q67td+3Iea1tvxM43WGsYYemsordDaUkv+xb2mNK1WrHN0+i/23dZpvaONxhlHh3/v/SgFdKitoJV5fR8oRa0Fo82xx8rf1Zu8F3lN+btBobTCWMu6rvxf/y//Z87n83940fj/sX5pC96HDx8wxvyBbu6bb775A10fQAiBEMIf+LqxnnEcqRVaBzQMzkKvMI3UJt9jfaC0QlwW5mmitU4plcv5ctwglbjvDOOIto7aGuM8sa4rl/t7Su2gGtZ4dGsYa3mYZnyw3LYd5ydySoDCWovxHpSm1k6YR7Sv7Lcb83yiK0OtBa0SxhqGIaCIxFxww0CtmcEYeosYY/HeAPL7cy4Y65nmE9u6oJyjtUbLBYUiDAbvAyln7u5GSikYbdm3FY1s1tPdiVYbYRiZRk/cG+Nk0apijSOmTK4V6zyn+xMlZqyz5BjR1oF2TKcLJWdyzpzOAWM0pVbC6Imp4MOI7p3WKqVWFBqM5TQN1CTQdM4ZlKErhfED+7Zi6HjvyKXipxP2KCglZ4zRdMBPZ6y1uN6J24r1QR5eKio1rPeM5zu8UWz7xrrtlFRIe8T5ARsUJUW0HSglc3l4z77u0AthmlDa0FshxZVpGumhU0tFO4cJnn5snEpLIW/GYKyX3V1llLaE4EkpYcNIbwVTKr2D0RrnR3JpjPNM3HZACrdSmhA80zSCUgTvCaERY5KCdhzCcsk01XHDSBhHaI2SM845dO10lXEuYDyktOOMFJC837DWygaoDKeHDxjn0MailMGFgNWa0WsWpRimM+N84VNasdYynD+Q1xuKjvcDdn6HH0batmCMI+0bvco9a62VDd56VJjQSlF7xZgB6zy0ivPQaPQOrTS8C6Cg1ErvimEYMcbT6PTWcX6Qg9excbaaGM8zNWd6h9KqFEtd5b63DuccpVXG+UwtmXXdAHDeU6ul0dHuOGxUI8+u0tAVzntyyq97TemNb1+uPO4b//Zn3/D+4R1z8Ly/u2MIHmst2nj6cVrSWslnDhjnjs8PKYbyirTSsN7hjgOp1kYKeW90OkoJzKe0otWKVhpr3S+KpdZy8NWKWuovNsbjICQFrJJzYgiT/J7WqKVgfDgKpvx+paRAfT4c9uN9KK1xVoqf1lqKn5LXK8chxloLeoDe5No5h9ZS9GuVfUAbORzUWqi1oBRYcxx0v6ex1C9twfPe85u/+Zv87u/+Ln/tr/2116//7u/+Ln/lr/yV//DfEyZK6SjdMQpKTmSlqKVgdQcjJ3NtKqd5gly4XRfG84V93bCqk/bI+y8/sBhLTIW2b0zzhFEwWktMFWsMWluUqazLhrWa1jV7LNyerrgwoo6uMaeE1g4XLK1kSkpo4zjd3VHSJt1OrUzTRC6VLSY0nXGWnx3DwLZtjKcTIJ2qM56UKtMU6MbSkAew7ZFWCuM0UUvGWi9dpDYoOr0VrJGuYBpHWqncbjvOOZyGPRXm00xKiVwVXUmH1VvDaE9cV5TSx/8ZnPegi9zQSsvDYQwlpePmVQRvMcZSu6aUKA9zq/TWefr0iPMeY6VbDsNMzJ3aIpe7C8vLlX1LdGVAy/tppRJCQGnFuiVs7/RemOYzqldqbtIBaei2U1uB2nHWM7yb6B8/ci0b4+mM0pqSC9bJidYehyPjDMYE6JVeKqVkjPEYE1j2K1ortLRgcoJVyOneaIxGTs9NobXBOoMyFuugtkqOGXO8Vs4Z12EcJwYfyHHHO0tOnVwLGliWla4MOVdCcK/oROkdOqAMzjnojVoqvVZqlW5fm8Y4OYzWshG5AaUU2+1bat7lOiqFsZ7h/J7SNb3KoSjFRNGap29/XzY2bUj7RokrwXuGyxfcvv0Jxmi0DSjt2WPC+4FtXQiD5+n2iDbHLEbBdP/h6FwV43Sm10ZtDeiCmthAo7PWjZQrPgSCG8lpP7q+irMWnCbFiDWWlCN0SKngfKehqK3QW6UU2ZB9CJSU6MZhvSfnQtq31y7MWovWmlIbKMj7jlJQSkFpwziMaK1xRu5TRacUQQ5GNZNK5eefHnFa8fvffYe1nvvzzMPlxN08Mw5yaGm1YoyhlixdVe9474/ut6GcXKsY5e9NKUr7qZEOiqODQopH0x1zdHxaK0rOgKK117YVY91rYWo0ekGex1bQGIZhoBzPY2+N1ttrwXE+yD2G3OctF3prxCrFVCm596UDB4XC+0BtFQ3SrWvpLEtt0rHSMQcqopR0sMYYjLWEz1DK97R+aQsewG//9m/zN/7G3+DP/bk/x1/4C3+Bf/SP/hE/+tGP+Jt/82/+B/+OFFfGaSanAgru3z+wXW883N3x/HzDOEVzilwSj58iHz68x7kbKWdO8ygdxzSw7onawIcRuqfVjlYC8aWUBKrTDm08xgykmGgpYa3jdDkzDgKd9p4YvMU6R0yR3jpDGLjdFqwPuGGixIixltIquVR6SWBkI04x4d0AGNY9S7HA0K1hnEeMt+SSWdYd5+TByVHRWmceBlrrLMsCWmFdwPmJUivDNAv04QOThpwiuRtUqaR9OaAIhbOW0jrBB3qrxKwwSrGvN+bThVY7zlm07jhrMAqM01g7ojpoJc9Lygm6YgyG2jq9NnoTOM8PDtU74/lC3AvOQOuN50+fcM4TxpFWM7V1Sq3M8yQnTWM5WYH5nFXELeKdRzspBNc1op3F+MD6cqXVFTaFCwP3znOaTlyfnmjekouV99UbNSemMLBuG0pprHMEramtUUqid4EQnTXHRpsIYZSNUFmMNlKEBkuPEMaRVAtVdVKKhHEg75GKxjmLMYp9S1xzAm0pVUlXaD1+GMi5HBuxYtkiHQR+bQItWT8And4V1Eajo4wmbgvWOZz19A42BHTOKKCVhFJy8oaODSNKa4zS1K5wwVK2Sk0bNW04Y5guH1ifv4EucHnviv36USA2N+BDoLbGum4YrVmfP5Hjhvf2KMwKbSfGcSbHHaMU+YDPtLFsMaL3SFdHZ0MTiDhHtJKu1zmLsoaWE94ZoB+djmKeZlQvGK3pTZNbw+qGGwZSSqANXWlyjMd9N0mHnOJxDTwtF1Lcacg9X6ps3L3JdS2lCvCuNN5ZtrrirBz2UmmUJoeaZV9YYuLHP/saazSDt3z11Q/5wf0dg7cowAcpJjHuWGvprXOgiAfUq+it4f1Ap0kn1Ls8m5+hxJxozaAA5yzt6MJAuiSFPNu11gPKNGilURhy2ummcbsljLFS5JSmtYbWGqNlfKCVPro5eXYEGi4HRN9AdegKo410sQds3mqFBlXVA7LV8nyVgrGWYRgQONPSWiPuGzmm76eYHOuXuuD99b/+1/n48SN//+//fX72s5/xZ/7Mn+Gf/JN/wh//43/8P/h3GG3JuTGdZlrJBBfoQ6UpBc7QmnQjwViMMez7jrKG8zwQ10VgJ+/RNZFTZDp50h65nM7kXEFptj1yupzQ1tJKRRlDU11mcs7RamHZE9MYKDlyu10ZhpGYC8MwcDtOv+t6RfURtAGt0cZgXcf4kXmcUAoeu8yBugLnHL02tPFcX24459luKz4EBucZh8DL9SYwT+sY58h7YppnesnEXMi1yGywdfZt53w6H3Mv6WScUZzmmW1bUV1OjZMPlCxdTykCWXjvqbninDyhy7pj/SDvaVkJwXO73ZhOM1ZrvDlwIqT49dYw1smGojTzPLJeF/zg2faIMWBMwDhH7zCEWbrC3mmtHIXIstwWaqkoPdHKjnOaUhU5F+gFGigMwzjJ7E4pam2MQyDmHTuOeG9Zb1eW24pShlwEBtTWQm+kHAnO0jr02nBOTsfWOYzSDOcz19uK84FcCsYrWoNcAWNZbisosM4x+JF5mlkaoA+UQGtcCECn5ITWllgag7WscaeUxjjO0DLUjnUGasEZQ6kNo6DWyjDMqA61F7Z1lXldr+RyQK65k1PEuoHt+gRwbJwK40eZo+VMGMIxi8y0vNNrQTnPcHlP/OZHGG1ww5kSN7blGW8tw92HA7oENQzknEjLJ4zRx0bXUdpgpweW5UYIHnojxyjwXpVZeU2ZmisY2bS15pgbaayVjriuEW1kkyx1wxiZz5XWCN6yLtsBzWrpguOO1RbrjBRjF8ipoVQXWM0FKooSM7VkvPM0ZZhPJ+K+yWhEgepHN2WMzDitHHhjznSgqY7VDmc1ddsEgjSK2hovt439J7/Pv/3xjxmHkfvTifd3Z+5PJ5y3r/O9o33DWgdaDiS/mJlZ1NG19dbpqmOsFM9SCrVJUdFKvXZV2krn74xs/Z8LjjYGF4bXmR4KSpJiY53MRVurAjmqJqhOKQfUqdBGxjAdOVw6a48CWKk5HQcWUBqUMvL3IJ395/ljTEehbTL71kp/7wz7X+qCB/Bbv/Vb/NZv/db/6p8/nS9sKctA31hut5UheHKtaN1BO2KqjMaS447ShtuycioB70e2baO2BF06Fmc1fp7ZYyS3jreWhw/vqFWw7n6caLSxTM4wDoFt3QSO2HdSLlzu3xFTRGsFSjHPMykVlPLk2uktEQYncIB1WB9ItbItC0obpsmy7xtpW5nmM1prstb0VqFWBmdkZlkrVityyq+YuXMGo6E5h6Zx8o6moOfIOARaK+wxczqd6CXhjCa3LtCedsSYqbmw7xutK6bTLId1Osuys68bp7sLxjq8N+R9I9eEaobz3Z3MB1qjtU7OEW09tTXu7h/IuUHecdaxx4K2luk0o51j2xZ675Ta0XRqSZRSybVxGhy5dJZFin0i0UvkNJ9QdJpSpKbxJmCdoSspKq0fc7PeSbkyDp5SOr3BPE2vA3bjhMzSaqe3Ktdol/feSsE5gRC7MmAs5ThR11oJVlFrIufM6D10xd4jznpyFGJPShFnLfu+gwtk2lGcOiF4OpqKQFLOWGra5SRPp3VwytAPSFVrQ04R4wK1VnLaX0/ofhjJpcqGmDN5r4RxpLZKiovASMbQWuf07tcELnSOUhtpXwnjzPPLt4CQH1o3rM8fUQpMGHFWSEbWe4yfhKjQKro3FLAvT69dRqdjhxPmKFogXdw0n2has748MgwD3XpyzpQccXYg5ULvHWctOR8zqyFQc0ZpRakFpR29QXCGbduBo+MwRyekFa1r3DAz28DtegWOYtoLJVesC8d8TKGUoetGjFE2+CpkK2MdzlsZj1iL0Z1xCOTWUK3irWVbV7r3aOsO8pKl1ITznlIKvRfSrZIa/PjrrwnOMo8jX75/4N3lzBgGhhAEETk+X0C6reP+Va/FQeDPjiBR0tl1epcuk95pKaKUohSZa36GDj8TX7oS0ozSCjNKl/mZSKS0dI7teAZQil7b62cn11Af90an13y8t1/8H1rJzx+HBZB9SmuBZ+W2b3SjsS7IM/E9rl/6gvefukrJOGsYx4GUKreXhVTkVOR9kIE8Cd1lU1fWcmZEGYP3nstp4rvvPnI6zWwpk5OQI2qH0yxFQZh9Ge8njHNQChUwbqA02QCWZcFpRRgG9pgP5lk7yCnStZwud9SaqTkxDiPX2xU6jDRaV9J5TiNx2+lorBNMXwNfvL/n+emZpDrOyExn2VaCD3jrqbVRShUIRmtyyZhjYN87jPNIP264UAs0YU8mOkoJq61k6YZbb1gfMNZRO+R9YxoHgWaCR2mFVVo25VoYvUcr6SZSKgRvCZNcq5QjD5eZ2gTWCCrQUHhvSEnz9HijtIJGMZ4m9j3JyRqNPqDTUuRkez6dhMCy7ZzOZ2IV6KQdf+P5cuHlegVdcS4wz2dKKcRtRVmP9SOdSE5Z4LIQZBZlhSiUUiTtkfMwsu4yJ2otC9OuNlK6wTAIgWMI5NoYx4F1WQ+m7YoLgWkcMQqWWFDdoJWjqs44jeRc8WGglUKrhd41tSaBg6097iuLtcemoqDmIrPH3vBjILaCMYpteWYYJ0ru1NboXQgJTimUVSg/HJ1AIS0vsiF12diMG45TfEX1xnQ6k1JkefoWrTXD6eHoACPeWeb7L9hePgp8i8KHSQ5iOaN0p9dCun4S2PUgF42nB8ZxJK0r7nwipkLvlX3fsdYT/MDtdgM64zTRMeS4y/zUD2ilSCmSU0X1jrYG7+ZX5mSuxzOuNDELGqB6wypNq5nr8yPDOBKCFVaw1gzWsNUNWqErjXMe6DhtyNvK6e5M6gKfGmvYYxIiG50UE0YbTG80ZbDGMkzj65xOa4Qh6sKxyYMLE2nfKTlS0g5NmInfPj4xjBOjM7y7nHi4O3OeZ4J1GGulgCGzNyGxdFRrVPor6URGbUJsMdqgraE3DhKJf2Ve9tZIdZeCdxRBapcuTEl32T/DqkrIK1IUpWBpdRw0jtfpx2FNa/3a5Qkz9ZiBKnWwis0r8aZ36Rrr0TV+Loq9/yHr8P5T19PTEx9+8BWfHq+M80AIAmt4Z9AoeinM00CMhdoytjfCEOh0trhxve2czhess+iSyakew35PaYXeMlrLIHZbN6YhCGyRMvSN1jrjODBOE/SOVRrnFbkWhsnTumGLO3mLIhfQHWUNxmqGMJKLMB2t9UzDTG+V3CqxZIZ5gpzpDT49PjEMARcG1k0G4P4gg6R1EchHIafRcaLlzGdspqYoA3Lt0EoJoUUpwijD5rxuuBAEygB67VzOZ/Z1wTuHGmZSKZTaCabSS6a0gurCwLLugGipKNUxxpD3SIw7tUHxA70mlO5crwvjaSIe2L3SYA76cy4FjSZ4Q2sKRcV7Yc611kgloVQnTAPGWYKB5ZZkLgbsOb/OFvd9w9hBNvNJOuhlXWi1ErwjgczwUsZqxfly5vml8eH9A8/PN1Tcscbyea4yDAPGaJmvHTMJOX7LQ906KKuBRkmFShcGJQdLrWtS2gWCuz4D+pixKEppMrurhVIqikopx4nbOLoqcqpGU5tCGQOtMc0XSpVNapxmaAWDMCNrqVJUS6GnGyXtjEM4rrk9oK9KihvOeloTckJLG1op3HRPXB/ptWLGCX+657sf/2u0Uejxjm7k+dBGC8Rckszd+GzspBguH1AKpvMJdUhTeofBB4y1pKNr0zRoMidyLmC1QvVC7QIPisRArmNv5WA7apxzxH0TgkhOIlFwco/b4Elpl/lcE6YhXZFqw4VAzolGQwDwjtGK7oS4o7QGbUixyIE3G2IuMr9yUvC7aihrqSnJobI0YTIeTERthXafSkb7gOrCylXaCUxbpDu6bRvPtxs/+uYjzhhOQ+CLh3t+8MUHLqeTHJi1fpVZ0EELbii+kfooikix0UpGJUqpA7UQ2U7vgpxopelNPqNaG73Xg90pe4XW5mBTii9la41+dMJo9YtCfMgflFJHwRQCjDUHulIFWhcmsz2KXgXdBbJuQmTR9q3g/Uctqy0axTBO1CJ6sxp3gg0453n8+AhaU2g4rWk5s5eNcZpxWmPCREyJdVkoDaZpJu4bHUVFUZumpwI0jO7U3lEcJ8MuN8lyvaK1IYwBPzpUV+iiGb3j+bbitOP8fjjgAyg0np9fCPOJaRypOVNzBjIpN1CWcfLCvusKqzvOeJEtOHcMsuXhVhpqlyF8KZ27hwesEpAMIOeGG0bQFuMcy/VKCAJ/7osUOrQRokmKBDqqIzMq5zDOY3qS+Z33QnGumVY6YRgJzjMGebALihA827bjncMPA9u6kqJg/LrD6Xxmud4YxwHjg3QyJbHtK/N8oVeZNTal8UOg5kTaoxBvxoGSPkNbcsrNtcrsjc627dgQ2IuQjCAJ/T2cSGskDIHSO6U0gciMpVuYTwNaKwYfsEoRvOPDhw84o0kpkWJijTu5VOkSxplWM95rtn3DOvlsUEo0h86RtpXBhUOD1OgojHdgDcHKxsrBpPRB5rFpl+6sN43ShnroqnKKYMAohW6NimFLifPsSfuKc5YSd5SxoESLCoqSO8o5lqvAfuaggLvxBEqYuy4EepPupWwLJa4MQ0D7ge35o0BWbuD29ELeF4xSzPdfYI2m1ozRMJ5nvv3xTwWSde6Y31lyU1CKdEp5I4QJazxLX9liJBxMxQboXhC2YSanxHw+EVOGAxqrpdJax1jZYD/DzK1khuAptZJyxppDh3bAaGiou2hMrRV6fa0NqzztkNXghNVY+8EIHhytdTqNMM0iR9KWXkViY62DLOzRYjTBi8awt441htoBFHHb0FoTvBxsU0o4V9EHyUh10d0JKUWTWufjdeHrT0/8m5/8PpfTxBw8v/bll5znSRi2n0k/SqOMzEpzSpiDBFNVxQD1M/NSaeyhC9TGQOtCaFEI6UqLXk4hOj66IDXGWjnItSbFHdHKKi260ZwTzoXXrrDVdtxfn0lBsloVtO2zyFUfutrPmthev1/ny1/5gjefZfMpRXQrw2lGa8uWInGPhGmg98Y8BB6fnni4XDBNTh/WONKeqLUwjgHdQRlNaQ1yoUchKnTVUcpymkb2nDmNM4/Pn7jMMy/XG95rvAvclkXYelqhVUcZwzRNxJy47onRy8Bba4P3IlloXZFSkcGxNmjXmQcZELeqaQekkXMSNprSaC2QhTGOdVtxJhz8kMbzpyeUVkzTSFxvWO+pXZP3zGUYGU8z6/ML3nusG9j3ndPoKTFzPp9pvXG9rvhB03oG5QijzKOssaA0QQ/UXChNRO4KxTgMPD4+UbsWSv4gkgvrAuM4EPcIaJx3jPPM4Cy5FuKeKTnhw0jMnRh3jBJ4pZQqXVirjM6LcYB11FJJy0YHgnOvs6lSZR6QU0Z1YZQpJTDe4AP3lzMfP35kGgc2CqUkqJYYE7lx/H2Ky2lii4d+0DuC81SlMcZJJ9SrzOr2LAJvOl4ZYc3VIp2qGw54SM5FxjpySihEZI1uWKXQzrGnQus7tIr3DroUdG0EZrZhoNdCzpneG1o7jLHkUvBhIKWI9U7g+MM4AKVwo6emxPL0jXQGx0zZDmd66/jgCF6kBaU0nj7+PgDGBfx44emn/wbnHfO7r7C6QSvoEDDDmVq7MKMB72F5+pZa6/EaYMeLGDjUQtMWYwKtKV6Wq8CuxmC0wQZHykIc25YFVZowGfcdYxzaO8ZxhN4Oglqm5ELOMJ9OKG3Yji59Os3k0sm1oTQ4E7jdlkMzqY+5ZyOljHOWaZiJx+ZuFHQnowGlDg3soaNrXebn3jpalw0/+IFti2gfaDmhlWKYBuLBE2hYjFei50xZ5EFWJCbKKDSdPUo3LZ9z5ny5sO07XUGh87Ilvv74yE8+PWHQ3J9OfLg/8+7uzDQMOOsOXR/UKCiAMUbILJ/1bq0ebEpzzHv7QZaRWZqzntzKK/GFA7aspVBoMks8Dke9N3oTiNMfM0qATpNZq3PHnE5RanzVCtZ6ICII+1WgUIXqB8Pze1y/8gWvlMoQBvxoqU3cJ16er0yDQ1tLV5qSE70PGOW4xYRz7tCTKMLgUcrRtaLkyr4tYBSqVdFBDQPeiM5lXVeUM6wpYYxn2xLWB86nmVZBGUfKmYohtcbL7ZHTSTo4akUZi7YNTSPnIm4cXaBW0zVUhfPSbXntKHS0htsaOV/uKHFnPs88Pj8LtT3uBCcuCnHbaMdsx3lDKZlhEIeK3ireW27XZ7yzXO4uxBjZd9HYLcuGM4qcOtNJYJeUC6o3WmmEEJgHj9aamDuNjvGWtERSkRO5thaUnCDH4InLgh+DzBV6xw6OnhKUjNGKVAqtZgbvqcpirMgA4p64nCa6VShBCNE2cNsj43nEAL0WxvPMy8sVPwx0Y0i1UXohb+WVVu2GQIn7K3X7+XpDGce2RWGkGsvD3R37noTNVht76uTScNbinTA4Y0l88dWXfPfddzg1stxWWq84L+QirTWDF/KF8R6nDM426I29VMLBvDufJlLOdIRY01UT0b0BWj5E+gfk1KoQWFqhJoGfm1b01on7inGBfU8HHNjQPhCCp3XFvu6MY8BgsT5AzULoODaa8XxPp7Fv20HugRQ3ahailR8vtFLIcRVNpZ+4fvqZsPu0xRiHqolgpRNtOVLzdjyRgnrYMMnMpjU04EZDTRnvHUY7luWK642mFNpaUtyptWKUErcUpalxZ5xO7PsuCMRRUJ2xxJyw2pDyTqkdqzUxZemkjUUhc03nLD4M7PtGXDdUh9YKRWshWymF6p2GRrsB4+Sw5bwn5yrOKUphvewZwXr2PROzcAdKynBIGGIW2L+3hPOauO/4ccIFJx04in1PoIWBTUMkGU5Yi9u2ijY1BIw1pC0yDqMc3Izi6Xbj8faM+lHlPM2c55kPD/c83F0IXkT7n3UOyuqDyGeEydt+MWe0h7GGOti+Wmu0EpKM4iC6fNZBKKT7q5VGfSW4SHEVZMU6T2+VbV0AcM5jrRfnl+Pz4JjlieBcverz9IE6fF/rV77gjaMIV/cto62ilco4eyFSoEilscVC9VV0SUpMWGLuDEbJ6as3hjGgUuEyzZRaxDUkDPKwGi9wljHUXCmaV/GxtoZvHp95d/8OlECfaINVneE0cLtesWHg/v6Obd04jeIesuWddZVhtlaCpzur2dYdTZduAoXujdM0cH25Ms4T27rjraXXzOg0Wms+PT4yjRPWjazbxmWe6aWgKpTcyCkyTJqcKtUa8hY5n094n4g5Y43HGYE8UqncbgthEJJLiklgF+tYl02o0SZQOxgr7DlKfiVw6CAP73wayTWD6segWrPuiWkyAk8dxBi0Yt8rwintOC+U9Xo4UKQ9YV0Qu61bZBgGapfC6ueZ0ho57TIf7YbL/Zl1udGRAf1pmqmHjkjGEBrlB2otOGt4WhcUjuADRjW2mDFOnFb2TSzQQgjsy4JMhQ1D8Gyx0Wqj5YibJmoX+IgqNm8dI24h4YDLiojEaY3WE1aJmQGH3kzExF7cf+7PpGWVw0CqVBp5W6ntYAfPZ3qr1GP4P8+jOKmUcpzSDdoeDLhWWF4+YQ4bNWUsyk9gA+n4f/WZ/bk+yWbnAi3doFW0nQjjmY/L/yAzmuFEqx11uAmp3ri9fEL1JjCd+txF3pH2+NqJkgwpVZx15Jzw8+mVGJG2FRCW33w+s15fcHYEB0aLzVcp4kLUasN4K6QpAGuhKTis60ptaNXpJdM/M4ZdO1yaFLpDw1JqoedK6xU7jjgfSCUJ8hDF/SWEQKNhtZDEtFLyPcGSYsZaTa+iIe1NSGNKacLoUa1xd5qlCG6FXBL6KDjjNBO3FX1Q+733eK/E+k9bcqmHjGAS9qqzeO+4Xm+UYwb53cuNx5cb/++f/j7OGt5d7nh3f+HDwz2X+SQok9aHLKcL+cpIR5hyPNiW9mDtNko7HGV6ox6yFqPFoUeJWkeeH2P/PTlBB2pJXC4nljWKEQL8z6zIDnu1w2JMaU0p6UCkFLX8wsnm+1i/8gVv3zdcmPFHB9KVouaK8RM5RbacOJ3P3G5P+PlMygV3zACuz8+cLxdi3Mi54IKn9yLQigsEownOsu0RazXeeVJpx8m6YoNnXXasMlxvC84qfLDi/2ctDS1WYa2xbZHz+czzyxVtNIOzjKNAnK2Cb6BaETp2q9RWGIPn5WlhOp1xXqy9nHMY49j2Tbq83Llc7ohR4IW7yxmDpmkHvTDdzWQlTjTjOGKsAy84fsqZYRwwqrFvO+NxEvNWHdCZwliFs5pcOn4+sTx/Ej2aCZigWUvCjSMpRUoHVSu1NoJ3hyA4k/aMcRZt5CHLeWMYPev1kRYC1g1oa7BaYezBuDxNBG95ermx74naIsbI0Lyk/NqVOO9FTNyaWLQdT2ZrneAttYsDiXUd70QP9LLueGtoRTqCbV0x5xOxZuiFtDdaKagO257Ijx/paE7nC8u+0D9bRNEYxlEcJVTFKmHB7injBgtoeimULEQLY4WKrZocvlKKxJSFRBE/a82g5cYwzcR1J4yeVBu1HMjEYRDQUUI2qYXSOiXuIuzVhhSlC0QZUlyESTsOgMzM8r4xDxNmGIVAUTPb7ZlWEj4E/OUDt+9+hjEaH8T1JG83rDWc33+F8Z6ad3os0q3fHkWcrhUdsG5gunvH6Xwhp8RtFWu3zxqwXqGWJvPUvB66RI9CNuhxnIg5Y6wj5sOCLWa0EnJJzklMAVISHVgD3USUXquQzFAdYzWmGdpBjkFrwjhTchbRt4WSK7016TitpSkpPOVggOZ9R1vFvkdqK5zvLqL1tE6enZR52XfmeSLuiXLoD6cxULN096nkV2s4OwRqLYRxkhkWndLEOai3xjiOxBjJcUMbYUyDoVaBep2xGNVpx14nnrg7P//4iZ9+8zWn8wXVGx/u7/ni4YEvP7xnCAFz2MsppfDeCaP38J79bLbQmkCT9bALU6hXAoqczEQL2I7O8dAY0JXh06cXAKw1r25En8X0JR0+o8ITZxgmYQ+X/Oqz+X2tX/mCl2tn0J2aIhWFd44wjaS0E/fEOARUKyKu3hecnxiCp9ZMMZb1+sI4eMYpsC0box9wXrw3jZa5h3ceRRMz5a6ZRo8yjnVZGMbxcDdItGJoyhKcY5pGcXqxYmxdc+LlOVFSERXWOEFvzD5w23ZhGDqhLD+8v6e3wqfvPuHHgd4r5rAMqyUSYxaMvndh34UL58vIsq5il1SEUeasPQygM6ApTaFaxmkZfLcOz48vnEeP1p7rbWEIAWs9Ke6c7u8AiHskNRloP7x/T67iEENv4iqyR5m3KM0wyLyu1kavlVwa4XQSuKoLM3aaZ6w1lNAprdFzwlaFdxatDl0UcF1XahKXjCmIH2hJBec84zSyHtCwAmrNXD68I24b/rjmOYmGzhtN9/bVbzAMA6aJN+btesNbw+16ZdtkLmi0Rh2dT+3CfPXTmZfnJzQiUakNptNZdHKmk1LmtkVOpxmlLbR6kDUitYMPw+Fk0THGsqz78T0Cg3sf8MPMertSahPDYaNAw+V04Xa7EbcbGC/i3l4PWYNi3SOjt6RUKTXRO8zTzNOnj2wvn2i1vAqcTTjLAcpoYmvY4OixCk2/NyEpGcf68i1Gafz8jrQ+07vYlGECSkE4oLYUE2l9RkymZGBpwkxHDklNW9GPImSgXnbRicXC+f6efe2CqEQxJ9j3HW00wTm2dcWFkW1PWK2hCwc0BI+qAkEP3pNLI8edMI5oI6QU6S4MxkGujVYzCkcuhbSvr+4kYRhpSh9sbM3T8wvWiK9oyQlj1EHUSgzTiZQydDEVWLZM2jdCGGjK0lVinE6UXElZdHHGObzphGFiT4neKvu2wiHOt4cZNNYeInFhYn52NvHDSNw3BmOYTuKBq60hxWemk3T6LQTivsnXD0egn377HT/55lumfzfy4eGerz685+40MwSPahprzdHhSbf7Snyhv3p1aq0Ok3cOScNhFdbFzJ5Dc9lSRishxbVe6bWg+2fXFpmDlppBCbszp0Q9rM1qfSt4/1Fr8I77+zuenp7ZVvGpLIvQ9F1wsjEAqVS0H0DB7eWFLz/c00tmi5JgkGMVC7Gc0cbjnePl+YU2ulfbsjCO5HVnTQ2IjONwzCk69kggaDTxkNx2jLcYNNYgOH7OjJOnNNEUpS0RZU/DB4d1lvNlomwr275xdzkBMlO4XhecNdjgGaaJ27IxD57708SyRVo52BFKCCvX687zy44S7y+sd1g0ad/xwdNbw3nFNDhyke7o3f2FbV3ZS+X9F1/w+PyM1VpGAyjuH+65vTyjraaXivWjCN4PPz7tPKWBPmCrUmR22JswI40RH8M9JUY9oIxhnCZSjALRjiMv1xdSzFxownoLXlh8yBzVOcsWEw1wRjRMT09P5A79gGJylgOBVuB9YF2PDa53tnWha0trhZyLyDiMPZIkpLOrnw1ttUIp0Vn2mlC94aeJtm0H/dpQ4o7uDe8szs3HzHMgl4TpsjkEa9HIA75uCWeFZu7nE+t6IwSH0wrVCtPpJDCxUgzTRC3w+PGJUgsaK5ZvR8Hw3lJyJXj7uoGGcRKXmFoI1vLp+gyIMwYojBuYpoukSbSCdRYzzjz+5F9hjRGtorb0VtDWYOYHPv30X9PpGDfixjvpkKwQG4bgeamZA8mUznM4Qa+8PH7HNM94q0EZSuuc5xPLdcHqznJ9QhsxePZWs28yRwxhJsUsUh8glYYdxIS7pCy+ob1Surye0hrrj3nSATPSZdbcasMHmdPnlClpJ8ddrm2txBjx44xGUXJkGIRdnHaB1X3waKMEfq5ZroPxlCrdSvAW48IhiNeolgnOipsSIhrnmJP2BmnPtNYZrPit7usipuitseeKMYcFXwhM00TNoktVraItlMMwvXUxg9DWkTeRlrgDNWhNnp0QAl0rfvrtt/zk5z9Do3i4u+fhMnM5zby7u2MYxsOwwr92c/Uweq7lc5en6IfrkQjYDVaJC1NHYM5WKjUJ09aYg6hyPFefExzoYiAuWlCNtojp9Pe4fuULHsAed1Ca+XRi3xYud3eUAsMQWNcba4ygFYO19JxorfD4csM7w2RmYmk4q2QGpTTrurEuHe/NYTQswtXr85Xz3YV1uWK0zLt6b6I/asK6C2M4HqzE6XTi5eXKMAxi63W5ELcVbzTGOeK6C9FDNbSGtG/UVvE+iPtGA7SQN6wT01eFYnl+IufCpqA5i0FOyeu64YfAz37+HdNpwgYtgvbDwagkgUmdDaybiG9P5xm1RqDydLvSa2aYR7SCafTsW5JkAqvZYgQtbhvGaJFTpEzwhlQ7MW0yMEfhQyCjqbVhWiUYhTKaGiPv7u95er6xbRtTbXhvUEa0Y6fTid0k9iQQlsZLh607LjiWfcONAXX4KX773XeM44gLnpgqrQsd39vGtq0sLy8yQ1KKFPcD7tqJSejyLUeqEXKTtR7M0QxpsTIT2FOsmprplCwayGkcidtCsJampMhydF3BH7rBXaKBUsqMc5Di5/XRgSjiutBLIaWOnmY0lZYSpTbWXYTR+21BGYNxUtRSKYdJt2jawjCR4oa2woBNMVEOaygTPGkXl5HWG0YZzu++lOdFK9Rxz677Rk3SeYX5Qo1XgXQPvRxV/g7tJ2oSnVoIniVH0r6T0yonedn+8PM9PgSMMaSUDplCp9b+ymzNJdFqFYisVeIuBcR7L5INJYhEXG/M88h2e37t3Jy35CJeo9o51pebMKmzONwoLTFHrVW8E6PkUmSU0UvidLnQuqH1hKESnKWXKLNPbcmli4AacNpQmpA56hHLY0yjV9G4AWgrbiRKqaMAK9G31SZ7hILJdpG4lMwwzsSUGAMM48j15ZlpOvEwDORSqL1xOc1Ctmqau/sHluv1QFHEKMBqmZMZJXP8tG84f1gRaoP1gT1lBmNxzpMrdA3fPj7y8fpCK4XgHL/25Q/4tR98weQd8zS+GsDT+wFxKjRWkI/DS/Zz8VLoV9mCPuQggBRKpTFaZs4oXn04P+v1hOpgXx1cvq/1K1/wcslsW8INI0YpnA/EuOO8Y1kWutKMg+D2ca8M3jFPltIglya+mL3TOWx8jDqYhbDHzIcvP2BaYd82xrtZXOH9ID6YR/egemcYArUUajpONlpy4/IRa+Od4eXo0qZpYo+fZ1IiYO0WttsmNH/jmCaFNeKu0ekE51iWlSEMuGGkq110Qcdg2PmAZiUuqzhDaC9dZdqJJXG6e2BXkRQzucng33TNel3YY+Z8OaF7ox+myeRM3BKti64s7hs1a3FfKeXQz8j8Q08X4rKjrcyXQLMtAq9qo/GjY/CWUhq6ixk1rfNwf48z6rAp6uw5UTY5JZ4uF9IuYunr9co8z6AtWnt6UyhlSVVOnb3DsuyiyyuVUhLWirdg2sUiziCC7WkeaSWLR2HvcHyW5cgnKznjvBM3jSgGxHsqAlvVDaeEaLKtGw2NRUx8e83iCOOkA6tF7OqMDYyniV4LIFIVo5BNHfDO0zUs12eGccYYjbXizbkf0gvnxDKtlSTaqd65u5zY1xV1OHZb5ykxUnKlHDPUVjO91ddki947uVRcq5JFh+hSa4nk9QVrxTNzuT0DHePFyDouL3hn8NNZBP/eYa1kPd6+/UZIDtYep32D9TNxj+jjs1VKY6zFB31YrCWRaTQpLNY5rNPEbaWkxjBMdEQP5seRrjXGW5w2xG2jYo+OUuO0YfQWbSw5xVcLrZIzSmuu1xe8cxitxOC6dGrcOc8TtVesNYcGViDZz240zh3wZ0kiT+CA9dCHEPuzgP1gKWuNRQ6B5ZjbhuAZxsC6rKy3mxRrJ+xc76z4oloZA3hnhUCkNf04cNXD/GDbN1zwoBUazfv39yy3lVIby34TT1Mf6MrQEekAR5aftYZ8eOqephPrcljMaUPp8NPvvuNpuclszRq+eP/Aw+XCGALBe9EwV8nR0+0X8zkQhqc9TKhbE32yOaDZzxq+1uQ+14d0qDeZcXY6tRbKcWj4vtavfMEbwwRaYVRnWzaUNszzWcx+vXkVD2OPk4QypByx1lGaXCDJkTuz75F12xnDwL4npmnmu28/MgSPM5p9WRjmk+jFtszdMBKGwPPHT/Tg8WFkixFvK5OXB+bDlx/47rtP9J6FCarbEcHTqSVzvhM3hdYbp+kknnpV5gnjNHK7Xdm2TO2KcT6jlOhswjBijSam8npKGueJwYmAtpbMlna01pxOd3z38fk1hFV1SWaIvWLpnKaJmPJhRKtZbusrw8pZi7OOpNMxgxJYSR/EkGkaj2DWwMPdmY9PT4zecutJNtyqSREasgn5gz12Oc/sufKy7gyDJx1EFO+8CGqRtIpl2RnG0zEvqMzDgFad223hdlvx3rF++x2tN3JtuDCxbdJdt9rlunkHaGIu3NYd1eoBK5rDP9HRSxNm7jyx3244czhWNI13EiAqZtHpsGuS4FJxrG+Y4Gg0vJc8QTeO0A7HiVwwqr8yilMUZlqpxzy3GUmJGALbKiLx6TSzrzs1S8xVKZXeRDrTakebRG6NfVnE81CLY4axGnW4luzbzn57wR0pA9oNDPMF5wOmyoHMhsDjN79PyRHvRrQfWH/6eyitmO8+0KuYGqA12kk32Vrl5C8o60jx9gsmXm9oP4KV8NB13em94p3GjQMtV2KSLDQZG/hfsCFrohj3qlFuR3it1kq6OWA4oLdSspgjK8uy7UJcapVh8Hw2PTZaoYwlTDM1J3ptqCRuMMb5g/HqyCVT634EJINVMA2BZWsYjcCRWsTkfgjU1OhdU4rEe3kvgcY0iMc9bLRhGEQm1aps/EMQ2UDcMk5ptPc0JJlhWxfp2rxn3zYZuyyb/O2rfL7KWpSx5BwpLVAabLuke4zThFad6+3GOEmk2LquWOdZbyvGakIY2ZabEIJiOggzcjBLBxq1psI3T/8O5wyXecZby1cf3nM5zeIwpfSx18hc79VhpYt2sbUK9X/mQnQ42ajDrqx+NgNAGLnW+cNn9ftbv/IFb9t3vJ6IWxQKsbGsy43zeea6bTg3CuZMx4+BLRamcaLkxOU8s9wW5nnidlswqnM6TazLIhBM3pkGS6cRs+j98h5ByXB3XRfG4Lm7u3B9uQoGf5xgi4rHQzFyOZ9JpZPiynCaMSh0qdxfLsKSa0Kb7l02qa48e220DqV01mXj/uGBvO+44NFA3BLu/oJtFWqmFSVQTy1QC4N3KCMwl+qNnCrh5CWFITj2dWUeR5bbRleVaR4oUeDeu7sLj5+eON/NVKVJvZJapeVMP3D98f7M7fHxcAsReOnpuogEIGt6kUyy83zidr2J3EKGHjxdF7QyjMHRW2FZVi6XCynlQ1s48LI8STFBs74803LFaCWMWeeEmFMLOXX2LEkC6nCgGbw8lLkB2h7C4YaiQWnUVlA6kPZMLwVrP3sTaoFHLxdyTMK6axk/yAGIkujA+e5OCC4dri8vjNOIDwPaNVrOaDReWZoWBCHFDZQmxwzGUktlXVaMDwJxHi7327Id+YJQ4kZvleF0EWZqXMRo/EhasMYexVo2aaXa4T2q2dfCMIjxMepI3QAkVf4QEB+khLRt9IMart1Aw5D3G8F53HzP9vKIUuIJOYwzMYt2cr/eiDmzXz/xGiKK4t1XfxyFeHQaq/FeYpTish1GxA2lLaUKU9g7mW0b57FeEs47Wgqs8rRSRQPXu+hYtaPHLBIMVcXerFvivhPGAaVFtD5OIiovR5KKMUqkANpSSidX0dFZbdC94w4odV1X9rij6Mynk3RwcWccRN4SnETi4IVENYSAUZpYIiUnUozM54u4+OTlkDyICTl0gVpzxE0jMXb2tIkDk1IM4Yg1Qvxy4yFPGIZRiC494X2gdSHJOR8OA+aNMATm84VtueGdwMk1ZboC3aXzmy93tFw4neWZdD5QqyHFyMvjJ853D6xxQ+mJj58+Mc4zn643csrcXU78kS+/4P58Yh5HOXD0Il2n0qIltmIr9llrl3M+uALhNQy6KTFF0FpTen7V9X1f61e+4PnRH/BUo+REGCRL7rqsOKMoMdKP7CbrwFU5+Vk61AqH6XGwIri8Xp8JzlOqJCiHEHAK8i4hrPu24gax7iq583FZeffwnvcfPNfrjY5iHE+MoyPGxBIzrTQaivPlgW29UZtmHAIlF2pJsqlHccvQdmSPEoGy7jveGR7e3TF6R7WS6+eH4fAKlfDaEDxGS3Co8wETRlKR02ap/fDtQ0TYDUr57DYxiMF07Vxv8YC9gN6YzjPKOlqK7DHTSuV8FhitdUXaEvd3F3rr3G4r2lkwmmE4Sd7XELDO8bxu2DAyaUUriVQ7ShlKLTw9bQJ1WUerjZxEE5jjTmmV5XGhpEhtlWGcSU2jnEb1iuki5Fc0fLCSAdecSAOsI+cdGhg6YfBcb6vE6pR6xLxoglfQDEYJEqCMZnl5FnTAChO0NyEztS4SBGeFreaHQW4fbbHWEXeRDWhbxKB4S8RcMN5hw8x2fcHVKp2GFdNh78Xdp5aE8wY3DHQUrTdKivIZ98q6r2I/ZR3+2FDyoZ2Le0R7Q09CIKh5Zxgmtm3n+dPHXzwoHdzpnbAwnQi9u5JstrQ8Cuw+nkUf1WUW15rh+unnOOvw0x3WD+QObhhAZ3KOMuPs/dCbK3J3mOPUnmtlnM7ElBi8p7SdqhTQ6KXSWzl8ZT0oxTiPeCNxTsoI0cMH0bT54A87ObF0K7Hjg6XFdhAjDqIEYgrfa2YOnh1JYqhFjOZDGGl1FanDHkklHQHFMpbQxtA6bFsiRWE7n04X8ZU1IpJfllUIPcrwcr0dsztovcgBU2voldoae5L5uDZG2LtWo5vc/zlHrLWcThPaBeKr/62kvqsqDkwdIYpoJ0ShXhTz3Z3M7mLCOE+Mhct5oI8CB5ctHd3f+GowsG8rzktsWeuSa5niyjTN7PvKMAaM+yA5mFEcoMQ1RvF8izy9/FvpnOl89cV7fvjlV4zBvrq+cCBLn70znRNyXC1ZDAbMYSZ9SCJaFWOL73P9yhe8lgvGKUk3mM5QK6fzzKdPO1kJ1h+C4+XTM+/e3bPeviUMA/N8Im4bYxAfxW3P4mqRC9VYfAjs68J0OGgoNMY7Ko3JaZQOtK44nc6SgNA6dw937HEXQS8NFxxOVZ5ebpwud7w8PzJPAWc1y5owxrDtO2EIkoLcO3utGC8WRbIBChTwvG7M44CylpfnK73BME/kCrp01n1lnsR9fuTYOBGDWa2VwLvOMY8TRiueXhZJJtAaYw3OCl1YGctyXQWXXzfCNOC05TwPWOvYumIYh9fsrRQz0+mEOijVy+0mJ3tt2XMmpcKkHUbBtm3YIDo0DTirWW83GrCtKyBzBwWkvLNtOxrJ0YuHQ45u+rBfEk1VijtWSbbZui4M04T3AVMbPmiM1kfIbqYqCMPMti0oBZfzHcvzVbqjw3rJO0vtQSzZiiRjz4PYd3U6MWWRNWh9zDUz2pzYtxXFgHPi5JJzFaPwXqBrwjBKZh+dlgt+CGLsC2CtyFwO2YW1HmUN27YRhi4n8ZLY4840BLZ9R9dOpwvjloK3YvFmgufltuDDiGoFrQ5t1MHoq8pyfVloVT63ZgP1mH35+Z7l5aM48wwTvVfyvuCd4XT/BTFXse3bd1LO7OsV1T97KEqR1NbgnKGkitMGesVqgbCGYUZpuC1XsewqheoKJQk9PQQrX6swjELioRdKacS8Qu/ip5oz1iicFcus58cnOfRZz7atTLNoOHVT6Ha46PSKMZrSCm4YabUzDCNKT6TDKaj1fsChGujC4PSW7z5+xzRNOOuIKVFyYvQnctox3kv6Rqs4IzrJvK/4YcKPI9ZYic/pHMHMYsxMEcTDhcC+RzkAqAo0rB3Yc8RgxDeXKlCscXIP1SZIE+KFWksRPWgTM4RSsvy7VJH6MFFKRqlOq1HSW5ro4KbpJKxMG3h6ujKMo3TLQRjtPgwst0WMp71jW1ZQih/97Fu+fbqi6Hij+OL+gV//ta+4u1woNWOU2IzJ7E5g/3qQn8T383jmytsM7z9q+WHEGEuqjafnG4OzdDTT6Qyqc3t5oeWI8YbbuvL+iy9ZloXr9QXnBm5HeGRtHaMUP/yjf5Sf/ewbjK083F/YY6HXyvnhQmmd092JlHZykSigkjPWSrDsbd25P424aWZdV1IuB+1X7M3u7s70UtAH1T0fX0MpShe9jz+iTObTieW2MF7OYvbaNf0I/xzHgd47Ke1YJ+9DJ0UuMt+J+w42SHIzklc1TjOqKUrX3G6rGFF7j2oCYy4rOOsYQyDtEowaQiDvUaDcVmlJaPtxS1gn85bWJFk5WCPkFiL2MO+VdrIS942XlNEa6rayH24ypWkReueMsYHTPLGtN0qTWdjpPFNqE/9RFPtNTqHaWLS37NsVby37tmH9wHy5UHJm3zZCEPnHuq5o53HDjNFQq8LYwDSN7FsG61GqcZpP7NFRUsSqTs0VHwK9SrxQVwo3BJThcG2RCBUfvHRjIRxSNzHVdpNhX660HBmnmawNaEVODW9lJlg6Uhyy2KE5Y/CzIe1J0AfEDD3GiDNCtb2+PIt43VisEViydk3pCu8C2lpcaOx7ZFtuwEHHUAo3zOIIkiPDNJNyptRIXF8IzmLDicdv/40Up9O92F/1ilKWjhLRd230nHFa8/wKZ4qVW5guEraaixRBbYnbSi4F68VG6na7vlp/DcNZNKqtMQQnCSRarmFVhRQjwVrxV/Uea6Xrk5nxQC6VnBJhOqG16EWtG4ixMniZl9ohyH0Hhx/sZxqufB79gNroAlWmPeGHkSHIdd+3nXGcJBEhirxjHE9M08TH2wsKzeXhXiRNKYvXrHfkXI/O07KvkXEeCcN0HAs6+7aQamM6n6kl0Y10hilXlMoM3mLdQKlCptNGPHrvPnzgeltZDrSgt45WUNJ2aNr0MUfU+GBknuy9pGj0TjtS0N9/+ILWOjElWkcSRFKk5oTRYoW3r5EYhe/Qikh4fPCvzkW9d27rhjGa2/5zvn56prfGVz/4AR/uztydTozDgFA7wRonRJVdOAKS07j9L+zq/+vXr3zBi9vKw4MIte1FwkpzKWIz1ipDkEGwD7JRXq8L8zSi9cAeRVxsraauK26cSLuIh63VGKtBQwGut40YI7TKdLlQl3hQeyUTrHVwKPYtEsLIOIyklCgp4rRmGgdq67TWWW9y0rubJ/acibu4wdSqcC5wu76wpsz5/oFpGlluV+nGlEH1SiwwzTO6iTnxtm84Y5iGAY0llkJrBXsQGOiduO1c7i60XlBdmHvj4Mh7RbWGrhHtHL0WMZ7eduKyQK+c3114er5hMGIhtKXXuVAIXsJoe2PdNhSgj1DZ6/MN45zo4Folp4wfpiNUVROC4fp0xY8zy/WFnoWw0Ushti7dbcmchsC6bmhvKa1LuCSS1F2iuG5YpMhaN+C8sFNbLUJzr+JigVKE8UxKwsAdgnTVlc8OMVKcXRCm5R6l+AHQ4frpmWnwQpmvGUXn/PDA1z/9MafLBe/FRSPFlS1nvDFcHt4RU34VwaswULI463c643ghGwmQxVjKvlIbDOOEN5lyhKc2DM4YwiCHgJITJTVCcIfvk6YbYR+3mrAa8iYZeCFIft9gCiZ9QrmBGleJrnp+FN9OPzOfz/w8SpHEn1ivnw6GpcfP90eop0FrjfOeGhexiFPStXQzgPIMo6PmDaWha3NQ0Tsv149oIGW51mG+oLVFd4FAb+vGNE1Y50hbZBgHMYZvcnhSSmNQhOl0pA+UI6FBfDSV1UzTxLau3A6WcAiBkjbG6SSpFvtOXK+4MEMz9CoH2lobt0WMy5W2xH0hpsQ0T2htWZ6vXC53YBTjEb7bEHnR4Dxx24+D74ZSYoW3L1cMcLmcDzh2Z55nbtdnlDJMp5n1emWYZ4FxO1hnRd+mPFu84Z10/70r1phpfTtitBT2YIl+djfZY+Ldw4N04DHJGKM20TZ6j/GObY+UmoRZe0gJjNaU2phnGVnUXnEqSApFqdQic7i479RDDjJfLiiFJHMoMYyPpbEuCy/bj/hXreKM4YsPH/hwf8fdaeTh7k48PxFiz2e5wve5fuULnjKGp5dFAkQHA9aB1bQYWbeN01lOY9ZoPj0+EXxgXQoYe8gHHKdp4jwOPN92rssq/oQncW24rSvrlvCDB+PRDjr6EPY6Wu2i4ZtmOeXVjtJwmkfWRZij7754z8dPTzijGQbZTMM4kdOO6pUhWPZtl5N7LQRrhFbe4fl6YxzEy3PfE9aKU/ntJvq+2greOVLKlGWT3x0svWtUa5zvzjw/PZNLlhu2NTgSGFSTyJXSOnYYRQIRd0ZvOd2feXm5EUti2yLOBq63Z7x14tCgFU+Pz1gjMSO5FGG5Wce31+urB6Hv7TOp67AWg24tsTZi3XHjiKIxTjN+GMUqznqsMeTDlHeLSYb9pb2SCWpJqFLJ+8YYwkEdbyzXZ+iS0TdMJxoSoPr+4Z6aCzElrLPEfaM5w3Sa2PfC06dnjLMYP6KNdLfbsqGNSCiss4RwIcdIV4rL3R3BOdblyjiOTPOJ55cXzOEnOfiBMAxioRV3rFZoJTl01npyXOmI12tHxMm1SRyU9+YwcvbscWOchkOc34QAoRrOCOu1liruNnHn+ekjp9MJaxQYTY6y6W9bkr/x6f+JNhrnLGEIhOkCWzwcVgIpJRFlBy/p59/8WKC66Y7elbjjbDvdDazrCzUuGC06MBANX6+JvQqBQR8J5L0UWo0o1Qnjid6PVIwjey3GDZU658t0kHuizJZzIQSHNZpgZPZX4kZCzNGN6rgwYL3Mv5zW0BLTNNCVzLtaa7ggEP/y8kxKkj3pD3F43KVrMWJoixkHYopoqxn1xMPdvTi+KIXpBYVlTzL+6Ad3QFIEqhyiTie0Fk1v2g9D7CMF3VjHeluoTQlZRimsD5SUKbUyjgPBjEf3JI5AaY8MfhA3pypMzNPpdBBFKtYZwjChWiXFRNxXWpGsOescoxLvStH2ndjWnfl8pne4vTxzd39PpzMg9nx+nIj7TspCAOy9vBbO4WBk15IpJRO3iB8HvPNsyxVj3SHpqkIsq42fffcdX3/8hFIwOMeHh3t++IMvuDsJC7S8QZr/sUvjfDgSDRppuQqT0Xp86OL6b+2Rm+aw3uO0QJDLcqN1zc1ZYWROI998d2WcJkpufHt75nSe8DXRunRMFhEDn+dBNsUtis1OEb2d1tLtfHx8RCvFw4d39C4FdFsj675jfSAXCSttpWBdgNpkpjg43OB4ua541yi5sZaMdf5IP254rQknYaHp3pgmL0GyJdNTI5xntIJ0DJGddehJZi/TPJJS5XK50EpCGU3KEe80ulas0bxcb8I+s4bJn9hjPejl4oq+vjxzfX6m9cOTc98J40wukZwWxnkirje6gdgzHS1C9XrYnBnDfBpZX26HcbHoDXPcoXWJSVmvOKUYxtPROWpSSUzeUeIm4ZJdNrxSCso4gVYH2Si99+KqkTK9Fl6eF3zw0AtOW172iDL6sKWKhFlIRMo6Sm+0uItJLuCHiX3fMbYxnsbDizHzct3EfT4IVf58PomDSRf/0ZLl+mp9CKpTQhnotaM7uNGx7SulVLSS2Ze2XngLvdFrZBqCGA6oxruHB27Lxvr8TE3qSB4QJ5thHPBBZA1C4EgHiaMdNnINbQOlZkpJXK8L8EnIKt4xuA63n0AvaCP39u3xG4EmlQT8bns8Ej8s6+ONcmjUFEiK+niP9gPtcLwpVaBp5z3UyjydXoNUtdIMIRC3G94YrB9IqVBLlDglXVDGEHfRM9Zaaa0Rxgnd2mu4saKT44bRin3bcdYIm3dd8CGwbhGjwAWZz4VhQDvLHsXM2R1pHtoFvvrBxLLt5CwdsnGWbV8ZR0dt96Qs8+hKYhgHqEWu07IehgYJjWhKt2WXsObbM6UJ4Skeh1rtKvu2E5eIVkpkJtZxPp349PERax3GeJ5f5PC2J9njSs1MnyOIej+0o5310P0Nw0hOG9qNpLjjvCLGXQhXYeDp6QntvFjQlXK4shRag5frVT4rI56XrUrnZ21gub0wnk7stwXnBzGlNpb5ZDHOHyiEPgJgxa3HWsu2bDKOObx5b+vCukd+9PtfM4wDwRoe5uF7rQa/8gWv00VoO3huTxveO1qXU/b9/YXbsmC8kCZKyiy3K+M4H2wpi9VWrIpcoGuP0Y4ShbI8ThOtKaZx4na9Mowz95cL3379Ha01npcFbQyT9+z7zrpHLvcXdJVOxDnPvkf2bSXmdpA9KiUllBPWmcHSksSQ9FYwdpT3fKRtG+uE7rzfxObIaoyXOJrWGy1XNIocC5fLCX+nRdirLWiJxNHaYl3gPAxHJMjGvq+0Jjo156dXQWhpBYUw326LPFi5VErNkm6dC6p3lu3QLpXMdDqLy3xqJKVocTvE+eIWo61jW6+HJymo1klbpikjkOXkKevCNM30Unl5fgFjsEbcO6zRpBiFYRg823o7su4M0zSjcxRbsNbpShwhtm3HakMYRryG5eVFiquxxJQ4neW0i+uyCRnPyY/kHEkpMZ1mNOaggzeRcxxmwjlXki6v+XelZpQ2jEeQ6Lrv1G4F5iuIldkR8js6x/V2YxgGtPGkeBNDcK3lPtTiBysO+pbLZcYYw8vLwPt39xLyqjVz8KSYWZftYHVKkCpaYZwnx4WaI9M84b3DTndMX/1vZYMriXT9xPL0DSWKGfbXX3/L0+MT3lmsgZbEP1MbjZ3vjySEjncWrzWmRonOsQ7gYL46Efsfonpak06tQUyF4JR4R1ZhP6e4U5ukTLQqDEe6oA4VOTTs2y4FyViU1SilSXkX2DNnWoooNKorvLWkXNn2K9pYai3QCgVNi8LGNM7QVWeaT5Qsc+WSi8hA/MzpcuLx8RHtAznu6FoO0qqEG6eSsVbxcHdCAcuyUYrECRnrDgP1QskRZTUxZiGAwBG2qihZiETtcBuxkyd4ec6neWJbFs7zmdtNdK/0hh+FOHW7Xhnns9xYRYhjvTXu7i9YrXnK+ZgLi3RBZn+elMUvcz5NYnumuiAg3VJL5HQ6UUpm2zfm8+Xo5CLGOqZpIIwjLUj2nzA3u8wpD5mQ0ophPpPjToqZlKSYO28FqvUDavDsa5QDYs2s28LTbfle68GvfMG7nC9scaeUzvl0Jh4zMw5W1jgGnp8XccVwgfN0JpdOb4XL+SJzm5SxNshMaggMVtMU8vAeMSPT6cy2RW63rxm8GC1PpzOtNb65vfDufGLWWtK+/YAxgXWJYseDwlrLMAzykKMwVgvBZEtHCnPlfD6TUuY0TWij2PcdbzRLh6Y5OqSGOZ94XDZUKZzPEwbxz9xS4bpG7i9nlttGQ2GNp6tOGBz18Av1w4jVSh5eDSfvuL68kFLhtqwMwbHeHimtiWv8MLAukXmeUd2wR2GM0hVZWfaYiSnhjRbvTAy1CPNOnCnATxP7y5XgLdZ5KVhNYJzWRQycsqRCh2HEB/eq7+NwvZ/mmWW5oUPAaU/eIykneimcT5MIe3Om1U5H5hqldlQXivQ4DlyvC0orTueZ1iAuNx7eP5BqY4+FkpM4UxTIcQGlicsqs8iYqbkyBkfLmVbkdDwMZ7SWxIySM1pB8EGEv8sNa70wPPck94QWqK/mzDAMPDzck0s+xMmiRQPEpcTI3NIPgduycX+acEpTu6J2xWWw9NJ4fHoR1xKjsMHRro3WKjIphOH0jnGaMUaSQvK7L9m//A1aTSwff8rTNz9m3XZqlc/A/PhfYmg4F6Sw50xwI6V1UpO4GfErFUq+G88Yo3F+kBlnSUc0TT2yEYUujzZo41jWFeiEIGkT4zhjvWNTkJN03xhHrgt2GEhF0g9yqTjnpbu1BrFIlcR2ZcQ4QRuRRNhxYrndGMZRZvu1oJsihEkE7r2xrzsxRt59eE+Mme35RilCPkELazhvwqgM84m078zTyLcfn+hIhp1SmtPphNIiTRqmCaMK67oyBGHnKp1xxnN7eWKchHATfKB2ySXc1pVxktm/Hyde1o35NArLOBchCllHcBJZtN52SklMLjBMo9ihKbEldFqjZyG9GSt2Z8ZYVDDkXNFK5Aa9FRQVqKAstSvCEEh7BNXwzjOdT5Q0UGIUVqoVV5eUDiMNxDLNaCG2DGMgPz3hhglFk9gsDSlG9n1hmk6YI27p3bsPPD0+fq/14Fe+4K23hbv7C7V1UlyocUXbszyYufP8vLAsm5BCcgEf0KqyrAs+3Isw10AtIi3wQ2DfVqZgSWlD0ZkOpuWtVKYx0Gvl4cM7tmWR/2Ni3RPnuxMDsC43gh/obWBZXrh/uKP0Tm6VPYt57O26YLXi/v091+cXmVF16U5qh/W2kdLKcHdPiokhBC53Z67XKx8/PjGEwDgMbLtAqeezGBEXM7BsR1Ds0zMKg9GO6+MTznu6Vjw9v0in1RvbHvE+kGKUuchRtFtrIvY9XEWmQaCO3BVKe3IGfWgYp3Fk2xaSczQ1sF2fmMaJ2hSlFHRtvPviHU5p9nUVduQBlcVYRNDdGncf3vHycpUOqlwxRjHPZ6wXicN2XURyYA6mntfEuDJ4IYIYH6h5Z10WaldCJQ8iK+loUizSZddCjuJbOt7dk2on79JVtyM4VxwpojAxnf7FTDK44yAgQ/5GPSAmUBgURiy1WhM5i9bkuIuzB/LzwzSQU+H9hw9C8jls0NZ9EScZOnuKjMERl5Vli/hpZrTi8DFMw2H47VhipOnOwzsjLv0pkqPAznSOOVMXA3EXjogYMXMeT2Lf9uVv/BnuvvqTbNdHPv3+77G+fORnP//EMHg+nM58caqsvZCzoiEeksvTd6Kp+pyLph0ujOzrJund93cipdg3rA9o7YhHyOtpnKgpMp2FpVm2jUVB/Lgwn++4u5xZt5X9dmMIk3ieKrGxc86S9hVrrcRPKc22rXAUSn9+ENZlWVG9EYYRjWhslQqUKs/wumzs+0YuFR8E+Yg5o40iaLHPU8ahqPhhJG0bNWWcVq+wdcwFH0axmksb4zByOp1Zlys+jBLDU4+4qtrRDh7evyNtG7/+wx/w7ccnnPUMw8C27mzLSq8V6zxp2yT9QcPl7kJOhX2/Yr0neEk4cMMkTFrxTKF3TeuVNQrU+hkpkKgsx/V2JQyDGCrkwjieJC4oDMRY8NYKGSlFSgOM5fr8LCzcWkRqYz3aWHpPQvjpRwCxEQ/RlCtYf2T/OWpKtNpwg6e2ivMDMSbookPc9/V7rQe/8gUv5cLzbSOMAw2xkEo5S4RNlYH0NM04pVm3lZa318G+91asq5zDGsfjy5XgB6z3lA7GibNFA7YtktadwYqf3rps5JgJYZJgVeC67CKwrWA6oDv37+5RVpHWSC7xEM56hsGSc2e5bdyfZkrrbNsmXpRGHw+hYt0SYZyY55GGpmvH3WlgW1fWBLU18m3FWyFY7DExjL+wCvPGcF1vkiYeM4+fPooLfRPyi2y2BaOFAKSoVET75bSC3nDDwPPzkzib94ozQgRYlvWw59qw3gljq0gBHIeBtm640RNj4ruf/xznHM55zKBZDjg45yyWULUS98jpJIy2eJhH51SkM9FRukNreb4uYu7snaShLwvBe8qyYJzHec/oBrwxLM/PuDEwTeILOY4n4rpAK1ymidu6grHH3M1hjaG2wr7c0GjiGjGjwHbKWLZVNuGmOi+3G2EMorGLEtTZuxjnDvMgThnWk7eFcZqYhoF9jwzziXE4ZBpVTKbR6tAI7nhj0boe9mjiTJJaZ0uJbRe4z2hNcBrdpZNTRnN/d8/Pf/4z7u7PfP0/rgeLTqKWxP80HynqDeMdThu06iLkt47Tu694+OLXWJ4/8vEn/5rHb37K7/2Pv8+67vw3/5vfgPMf5eNqiNvK/vLptdgB+PGC141YhRG4rQvWCaPTe5kDKetAWx6fJGbp9nIlhMB8mg5tVifuEaMUShvO59MRLVPQzlBK/RzLJnpPrV/9W9Me5UDbOymKe8m2b6QUOZ9OxKMDdBryLnIDqw1+kAy8nMXtaN93KYKHf+x8Oh+RPBalBDbX3tNK5nSaBIZWmtvtyjyeiHlnPM201skpwSGeb62w7YnaPLU2Pj3fxK7OCaM4BMuWpZMcx/Aq12m9k59fQFucF3/LXBLny+XV3DnFRNzkdXMuWK0pUcKdaxNze6VgPl1Iaaf3xnyahfOQsuQY9sZ5PrGnJKn2B0rmfKCVTMxV5nW1wyY6veX6jLMG7wMv1yvnixNpjNIYDSlF1pcX5rsHNJpWioyU5pmcxATi7t2777Ue/MoXvHG0mGBoOVFyR5vAtke0dwzeiwNLLWAt42liWVa++/YRPwRK68S9kHNjnsWFfdkW3r9/R8mJl+smoZtKXOEe3p3RXZKPG4q9VLZ1F6ht2xicZ4+ZiiEYS0mV/bZjvcYpQ6+VD+8+iMAYRRisaGmQjsB7EZaq2shKNk5tFcZoPr5cGfx4xOlstC6CT2s6p2Hi+fFFNEAhENcbKRWGMHNbVzKF68sVqyRiTcy1J0k/6BVNByVzvlJkHppjYUvC9sq3G0OQLi6EAWcHXq5XMSYOI7Vb9n3j8nCHN4p422ilk2NFt11MsFF0rdhT4u5yx+ks3UoxRoqlVpQmmrvb9ZhrhYm0i13ZNI3QG0+PjygrIvpaJVHAOLGvMkYiS7y3aN1RqjGdJ7TRBxusk9aNVo85kz7mbK2irKMqc9DmG7aLG4Xx4rpP68SbCLn3ZcG4cFyTSHMKlEGhGe/vMCisd7gqSRsxjNzf30kH4tyr0bIzsjHVXHBDYN82punEvm04H1hiYtt2QpjwQROsYlk2jHUYLX9DzeJUP44DqkbuzyeC84xevaZZW+tw4xk0NCXuLD6Y4z5SGOMYJ0/rGY3h9PAD5rv3nN7/O7750b/mRz/5hsfHK//t/z7y5buv+DpJodNatIHWec4P71DAOIwyQzZiBlBykfgsPzAMI3G7Mc3zMU8aoTXpmIsYJxttaL3ScpVO8XxmGDzffPedBK+OI+ow+66lQulo3QUetI6Y9sP1B6xWDGcpDA2gCqlC0hN2xklMI1wYpHDkjHeBhuL6cmMYB2LJaGXY1pXzwztqT6gsOkyaBCTfnq/i4ZkTtE5JRVJFtMFZyzAOvDw+SWJGSYQwsMckaRveo5SRWd44kXsXZ6MuQam1FObLhbhHitKkXGhFRNvihZmZp1kQG3UkmTgrBCyQw6txaCNpHcZaXIecBH0YB0euR5QQinGa2G43apXNYl1WBi82dfY1X1MS4Yf5jLWSuvHDr77kZY1s2yJRQa0yDgPT5cL9w4XHAwL2YZK8wdm/7kXf5/qVL3hKW6zxKN3Y1hem00y+it1O4xfGs0ZLjMUQLHnfUc2ScuL+4Y7bbeH68sT5fCbuC8v1ma498+kkWVUI/r/FxP3dPVYrbtuOGyS1+NPjJ8bTmev1hnce5yzf/PznXC4XrBM3gW4U4+glhX3Z0C7I4Fo1rA/ctivz6AnOkHLltok1mjViG1Rzo+jKruLhVVd5eXlGH1EdKVfSvh6EjDvCMPL4/IjRGmchWC2hosj1sr3jB0dMSnR8g6UbqLGSb8dDuT3j/AWjAzUn5lmMrm+LCL1bjizLxnQ+iwtKbTg/EVWk05juTqy3F3ywBwlHM5wC6Yii8cHhtSdtN7aYuNzdU3uX/LTehCzSCjZYWm1s606YL6Ttxr5cmS730BqpNooxdGvIcceqQE6JpCUpehrDq+C6RI0fR+ohmM71cAIxSlLHu9xTslnJQaS2whACwzBCr1yXjVq7RCOFwHSaaKkwX2QG+9mxvmuDco4BsS7j8Fm1QaOcoysJ9dSp4J3GK/F7XLedh7sTKUbs4FluC5fLmX0XJq6pu7hj1I2h7vSsIDVaumJrIbfKr913pj/163z8dKUrzTxP9NpINeK9wRpDKtJFjGEit0rdC0aLcUGj8mu/8ad599Vv8ON/9d/zzY//Ff/sv/u/89/8qUfGYaS1gvfh0BRrjBuOFPrIPI0sexTWsnLw2Z2/ZPw4ieNJyZTaRNifMpf7O7ROcjCzJ3oTh/9lWVE0ttvCPJ9fzYqHcQKliJsQq1JK4jgyzdQih4BcGzEvlLhTlRZ43Fput+Xwru0SqVUa59NETTsVAzSmeaIdYntnFKcvvwTgZd+53L9j2xaWbefy8E6Yoc6Lr68L9A41Rk7zTKPLfA/pxIxpkuRA5/79e6wVx50Yd6Zh5Ha9sjeZz40jxJjwKbOu4jQzDoHUlXTl2kjhMpJUb6zBKEmkqMPIutyoVdicdV+PXLuCdQPGibOSG06oWlheXkSacZAAp3FgnmeeW6GjuHt44OX5yh7FaBoluaLn8ySHhdJYry9cLhf2Ho+kkg0XJm7PN0mJef+BfMzprbXH2Cl9r/XgV77goRTrtryKYdMeGYYJujDKVO+HeTAs+442lsu7d2z7jkLE0vM8UWvgel2pRYtnZdzoTdzwAdHCBLHveX58PtiHhsspwMtO2ReGYcZ76TyGMFCK5Gg5K2SOWsRV3R4pyjFG7s4S8hi86Fcwjqo4/OnEY7MkcViP68LHZcX5QeaOWXD00kSa3FpjmMWEueRIz5lbSozzCePDQeXu7FsirRuXw+VlPl9EGL4ulJLp2pBb5fzw4cg7k3yyfRFDYzdM7NvG+XRivhv49PFbTvNI712SvBX4cUBZmfuVvFFKRptBgmONodXK9XpDGcPsPXYeuN1WWmtM84nb9UrdbpzmGWjQCvP5xLILfBq0w1nDtlWU1eiuoMMYRvZllY4H0MbRioRQOmsxViQEEs1UZONsRXwP94i3hq7bEeukRJtnhYjRDrf4cUS8Uc8zJa7YwbMdbiZ392Ihp7U6DIklo23ZdzRgjWZ5uTLOJ7aYGLyj5IjVHustyju6MbSUsD1SX77DxETnI0Elxl7Q9dAH0tFGoY0W6r7v1CaG4/o04JzhfB5JqRDUQrYOPdyRlsjLyzPzacY6TW2JHKOQsV6escPM6CbWbaHVxp/43/05zu9/yO/99/83/uX/8G85n0846w99pcwHtXXkWDBDoKrG3bs7mcXum1iUpSpynBTpTpw8UArlHEHJYcM6OWS2KqbbvRa2feXucuEHv/ZHhLzRKxrJKvQhiDvJLgkY0zgKVGkt+iDM+GESN5R5puVywHTinUmtYiytLSk1Ym6Mg1jK1d4kWV2JW0mKz8zjwPnujhgjrXdO5zPr7Yo2Em00jkKcKqVgXBCrwiYG970e7Gc0uSa8dQTn5SC9ruK8VKKYXfROCIPMHXvn6eM3hOkkUUExMU8iXtdWobWwMYsydCJDcFjnePr4yDCOGF0Zh0CtTazSbECpTtwWidW63ailkGLi8nAhLjec9bQue09TMI9BbP4O5vR8OvPt1z/Hece27wzzLLFrdxdhnhvDOAbx3S2Z+e5OWKJVIGHrA61KwG9b3nR4/1FLK8XldAEUt+sLW4yE8cS7hwvrsrAnce7WFqxzdOWIWZybzDHPiDExBMd8EheL1ioeOM0Tt9sNrTS5bcyniVwbPjiUcYzBcn2+4f1ITDvbesOYE84YTuPAtm2UnHj44h2xiPYljBN+kHmcc0Iplvgqj7Xw6dMj1g9o1diWQkqFkjOpFDSgmuSTFeuoJTHNA6M13J6uWB9Ynj8xDAP9gAi9H9D/E3t/0mRJlqbpYc8ZdFa9k5m7R0RO1VXVQIOAoBskhAQWXJEiXPAvk3tw0WgCLHSzu6srKzNjcnczu4POR8/AxafuWdhQpERyAUkp22RGhLubu/m1e/R83/s+j8lYlwWLgJS9SZTno+hLfCCtwv401uA3h1EJoxLb6jA2p6oqNrdIYXyZdpKH0D5A0XXdzkLM8duKzgvmxeHDxDpPZNZSt0emaUHtY8gQo7SotoBXckuQp92NPMtI20bVyG5n84HgV9ZpIqJ5Oh2ZV8c4fhk5i7zVLQvLumCynKY7sS5iAvAxooKXVKmTMWym7FfYbQxe3sRNJp9rv1nmNt8PLtnxNgfRFPlFbgJZbiltw+YDVSbGcr+ulIWQOOZhFHB34TldjkKeURJp78d1H/s5auMJ052YFgoTKUlkaqMoNLZRlGVBVVXk+ZGqKOUN3Zqv7rYQxN6+LAvTNDFOE8MwsqyrhB3cyrp8Jow/o/IWm12oqwZtLTpEtmWhbhv85ogRiAHvpVaTFwWJxPHyjn/xf/y/8od//z/i57sUsY1QMvLqwDjOUqS2Bh82SuSG7pwTRmkpY2etFGFzVGXBNA5M80xdNlRNzTxPTMPI07PcBOZp5N3796KLihCSp79L0vepeeJ2e7D5jaoqWZZFEs6Hjql/kOcFh/NZ9uKAUYqYPMviKetaeLcqEQIUecm6g9o35wgIf3bb5PZPhKgz5i0JUs/53dn3BS+47pWeSJ7t+6sd2Bxj5D4NVHWFLXKpwkTpFd7uD8HOrRM2y8iznNzmrMuM21a0ysXDmAr8JnvWEDb6fpCRelVitTA68yJneNwp9iBbTFGCfMuCcytFJTB4twmhaFmFn1qUojjSGvLMsiTpM8rzscZkBauT11eMUX79eaasy53h2QCaYRglEJWED5qC5/2Hb5nXhWlaBPu2F9OVkhu51oZlWf+k58Gf/YG3zAtZXpG8w2gRY/pkuN17miYHCil8z07euDexo9vcolPCaNh84HabpdSqROi5pSCdmGVhmRdMVXO/9+isICSoNPSPHpNZ1m1D5SWVMQJXzS1tU4s7LnpWF0hoNud5nT4LN7LtGB4967LQthXTNLEuCzrLWDdP/3iQlOwLy7zE7vHvpCTpl5QimZJ5i6TFkdcVVhvq9ojNM5xbyPbR1epWgSE7J2SPCME5mq5jcY5DW/Hy8RPeKMpy7wyRePR3jFIsxpDXjdQTVkdblORNjfNh9/EptnWhrnO67sD1+mCaFmxusUUjCCGtRA+0j2DLTOLxMSLySC1F5CJvGfoHVVnSdgfebjeJuyu9H95GovruQVFk+LCCknJzURQYlSQuvqxi2jYaRWCZvfAJddqpGCt1XRO2lYTgrpQ1NE3z1WJvFBxPR3ESTjOlyyWtbsR23+QVcdl9d5lYuLfksFrRVgWmLrjdboLHGq9URhxvdntw0TMmruT7w0XRSm2lKKr9Jmr2N8AMm9n96VrIJCTkUA5RDNk+iArHC8OyyHJCJYGIGCPrsrLmjnldcW7Fzb8nRo2fGvLDL6iPQtuILlFkBqMiVgvtRcggAasVVXvif/ff/d/47b/5f+KmHhEkKIr2IgSjacQYzeF4RGnD4/PPspsua4oiJy9KhlFGa8ZYNJquO5AXcmiELfD89ESxcywvpyN1bthC4vF4wJeHj0LesGNiF6SudN0Bty54t6G0SEiXzcEuoe0f9/3BSColxgqb8/Ho2awTc0FWYPAYKw846zzjg6coc0JUTNNEXVXSTXUr2mhihOPxxON2QyXPNK6gRHxcNy1FnnG/y8FsspywyYFrd5IMKXG8PGMzSYZuIaFsQVg2NhXJMkNRFqR5AZRIgrX0FtdpZApBNFNFQaoqYvBSsdotBe3xxLqIl9AYi98S4zRT1h1VlRO3sP95PEM/UzUt0ziQZVY4nn7dS/WGopIbegwbZZZL4d05tJH+aVHXO59VYNfKKtxjYVsdMQaMtmgNWVmxrg6bFVTFP/nw/lEfMchoQhlF8PLkYI3FrxuLimhtqeoKUoEKkaopGacRnSTcsHlASY8ntwUqE+u1UrDOM1ZbmqZl6O9cns6M40bbdeRW4Z0TS3fwtHXJ0j8oy5pHP4BSOwevxe0GALNLD4dxYnz0KCM7pmG4E0Kiahqur1eKqqaoKtaxl36a98T45elZDhiUoSwylnlGp0SuLf3QSzBgHL8CcKfxQWkzdJYzrA6UIUTR0bhlwofA7SYusXkSjiNKUoBlVUCSP4d3K/f+QQiBEQhlAcHRlCVv1wcRWLfA28uPFHVDXsmfTe18znVe9lGUpipr+mHE6IjJZPyxbR7vHW4T1FXRNGzbRtc2jMPApmRknUgs64zWEre3WszRbl5k55kZQoo4NxJFvUVR5EKz0bI70mmlynO6tmEYA0+XM9pm9P2Im0ae3z0Dce9qJQ6HlqauJTBiNDbXhC3gV0ncaifoJk+gLgvCPNMPnvXt7/nQJaxV6NWLUdwYsVNUlixvZPe547kEvbY/2KTE6lbR/+z/PamE2dVKXw4654TDufkNIV2l3WwuUuEv/6z3VHJCqCtu3QjzC2F5Q1UHUvWEzgQY7TaHNlZKxzZjmWRloFRiuL/g5gH9hbDy5fe6TKQUmYaRhNrVV4GirkhofNL4aUZFmVrEKDSXmCQlmhnN6dAyDCMheg6HjsdjYl4DyXsya1jnkawoKTJDCAmjNeNw53A84uYFt8mbaJ7DNI3Uqt15kVA3HUollsXhNk+ea4ZHDwmOxyOvq4h9q+bA43Fn8SIX9iFQGEuZW4KX2xIxoq2RwyUreHt9papqhv5K053324sofYahF2UQlmmeKZsWpQ3TtDAPN06XM5tLrI+BopDXQpQmA9rsCddHL/WOIiPTFlUUrG5FaY0GmrpiXVe2EDEJXFwoqxqbSd0lBPGm6F0pZnNLSol5mEBrtj0R3bUVbkfV3R8PsrzEGAQaPq/7eDpyPF8I20ZRVngv7sXgA9vqdkdLIvrIsjjysub69th7kxk+BjLvqaoat0xsKf1Jz4M/+wPPbxNKH1mdZ11F5xKCkBm2dROUVJlJcbQyHNqKaVkwSVNXNd//+MLl1PF0aLle7xT5gdWvhBTopwW3ec6nE0prgTerhRAc92lDGUtIEaUU8+Qoq5bxcSO3BauPzG4jxYTznnWZsJnIP5P3jPMuMl1Xmq7lVArDr6tr3OaI0VJVHTFJKdSnbTczZGglh20yIkjdNsfhmJFCQBMpcvGdras4sZQ1RL9J7243IRdVyf32Jg8HKZG3LaXSQqQJGxu7RHVPZVVlKUGgFCVYYISfGJeVsq7kJuAcWV6ilKWuSuKutLG55tB0DHdhnrpNxnlV3TCPA/28oaw8/akU8cHh/cahO4ES7NLmNpKTW1vYi+qkgJtnuuOBt9cbVVnSHI7c7zec2zgeOtbV41YxYNdtIzqTLON8agkRbGb47pv3fL4+0Jnh/fEZgsJ76USO80xRZqxOUFfZPrZ993xknha2IAdxP81y0G4S5khh5ac//Ce++y9/SVc1KJXJIaHVbo6WcWAMQRJ1ar+1JamKqySUmbDT8hWyk/pyiIUoPzbs4OMYonArkUM+RglrpQTOuT3sIf9NaYXSGruPCrf5DssDmzd0l9+Qjs9sW5SRMGI7X9aVEOX3pfbPIU9xO39UazKtWKIELKqyIi9LzN5Fi15UVDbLyWyJWycO758Zpkn2Pjpn9YKEQ2umeSZFj/eGEDaeny5ozjyGWQDQ20xR5uRlRUATwipdSJV4PHqatqOqqq8F97IoePn8WaS4SeL8eVnJ98oyYXOhBpV5w2P/O0hEmtORzXm2ZWTdNtrjkXUcSCAYLaOwu/JrKxuUSngnyUOFiIUtimmc6U7dlzU6EGm6E9qURL9QFBkxeNwaqZvm6xpBUHArbdeS1zVh24RgYzQYQ4qG2/VGXdekFMmqBr8sLM6z+U3IOVZjSKTgyTO7H0mQrDxgETVJWe6PkSwvcKuX6lKS339W5FDmOwh+5Pr6Qtu1EBUKxfXlVXikeYk2EvSJaF5f3zDGij4MMGXB/HhQ5AXLupBbS4j/dOD9oz6apmVeVqoip6kFPmy0Zt08fpM3oOU+8Zt/9mvGeeHHjy+cjgd0iqzTwqFtuQ8Lk4kczwfut1HcWCGRkud0Oe+7H09RlKgv1/I8Y9s2ng4t0zSyLo7rMFJkVgq34yCjrrxg6EeKskRF2bNYq2mqghg1KtdsUTGsjlxBlsnYYplldBBR5FWBzg2PtxtG5SgraqGIPLWXXSsEEWN59NJP6o5HQpQelrEZ4zyhrKHrGrYt8Ha70Z1OrKOwCr2XN97j5cTqFlYvJVNrIus6i8hSGVJw1HWFUpp1WSmqQoqr08r06Dk9XQgoFrdBlDfjtELPTF6X9PcepT15VXMfRixQFJZ1njF1RYqGzJYUpbxZbevK5r2Mh6qKZRohJKpGRp8oyzSsMvozAh5WwPt3z/gYaPNMkGDrCkGs4EVdojMp2LZNzevbg7bM8etGjAatI80hh6gIk2dxHr+sFFVF2TSsk8EH9s6jRPSLL/uulAjeM82e3//+R2oT+Ff/8j8T36CPu3FADjuzk0FCjPvhJsaHlBKRtAt55Q1BUE87OeULjHvX26TE15+XJDYp41ytvh6sJGG8gsiQs0zOqxgiPgjOyy096w9/Q9GcKE6/Im9P5GXFtKwyLtw2rh8/S/9rB0Ybk2PzUiAC00B7OOE2h/Or9NY2hYqKPBPJ6zSN1FVB3Ta8vrzifJCQQ1OzLo4iL7nf7hRFTt009L2EaxKa6+PBOM6QoK1btm2lKGWUmhcFYZtIG1R1Kw8S3svIcxuZxscufd1lqPsOa5w3mrqmblrGceR2f1AUliLJmFwlyK0i6RKsZh5nMm0Zpomyqqi7hs07IuC3jaLIaHZIs9YaU5Ry0OeJsR8oikJK80ZjtcaoSLKaLUa2kKiKAoVhcxPKaNquFqZrCrh53F13DVbnxCBw+NvbdQ+LZBhEiRTDhk+KssgZF9m1h02wciFGsbCMM2UpQZy+7wW07j11XTPc3wQL5z0BTV7k9Pc7h+OB1WZCBPKyk6279muP0s0TYS+nWyP1IR9ljbAt856OVTRlRUIx/hNa7B/3ceg6hsXTNDXf//A9TVOTW4NbZpRSvH8+8/nTKz98/zPd4UBbN6yzaEhMbrA4urbiMY5M87aTzYOMDkzO9HhQZAVu2+jHibKoWdwm+xKleXu7Mc2zkBmUFiPBJvqc1XkKYylykXOqrERH4ULmSRGjl1DGPLP6DXU8E/zGcr3Snp6IQcn8m1loC7VjnUaRV7bi4JrnhWNb40OgqSuq5omPP3/ier2Tl7KMrqqGpinobyvTvafqjhy6A37ZyK0UrQVULExQm1lYFia37B2dnLKscZsnpEi1M/OKIkODjHZKQRzFlPCbI4RI2I3Nx9OJ2/UV5z1Zbgg+incLwMgtqq1ERLkFDwm2vsftI8PKGmIUpQxASoFlGlFJCteQyIocmxe0bUPdNFzOR8ZpBAVVkTGOwtlMUbGOE9F7ks1Imyc3gMqlfxgiPsHULxRZzuIEUdd2B0KKjEOPVYbXz68cz2eMMYTgqfNyH7FC7xYyY5iGnn/zP10Zp5n/4j//C+q6kNcBUvRNSsbcX25eIUjSVg6xtMfIhWai1Bd325eajcaHtB9y+40uiTpJzryETlKriFEO2hTlvyl2rUsyeCU9qi8/TinFOl7Z5gdFc0Gdf03TXDBaMYWEXwYgYY28taQdI1YUBpvleDeR5wXztLF5z+XpxLZ6EgG3rmzOserE6mQyURQlhIAPgc15+sfPVJWwHGUnmFGVJY97v9vFoTkciCl+jdYTxaCuTAZR/HbeO9L+hn84tETvqVuh7pgsF6LQNBH8xpgG8iBf55Agt5ambZjHibglxnkiL0pxwbnAOC+03YEUdjjC4lgXYWqWZU2IURCA+745rA6FdDK1tkyj0EXMbjvZfEBpw/l8EgffMmJyi7U5t/tDYNLakNb1Kz/2enuglWK8PzgcTyzzyOpW5p2Du7mNqu1YV0dVlizzDDEwzjOHrsMHyLKcw/GA9xG/eazNUEpuaFqDtjnH7iAp1Um8obaoSBjWZaLIS0KUCUTwXgr6ptj38TkOSZDmZUZKhuHxICsrilbg1jaTqcef8uPP/sB7u92wRcWtnyirluA2pm2laVq6RsgVh9OJ2XmGvqepK3xIXH9+4cO7J3HW7WPGrCgYhgEIuM3j5ihz/9nhY2RZF/pwpWsb3q5XWXIbQ9g2rFb4JN+0TV3hlpnT6cA0zRhjMXnGMAxYlTgcGoZ+kH3TtmCMeLBSdDjn5c11W4lewMbbtrEuI01dYkgsy8L99kZzOLLOnmEYWOcFHyTKXFfSIVqXibwqiV5GXlWeEzO9JxNFP5JSIK6r3LBSg/Oeom5ISTMOD47nJ4iBdZL9SYiR/n4X2eo8oGJgW4VvmFJinkaqIiPXmmAsqETcFqKPmMxKnN5A07WSKstyCIll28irjKYUsgNJ0bUHXj5/pGkbdJ4TiJBlpCCjYqsFhXR5/8xwf2C0IS9KTPTMbiMkEcyuy4ZRlnFdeTof0Wj6cWIL4qwripzbMJNC5HQ+CsUjy5jXidP5yLo63u43mrLGb4HNSNrV+Y11mkTKWwhRJqsqsrJhGj9JF8k5/t2//y0fP73x13/5C7778CwVlRR3K4CAzr8wKWOUfS9ACuwHHvAPfgwp7aP0/cfF9A9GmF9wcHxNwu4/RQ69LzfEJKNNi4FM/r3ff25R5MSUcNMb23RDf/grTt/89U6GcfLr7NdMkzVYW7A4hwa0smKxj4GqqsmsqK/cvCcLa0Fu5ZllXqyIghX41ZFZQ3k4y45rfHA8XVBac+8HopcYu7UF89izbSvH0xlrc7IiJ24enWXcXl8pq5q6a0lJMcwjl/OZZRy/egStNVijKYuM3q24yVHkhXRxjydW5yhCgbKyKyyrijzLmNcFbTWNbbEmwysEhGAsSSnKqmTznmWecW6hKDpJSJZSOQHo73fKpkU8HElCH9qikTL45jYh9iCdxsxopr6nyArm1QmfdRbh8DoPZEXO9e1FYPV5yfF4ZJpF6uo3R0Ix3R+SDj6f5AWjNEUpJvO3tzeUMvL17GS/OA4DmBxrc5ZpIiWZYBir6G9vFEVJWQr3tb/f0WbXNWm7szcXHtfrXtRPqAighEi0bYDfpbXr19fRn+rjz/7AW+aZtihRWsnCPUWU0fiUuA6zKG3wnI4N0yykeas11hk+fX6VvpbWgn0aJxSaFALbJrcnFYWzOc0Tx8sT3kU+v1wpmgLlPTpKx0vpSG601AvyQp6ikcTnss4Crk2BsqqY5lkIJquMCZVSsiMjEQ0cuyOvrzes1Wgjqo779Yo1Oe3hwKVpePv8ibStlEVOWWQcDx1uC2xBei7jtHC8PDP1jz+WhAlkmSKtggryacFkBm0rtAlCpAHmaSTLMrrTga6tWcZJKPth5nQ5SKfKapZ9eV+XFbfbDWUseV4RlSIGv8tD7VetzDLOmKYgJCFZiDSzEIjz6kjW4FYZk2xuoqwVdddRNRVRS3FXW0NZ1xyOR4iBeVxYl42uqanLgmWVgIwtLGhLnjWEbWULktLVNsNv0gnTCnSKjIsjItSQn3/+TFFkO5BYGJygKMuatqm43e/oLMdgmIcBpaFsGmLYmYcp0pYFy8N8PZBCCLy+Xnn0A394/sSvf/mB86kjzy3Cf5FbF0qEvl9uc1/eC74cgErJ7ZB/IKVV+1gT+Pq/cudNqD3NCZKE/aIJinw5sBTohNYaa6289kmU5Q5F2AMPcfiR/ndveHvGz3KzMMYAUDQNSSWqqmDqRynsl6XszLOM4X4lpS97y90lGUWfo5SUyBXST1RabkTT2GPyYqf3r2RViTKWGDacE7al0pYiK0QOqwyr31ged+qmIy8L+tsVY3PAM04zRVmxrHtyFxh7qfHUTUWKiad3zzRdwzhIP61/jBht9zCQQusMFdkfPmfOlyeqouQ2jpyeWm5OsIHLNBGTIirFugi2y28em+fS4WxamqZmnEbmaaVuG8H3WbOXxy1ucaIOCw5b15zKkuvtRllVwmidF9QOzt62wLvnJ663Hm0tLy8vclOLke7QinlFK7Ky5na9y3SpNHj/AAx1UaGLDB88937gdD6SUuDp6YkYI/02cnp+5n67E5285tZ5Jni3V2PkhSj93UQMQb7393315qWyoZSR90UFhECeZwzDTJFlf9Lz4M/+wMtshkEzDhNVKakvbaQsqkjUVYUbJ+7LLDcUN6EV1KVlHJw46NqG4fHAh0SR7bu2dWUaF7RKEDbKquZ2vXE8nQmrYx0nFIqiKkAF5tnRNAXrNDIOE3XbyR4rJYqsEGJLFknA3N8pq5Km60SFkxTGGhQJrQxu9fggPaYyE1xWczgKeX5dMabicHkW+oISgatOoHOLQvHy8TNlVTJPs7AqK8O2iStsXZ30bMpckq1xI0SFNiXOiVfM76Vbk7SoeJA39WWZuF0fpN1LltD044pHUzTC5ltWQa0VJufe91jjhQpiLGUtFJo4LZSVIatr+vuN9nAkK2QXU9cyOi2aA1VTo/WuJCLwzTcfeFwfZFnOu6cn3t5eyU6dJE+3DbfJza8sS4w19MOw0+WNdB9j4Pp44NaN0+lCkVmW8bE/xWeQJKm7zlK0P5/OZAZujyvd6Qmrck6HM7NfcYuTm1DcmN1Kkdfc7wPGwPK4s8zz/+omFAHnNn766TMvrzeOh5anizxQVFVJXQsnUZInf+y46a9G6D+CmvU+4vyHwRQZW0YikbCPNpVMMPcfLz8uJfk1g9p3heHLSHT/OVqK7MYaDIZcKTJjMVaT547L//6v+fzy4He//xEFHM9nbCVVnePpRD8OqCj9Vu9X4rZi8kJ2n26DKCNrmTDITi34iNGLqI207H60zYRFqi34wNj3NN2RRPh6QMsYVPx+TdcyDzMAZZ4x25y6qSBJ+jcFu9cWZqilIJ4XJfMqVKDbbcBtC945rDEcLxd8iKhpwm+eGOVzJaXoTheReFgrcl4nt9OiKJimFUgy2lxnbFajbc40Pmi6jhAjt+sdYzSnQ0PUBqLUJbTWoikK4D07eHzFVgVVkQthCYWPHpM0ZdPStgVLP/DduzN/+PgqLFlrGd3Go++JScwdZZFxG3vag8hf87yQiUGCdVpo6oZlWZmmhRA80zTu5fojwUsKfltFDdZ0R5apx1jLNC2kuFGVFaCJYcMWJSqTm32R5RT755p33+S0OnlPctPXB7I/1cef/YHXdS2TCyKdTJamLnm9DhgNZVXTj4MUqU1kuIuKwq2eupKnppTAf/7EN9/+gnUYeRneqOuSPDM0lYhVY1ZC1Jy7Ayp56kpuNGXXMq0jTV0x3GfysiQrCsI8oJTQ8RNRemPbitvk/x/OF27XO0mt1G2HTgGr9A4KVqxhpT52PK4vpJBx6Dqc81Rlid9vm4pEd2gJQQIyfg07Tg2qKpcid2bxTpKPRVExTvO+i5DRxPH5HUYbTKYZHg9smUt5NCo8huAXlJadm7FOOoo2MY+OlOcEv0nlA8XjdhUnl4ms051NWcpKUmu5Ep67cwvrFmiOZ8oyZxgmigo2F4g4jpczNsvIppn2fKJ/9CidKHblzOw2bFlSGM0yj6LxCYnj8YCLkabtGKYFNy9UmeXcSaBoXGVPazQEDCZTTPNM4cVQkZLfwd4eqzRFWbAujnkcmCY4nC+UpZBgiIHMKlwI+Ci3IecjKkWaSnam4yjmcmssRVOzeb9TQiIxyU315fXG2/WBNYaiyPjLf/Yr/k//7X+JNWKyBuAf7O2i3w+0fXz55bCLe+UFxf96XIn6Ot6UX0puhn88LJUcSiEQdwJGllmqqhD+Y1HQ1DWHriPLM/ph5uX1zk8/vfL55Sa/pjbk7TPr5rFGE/1GAgprKIqavu+xNiPFxDj0Eh7aHG1Xs86BdZlQUSLqMSas1dR1JUGHzfPy+RNVc5Aie1VjbAZRNFl+2+jdSpbJ+HXsHxy6lqTEIdl2HdvqCNFjsgznNrpDR+o6CQOpJA8VwePdireGsDmBRq+OZREvYtgcKiVSUCgNXddxu95ZldRwjDZUVYVV8t3edi3jNODWde/caVYnlgi/ebQ2RCs3XrIKvy6s04i1BmME0dXWwsy932+s80x+6Cifar7//kfpM5YZ3geunz9BPGK14b6shG3l2IrENgWHD4qyrimKkmkcaQ8nQvBkVg7/PMvlNbSnVrNMM/Q9h+OJGIVC5ZynbWvc4pj6gcPpxOrmvTojzFi/gUqKkALDY6I7nlAoVi84wmWexAPqPVFJ1cItK9pmGP7pwPtHfQyroywqjm3NNM/M/Uhb5iQUw/1OP05keUZuJJofvccn9UcAc9lggmeeBtbhweZWphQIZUFShhBWTCYx2vExcLoc8evK+ekd3juCX3i8vmHLgnmZ6NoWbS2bc8ybE8TQJMmwrKhYlomy6/j2l7/m08efUVZR7fzMdffMVW3HMIy0h4MccMNMUddszmGN2BSWZeV6e9CWGVV9EPpCFHqBzcrdw6Zomka8bcHTdi2PfqDINMfLSWwR80ZMgazIiCFhbEZyDr/O1JVobIzNSfsTZ0qKw+ko4yECIYgi5Xi+4INnXSOaSF5qIeZbsxen9Y46ytE7R1IbTV7m0mvU4h40mUFVEnN/evfE/fqGNgZjNNv+BudTRHkZi2zDKLxFpZjmhejdDhPYyK2lbBuSyVAhCm0fYNvQuTyZbyHSNDVGJ4ILGKsJIZJVJX6dUUbsFwDbOoNSBCzdqSPsBoNAIqyO26u4BOuuo25a8iKnKXO01ji38uiH/eBLEKOwJ6OUx//9f/gtWWb5l//VXwv2bE90khI+iu1bqoFybZNwi+zlYopf93MKSLIe+nrYhSCnYAzyOSERYiJGZO+ZZZRFTtvW1HVNXpQsi+PRT/zuD7/l5fXKMIyS2NtLYoLcS6xTz/nDL78ewk/vcob+wTiNJCArKhlpaTlky6rjtqcwizJnmZOEpGIkJU3/GCB5mqahPRwFmpwidVkx9nfKQgDrKUbqpsP5DbTB5pZpHFBaXm8xOMBLshhJAgcnXbVt89RNR4wibhUVkCFTMoFw68rt5SNlcyDLc6ZppqsLtm3dgzSIwHaT95LV3WjrktV53OJo9lBXeezwm2ebJ6yV9yC3LMIV3RxutUx9T9nsh/wixXYXYL7diMFzvpwJKdFfxTBxOBwYx4ltXTicz0zLTN20VJkgExfnKPKcQ9cwL4sAE6oGZTK5YQNKyW45yzOxpIdNAjjacr5chMEZE3XdMC8z8+Ko65amalDakhcZb58/Ek2kPhxYl0Vedz6QlxqTWR6PQXIJKbEsK1XTkGmLtgKhlsRmxv2ffHj/uA+/rnhluLsVt3rWVaSgekcfhXUWxFFMZBZO5yOP+4BbNsqm5f72mbqu6ZeJlBJF2UhycnWkGOiammmZKasCpxVRa6Z+wORCdbfWsM4zWVGQ5bkgdPKC7iCQYx8QJ5vfhCk5D6SqZvWTHEYxonTGtjmqqsRYy+12Y50XUtgomwN5IZHn3Crm/Zbmt4A1sK0b3kcym+HczNPTM9eXFzKtaepaEmBGpK3zMJAZQ561rJuXGXpZErzDZiVrXJnHEZNlHI4XFIkQpr3QW7GtC+vmCSrH2JJcy5ue21ZUTHRdS2FzlsWxeY/NjBDrcyGHkBRNW5NXpSRhjdy4tIEyyzGbLL8JHqtqVIxUZcW6rLgYcOvC0/MFkxnc4rBKc+ha5k3Gc9vmqcqCZfHEkBiWEUy2P9hkKFszL4LP0lbSlVYnlmmlrGqq2pL8QpmJIdq7jfbUcb/fmIe7FHD3kJNvDxIvT3BqGu79JGJFawnAMIwopMCvtaIoCn7x9C3vfvXP+bv/5X/k+vlHuU3vnah1dfx//uY/cr+P/Iv/7Fccjw0KJQLS4L+u7WDf8QHsu7h/mN6UHZX6WlGIMf2D3p78fK3VPzjgKuqqYV4cr293/vDjD1xvD9Zl3Tt+ewovBtgToWofs+Zlw+npPVolmRTklnV1hLBRlQ3vPrTcr1cRnC4zTX3AbwtVVYoKyMnOeXvcObanfS+UY2wttQFjQBtynRFCoj0cdkD6hs0yAWqvK8OjJ2xhJ4x4/DxRNy2LW0mbx6+SMtRZTt20GDWjUuRxHambCqMVyzTsqC4t2LDE3nmF6D3324O8zMmKgjz3bNtGURU8rjearsNHQ0h+P0g2+scNv7WQCfSBBFuIzMsCJM6Xd3uqUdG1LbfrlW1dmWeHySyH8xHnpK/rljsJWXt4H3aptKRyD4cTj8edmBLruAO2Cbh1o65qeU9ywuPVxpLlGSmKQzP4SN8PLPMsYPgYmKcRHwPW5rTdgXmepPtpYFtEGB2sJiL7eVBUeU7SmrHvdy+h0IaqsqC/XkXonGWsQTqkRmmCUizLRt20f9Lz4M/+wHt7vVLWK+M40jYtmbVkSuGDJyTpgaTkMVnJ5jc+v1wF11XVuGWlO11Eo7LsEs8vCC8t4i3nI0qLPbtpaiKRp3dnkvdc7w/apuFw6FC7GHJ1AZUeXFPgdHmm6Spe325YrTgfD6xFybIF8kwLudxaykri9K8vb/R+RWlAGfIqF/P3vBJTwOyFbh8Cx1OHWxaSMmRFwaFp8Zvj+vpCVRRUhwO3+30POiRiUuQ253K5MI890a9oFUjBopR01RRJfGEhiY9uLx0LMWKgLCxtKylXpTSLC+S53JyDFymqj4GiqciisDmTd7z78IHH44HfaSpltOjgyaqS+zjz7fMTcz+wzGJR3gLch4Eiz2irgqdjy6ePnzBlLmVeF8VZ6DdyY7EhyW1gXSVxi6hj6qbhdu/JihLnA9HLMr1t632hLoDi4DfW6YHTFqUg0x5lIG8q2fmEjaJpyAtJtmWlpqhqlNHc314lXJAZzmVDinIoNk0tL9A9caKV4rvf/BXvf/3XfPjlX/Lb//j/5Xf/7l8z3l/Ym+Vs28bf/+4PvLy98Zd/8Ut+/Yt3u2NPAiYxxX1sKV9/vf/iXwIpX25+YT/kviQ6lZIbWVWW8lCSF6SkuT8Gfvv3n7jeHszzwrb719JeYZARakTvByhRQjD5vitmT+VN0yy35dtEVlSi3dmEqHK+PDFOE8pKsTqRqLsD2zwJ1aMohdKxuT29Cus0oQy0VYVWhnUTWLPFirECjVaRT58+8qXTUZdyiDqHyJ0r0S0pNE23G+nvN4HoakkpJhLaZFjU/ma9oZJldSt107BuG4lE1TbyFykoG8ZxRhnLsW4EvedWrMpY5oksL6SsnZf4FCmNxhY10zSzuI2sqKirAr9tInsOMA4TwUuQymhZufgtMt4fFHVNWXfkhf26b1NKKgXOCflF+nea9nCUvdpww9qMQ1Myv11ZZnkIqa2CgKiolpVCWwyRYAzTInu8phWLjHeOsjCSpp1GqsxwPDa4LTEMPW5zKGMhysRiHPfeobFfpcsheFFSxUhmDKoSU/o0DuLhDF40RH/Cjz/7Aw+tGaaRMssEluuFhZeXFetedFy9l86duF9QSPJSG4tbhUJxOh3p7ze0FsIIJicmxeo2lmWhMEYoIVH2hYSARoldvGnQiIIlhgdV3ZJSYhjuLNOA3zxFd5SnN52wOjGMMyl4qk4IL0ZrnN8IIVHk4n7bYkA7T0waayxKye8XFcjUl9vqA8LG29sLTVNRVGL/3vyG0Yp5nER4u0OY52ViXiZya6nrA49+RKlM+mCbQ6tEnmk2v+LWjbIsaNua201+H9O4Yoxl8zPH85nFLRS2oGvFXm2zDFKiPR/k7hKFcmEuJ9bFMY2TQAF8QAUJ9bhlZRgnbGFZgwdrKKzBxMTryxttU1JUJWjFOK9UZYV3MDwmcptAGe4+kJDDpm4q0HAfZ0xuaY8Nby9XFidff600ZVkSAlR1RQRyk5EVBWv0BGQ8oyKYzPD07j2LE8g4SomM1zuGcaZuW/wWSEqYiSSoq4Iyk9eR7MwkN1nVgroqreXXf/nPef/hW37+3b/nd//xb1imQUaYMfK4D/zNv/1bfvrpM7/65Xuen46UeU7ky/4uAeFrIOYLdeWP6U4ZExZ5zuHQUZUlKSnerg9+94fPvL3dmaYZH8LX2yDAF7ILfCG1yCHqUyB4Gb2u68r5fJZvPWMYl40sK9gWz/P79yzLwjBOFFXONPasi+C5vvvFL5jHUUadUSzbw3SjyBV5bmT8Xch+rcgt07zwcDe0FX7mPK/EqMitjLbz3Io9e5rJStn5WSMQ8aY1zOOCNRlF1eDWldWNbNuCWTWH05nr2xsxeqzN0cqSF6U4GDNDmAL9/UFWllhjSD4R/IItBTJd5jlYIyPDcdrDJIaqaTCZJc9L1qVg6G/EJA8ywTtMLqVzazKmZWYeR+qqpOtqqrokes/Hnz9RVI1QlYzBrytznFg+DjSHI017QEdPQlLiVV1JkjzJGHxdJ7TKOJ7OrPvXjATHwwHnVpJSZNpgrCWkQJ4JJ/R0bHHbxuwcWZFT1S3bunE8HqiqgnkcaduSdZrwzvH8/pl1XggxUeYZuY/SsdwWkQtnGUVekmqNItFPE7Yo0LvBRlyfQlD6U3782R94TVVK6jDP8F+pE55pXaQ7s8+PTWZ4fbtTljndoeP1fufy/Ix34swLXmjg2lgBue57ApsXtNZgkEJy8BskzfH8jPv0E/mugEHL+CmiUDojeU+uRYOTQmAeR8q6ZF2cvMkGiTsbbVm2GV0V1E2Nm0ZicCQiOgEhkjYJsShtUUbYd+sqsW6bZcIPzQsew7hTVmQ/l/Z05LquJPZOn5d9XfAihS2qkmVyTIOECTyJqe/JjCW3muAcC2kXWVaETLQ8XdfsNgbD8VBjsoLbYyDLctZhRkVJBm7Bc71dqSt5ki9KoeHkmTwgLIsmL2rKaiHEyDDOsnNVmhQd7d5ZPBwOKCJtUzOOEqZpukZGLMHL6C0m2k4MC/O4krZI93Tm7dNnQlS8e7qwTMPX147SmnXdROq6CA7KGHmSfX15wzlHbhru1xtZnu/EfSV/xs1R2oy2Kpl0YJpGuuOR++2OUrDM49fDR4gosCwrXRLaYFYWROCv/tV/z2/+8/+a7//23/Hbf///ZhllLOQ3z6fPb9zuPcdjx/PTgUMnEGa7VwKUUl9pKtYaefM8dNRljfeRcVr59PmNzy9/zzhOeB9JKYol4x8caCj4IxmTHVm2F9FtQd60vHv3Sz59//ds/mf53ChMlpO2jcc4oWLk/hjQKtEeWjbnOBxOjONEYS2ZikwpUlq7J2YT87zSP640bUvVHVhXR11ovIo0h4a5l5VAmFeenp74+PFnzodvKIqCYbyj0kZSQd68t4APmwDYVaKoG7IsJ6REUgrvVuqqIc9zfv7pR6pKiCZZZolAXMSQARnBbxhj0FZCHMfjE2EPBCmtSVq8c9sqCdSubBn6gaQMCs/t8QpK0daNYLZCoNx7eFop+uFBDBFblDwevYyOEfxXVhbkmd6rQZa6alDa0JsMa+1X2kqWFyzLJMZ6oO6OjP0dm1mWaebl4yYEpFVUYS6I2JYQ2LaNzFhU9AzDSnc8UFrN434nLwoKY2iakmHsSTGSFxUuq3l9GynznOKYiwkkbAKeMEYIQtaKaDkqMpMxDrJbz4qM6d6jtUFrxbJ5NKLP4p9Smv+4j6F/cDg9obSisJmUJoHucCCGjSKXwIBSotIgCVgXIuM4khn1FQWVFxV12zJOE5kxbCkyjyNVXaFTZOrv5KWgcZZFdmnGGmICk1msSry93njcXqmami14Docj/nYXTJG2hORwWyDLSza3sky9xNuDPGU33VGoDRGeLxfyIueH3/9eoLdevgnyzOC94fZ2Jysymh20TNwwecW6LmxrYp4XFudo2451GglpwcWEMlacWm9XqrYlJuEWanNkvt2kN6U1oMUdFiQhWtaVRMDrimNXo43l9e1BmdcEEt4F2tLw9It3XK8PjMrI84I1OIZ5kYKr2zg/PbGtK3mWc78/GEeDcwGdCeQ5JZjXSJWXTFMPMbBtQSgYOfubkRi7TVNTlDV+WXmMMyYmlv6BMoZf/PID67JwOR2Y543hdtvTfvIQkGWWEALLPFNWlWCbtOJ2fWCLimFaqIGqKhn6B09PFyDx+vKKMoIyG6ZFup1GMw2jhH60xblFuklUQlXZ3xBkrCqHlTGyg9ZZxV/8F/8HvvnNX/M//Q//D+4vP4tWCMXqHC8vVyHn5BltU/P8fKGuCi7nA99++17CO1vk7Xrjp59vvL39jr7fQyZhf0NRfCWtfE1yKk0kQhQKTYwBHxLaljz/8lfkh2e645msbsmN4vHykREQlx0cnr7BlgVhmsREYSxaK9Z5ljh8aambBmsSRVlysgVvry9k2pOVNUNdcDz9miwzJGP5+fsfmVeHNprkA1oJE7esSh6PgdPpSIwbw7BIMGxd0cqy7L1RjSLPc+Zp5Vhk+H1vGbwTNqQ2xJho6gZtLNM0gvZ03ZHgHyTkgaCsSmxWkBUFKiWCnyjLHOe2PTEbWFOkqmvWZcEXudy6VWKcJp6eTlxvAlpHKcqiYAtyEKG8vMmrtItjM5S2VHnGuAukfRCzgTVifRjuvfR23UJRluA2VNScTyemaUFrxe12E9m081R1I/SnZaWsa9Su/grJY7JcDPMpURUlhQ7EzeF0xvn5wjjN+KSYnVhN8rJmXR0xSfDNR5k2Pb9/Yh5GlMnpHw82H8nyjKIqSUTmdSZtG1kuWqiwh6WyXFYybl041Ac+Px5/0vPgz/7Aa6pKortlxbpNaGPob1fYC7RDP+5opsThdAJgGgayvGQcR7qmoe1azucz1+uV/i4F6tltPD+d6fWDx+PK0zcfOGQF8zjRNC3TPFJkOd2hYRgmpn7keDhQt50gnqKiKHOutxvHwxFjLNfrjTwX3YefF5ahp/3wHrdFqlqKsdN9xG+Oqmn4+OmTvEHnBffbjcuHb9g2x9vtyvF4FmbfMjHPIhJNtiQGxeom6b0sC3VV09S1cBN3bFJMkcftTlFUTP1MiomirFnXhSzP+fbpRNh3cFkuEf3gZa6Pgqd3z0zTzDz0PD2dUCmSoQRxFuHj5yunY4NWirfXO1FrCeAUBcfLAaU02+oZcWzOEyqJ7KfoOe67L79tjMOIMhlP7y9oEtO8sC4j5R6ySFjisjH5GZ0JPUMHT1G1TKvjPq6QIiZJLeXdu4vs+YKIRLM8R20rqm1Yx5GyLNHW8vj8me544nTo0MYQA9i84KePn7HGcDqfWFZ5CLD713OMARU9p67FbYEff/iB4LevvsOYRMvyvigpiozZibdPo1iWFe9W8rrjv/k//9+5vfzM3/3bf83t0w9yE1PswRS5jtlspB9mPr/c+Q9/+weUltvZl9Hkl9EmX3+OkPe/7PnYb54hBkltKktWHTi9+yW2aDhf3nHsjiQ2+lEEyVob9O4eNMZIMX9Z0CGJSigEysrSDyNt0zBOEy+fPlE2zV7A76mblqbrgEQ/9rx7Pgu5ZtvQKH7z61/RPx5M68r4GAh+pe4KpmnhcDiyuo1tdRADh/bEmCAqA2m/5fmItTllY1iXQAqr/Ps9jUmKYhfJS5z3Oz5spn/cSdFTtg2H05E1L1mmnuH+is1y8qqR4FMuB6Y1mnlZ8U64k7k1zATKqiSPGUM/kheV6INC4vXtFQU0dc2yOAFBFyXTvAgsY10xWiYe0/Agacs09VzefZBDOiW6umHd3XFZWaA0ws/VoNBkRrMtMzav9ocxJ9MUtxJSZNsB2UVWsC0rpbW4dSPGxOl8xG2OZVrwW4QkY8YYI26Yvl4QjqcD2uYMQ8+nj585X874kHZqUKDM5P3IKMW6rLSdSHf9tmPbfGQaR/I8Q6uW6+sLRfFPxfN/1IfzniwrWaaB5w8fWOaZrRZigg+e5njm9vmTwFpNYJ5nmralrFuub68M/Z1lE1eYQdF0Lc55puHBjz/MPL17R9tA/3rHKL2HTQJNJXs2tzrCtqIV3Ptewi2HjnXn6xmt90Rg5Hg8yNON8yQfePfdr0l+xruF6zyL603B5XIkYFFa4byobMq6ZJ1HjNIcT2fur680TUvTtKxuZZwcIBF0pQ3aKtq2le6b2/B+w63rvoeYOR2PrOuCMQabDKfzhWNbcr33/PK7b/jb3/49RdlSFTnzOGAzvZPm4Yff/YG8aSmKivv1yuHYoY1FWYMKkaws+Ph649A0aJsRo4QXgvdM/YPM5oIo6wcOxzN1VRCifNNmeU7YRLdzfjoxTSvLsrGtK01T40Ni81I+VkTyWsC19/sNpaz8PjRCMXEbj/udsixpmpJb3xOcozs/45NhGmaUSlRdg3eecRiJlefp3Xu8j8zzRFVmHNqGsDnev38mpMTnT69Ym1FUGdf7g3xX1pAs99c3qvZAUUjH6R+Ck8qyxHs53PPMsswby778Vztwty5bmq7l+PSO8fbCf/if/gfur5/2Dh/AlxJ5wm0SAjFGDiGhsCCHbPzjTm+nWO3ldHnwyeoTWd7wF3/9L6gPF679hDFSOZmGiXERJNe6RW4vbxyPJza37axFvadANSFJF3ZdZt4/H8XMgLjgrM2EVpM2Fq3JSzkkpS6hBW6gPdpYrrc7Ns+xVcF3Txf+4H5kixlWG9DILa4oGaZVRtgpkVc10zByOB3FwYZnWQayoiCGIDLfeaWqa5TWUm3xEa00T6eGeRbdkzaKrO5IKfL55QWjFJtbIWkJySjFcO/JswyjIso25Fax+YBzK+M0kZJi2/xXUECRF6S4MW8LKUHdSDI6pYQxhnEcmReRBS+bp24qHvcrCciriuZ0xC2OdRqweYayGVkhHUSSjEmzosRoJYQeFG6LaKOxCjalGfsHVV2SVR3XtzcyFG2lccjNmeAZhwdunehOR+Zlkf386gTdVxYoFYjrIiCNdWMbZlJKPD09sbjAOPa4TXaJa3DkVcGh65jnBaLBGMO6TRR5IfvgzaGRLqjWFptr/pQff/YH3rpsmLwkKs04jBRFwfHYolLg0fdok9N2LSolhn5iHB9om5NiDynSHc9M4yiutjzHryvRB86XZyEPzBNGw+HQsm1yEGq3fI2Tt10HWnG/3Xh694EQI+PjgbEZTdfyuF9ZF5GtPq4vGC1OstxmbG5m7AcOXY0xmtVH0f5E2LaFZVk5HDuWoaduDxjF7q6CoiqZloV2H2mSIusqBuLXz58IPnJ+ekdSim0v34peZ5dvGsN3v/k117crKW7UbcOtlzfvn15uPD9d+P6HH/nlL75jmSbquuHyfEQrTf/omZxjcysfni+M88z9+ommaWm7hnmeeDoeWNaFw6nj/uj5/PKJumhISvYiddVS1CXLsvIYBs6nA2Pfy620rum6A4/HgyLP8UGknqsTKHdMiaathBUYNt4ePcZovFtxSizTw+PB6elMXeXijkuKkAwpKfw8opIU3lFw0HA5HZiKnHWauL5eWX3gfD7S9yPJex7XO+tS8fR0oqrkJj30k4yCUyBuSSgUbSOotHlFQq6CJsvzguZwEh3N5knkhLjgFknvlVWFKTXgid6T5RWXb/4Z/+3lG37+w9/y+//wPzNcX/iydPuHpfI//vMXmorMLFMSrFlEQ5HTffiG+vSOvKh5/803qH3nsjnP4dAChtvLFaWhbRtcjORlKbstnchys386URe5EOiHO0/nE0ob7v2EW1di8BRlhVER7xei9/ziuw+83a64ZSYva2EvZjkuJHzyNF1L19SsXgJNp6cjZSFeNudmwhZw44jWhi1KNWRzUiyP3rPME2VZ0HQHyqrkh9//nvZwRhUJksLNE+yYOJvnTKMYTspKOrvzOIoay3sym5NlGY9lInMBW1gxP6RAUeaMQ49bZ+qm4/03H7g/Bu63m1CN2o75OuF9T1lYqkKYlClGTpcnXj9/4v64E/cdd5lnVFXF0A/4ENFZiYqJdZzwbqOqKhKB8XHjfL6wrvL3PSyTBGL2W317OlOkRHDzbiswMpY1mQR4spywbYQgvsl1niQ4pgxF3YjOKyS8F6cgIbBOCykG6rqkrWuu1zc0UteY5mWHZMvuPEUlTsjNCYHncmEc5AFT/gyJZRxQJiOqhNaWrCqo8n+64f2jPvLCoJUieMfHH994+uY7TseO9gCb88RtZd1JAsfzgbaricmidSTPC5TJOBY5j7c3Gn2UxNkkt5YYPOvqJVUYIN/9Uavz1HXDMg07Dqujag8onSS9qRQpegqr6bqWujtwe3sT5uImMssvacP8fGTdNinlFgVOKdbVE5U8DS2TGNo3F1iTGJJVluGdWJt9ApwnRs86r4Qk4zedAqSwkyYMKSbO796Jvdl51nFguN85H6QL6Jy8gG0Mok/ZIk3T0g8zVXfg3btn1G7ZXv1G0zZ4t4mwM8Hx/MTbywtKgTZWUpda41ZPjHDqOrFv+0BWljRtwfff/0yeZzR1wzSuvP/wgXFZMEo0I2VRkPxGlmXc7je++fABUkQjksqXURyDRabYfOJwkCf52+1BezowjaNg0IoKv05iuC9yyqLgdh/ougofEy8vrwS/cTqeMdZwKCzTtMoudFuYVKQ7HpjmBR8i75+fCAler4/db2fQOuPpJKJgncH52Hx9jcotzACKn3/8UXqUUYIwVdOgM0+R5ztfsEebTEZVJtIeOn79L/4V3/7lf8YP/+F/5vv/8Dd/vMnt90e1f44E+BDZ9mSxMQZtMv75f/t/oT0+o62mbmqInrfXG/XpKB67QkI4hEDdSIS+azoeQ0/dNiTd8PbpM/PQ738gwfednt6hkS7d6j3udkcZ2dvdrm9UTcPpKMXky/lEJDENYovXOud63asqIWKznM0nkpfy9jT0FHnO8dDx8aeey+XC2+2G30fJcdvYQiApze16pzse9pJ+ZJlX8qLav+aBdfVgC/JMRq+Xy5F730v5PmmqSvqzzaGDEOiHCbymaVuCW6XkXndMYw8ppyoL/M6R/fHHH8mzAqsVl8tJKgtpw+QN2hhub68UZU2Mns1/xmhDXVmK7sjnj594vd549+6ZrLDUzb4T9CtV0zGlAETMnma8397w28YWPEVZYrVhnmf5WixSPXDOUZRedmgx0DYV27ZQHw4s/YN1XjA2Q6kcrTbKTKOM5vEYyWxGSIplmsjynEwrQkqURc3Qy37aGKl0TNOEtpayzGV0icJvkW2NzMuKsTlK6a84tXHo8T7SVjL5CGFjmgbWfxpp/uM+UjQ87g/RAl1KMYnHSFlVVE3Funq6riVFwVslBZufeXm501QlpqhJyaOMJKNM11E3DZ9fXsUwUFcyGtJSUcjKihAn3DLKfm3335V1RdhxRUVTM4+j9JO8Bz1DUjxu8vv0UV7E9/uD4+VEqRTrujCuEyGAshaS4nQ64f22pxQzkt8YxomDsTw9P/N2vbPNjmikP9acTlRVhXcbFvk9/8WHd7y83tBG8937Z/ppYVoCl/fvCT4wPAZ5mncbyS14Eips1N2JvJRuX9023O8P+qHneDjLm3OWCb/SSy8rJc/peKAfZKTU1BVWw9vrC08fviEFcG7hdD7w6edPTEY6hSaz8k1Vt3z/hx8oa7lR1HVDCNKD7OqMDx9OkDb5ptpWlnki+MQ8LdLZahrK3LI4QSelGAV9VNTM68q79xcIG4+3O+X5THztGfuRqi4gRNq6Zp4n3Bb58P49KfWsy8T5/AQpcGgrmrbGec8PP38U5JWPZFaSm2P/YF4W2qamawp0Xny1IAByK9IWU2RiNk+esiiE+Zo8zhvKqqDpWlQC7zdJNxY5afNMQ+AX//xf8vbpJ1Jc5dfdsSpqrz6Y+sT77/6Sv/2bf839/onn5yeKosDsYzm3riStaZuavCxZR3lYyYylbGse4wNjLU17gCTpvNvLC1ldkbTejddysGptsNbsIlmFRgJkVVGyzJq8EE/iME9gLT98fMV7YTUabbg8XzBWxso+RBKKx/0h8OEUaboDVZmR5yUpfSArxJZd5AV9PxE2R/TyQHfsOraQSFF2s9ZWEuTax8dNleFCJM8zUsjwIdE2NdF5EobVyahxuA8cDi1GJYpCM04LMSTBhmU5VdvgnOPD05mUFAFFZi1+2wgx8uhHthg5P78jL0o+//yRrCgwWUZTSGVhcysxwvx4UOY5KQO0YXz0tIeTTI3aI2VZMD7u+KhZ7wNFWVM3DY/7K2VREyK4daapG9y6AZGqbVBWJkVWaQ7nE+MwcDhdmJaJomnRSpPnGT99/z3t8SSvy+DJi5p5GrAm43A84baNqe/J85xxmYlRRuXTOBDReLeRnENnluA2UgjkVcW26f0B3dGUOVuEaR7BKHngT6ANDK83jqcD89T/Sc+DP+2A9H+DH6djzeXpIjDauuT0dGZ1gZiSpNnqYi9G9vggBI4yz0EZskp2VGM/kJcNTVvT3268vV3JbAZJFupt28jTotHMgyykQ5QbWEyJfpx2inlgdQ43yYitH0bS3tvzwVNVFfM0M00zWkFwK+s4In5gYQBaA1YrUJHNb9RVzvPzO7quk3Ftd8AtK7PznJ6euFzOXE4df/EXv5a0XUzUVYkuLFFFbFbQdA1VkYM2LKMQZbz3JAVP795hsoyubfjuV7+mKEshtLiVob9SlRn97UbYVoqi5O36SlY10tlZVhklbhvT8KAoMvk8IezpRcvpdETFQPArx7YSckXwMipMiTzLKTLL0L/x4dsPBJ9IWOZ1o24ayqri5x9eSB786nn9/LKPvJ44HBsulwPnw4HcaPI8Z3UeHyMhJJpW+pDrPLItM3mRk7Th5eWV0+kgfL/NcTy0eB9om5q6Lnh7ewWtaQ8d2mhCikzrRj+M2DyjO7aUhSY4GYOlBMM4olVimgY+v1x5fXnFWIva9T/btrE6hzIGlBS3N7cxTyNFVVNYzbgsDOMi/TilWJzj7377Ox73B23bEoJUS77KXmNChosRkxX81X/133F8/m7XO32JY8I3Txcyozi0DbnWfPrxR3ldNB1VUQh6ygfKIkeRMJnmMc70twd939OUNRYxYMAf7Q3BR7Q2uHXDWM3xeODDt9/JPmeV13iGocornNtY5h1OHiPWZozjzNvtRvSOrikwWqwL1lpCgNUnTGbwbqXIC7q6prSG7nAgkGhOJ+HVKsUyTyzOEUJgHGdmt+JDoq4PeAw+gt8Czola63q741OE5InbhiJQ1RV2D2p9frmSZTmnywltLfeXzxgFRWb59HpjXWbWoZcpUvCS8t02rDJs88bt8ytd9wWAntj8Jt+fIaIzg9s8GEV/v3L9/Inm0DGOPYtbGaZZBLNtK+sWbSiqitvtlbxq9weEhN95nXlRsC4jYQtkVqhO3fEkpJmU6B83oo97AT1xu90pq5qirsDmhKDwPlAV8ncwj9IdDoDJSvm7Do48s9RVRYoB5x3r5unqjugj3kfZ/YUNa7R0YkPCuw0CHJqObR93H5qa0/kirsPm8Cc9D/7sD7zrfSAqRdUdMVj8uhBV4Pr6wuPei1EYyHODSkj5MibK3BKiZw3iwbNaU9ct7eFId7wI1oidRak1NpcYetgTYXXb4LyUnvO8kG+GXDiWpmjRynLoWty6yBtFTBRFQZZnu24n0R7PEhFGCUnFWLTNZIluM4qi4vEYyfMCm+XSA8oMT88n8XlVQoT30XF/9Lx/9yy3n23jdD5ireHl9YUQA2VZ8LjfMNawek+eZ9KJsppt89wePbdePGZZUeI2+Sbeto2yLkAb5rGnbWr5BoqJtm3khrPHr8dp4vndRTxiPvHx5YWsLMW9tWy8XHvGcebbD+94PrdYa/b+Y+Ld6Uj0jmMnIlXpS/3Eui4czy2fP7+I4qetd3XTzDyPZEZj8pz7o+fl9ZUUA5eLiHQ/f/xMWRZc3r0noti2QFGVmDxjnAcOxxYfPNM0U+QZt9sdu8fgvfdcb4MwC9uaLNMoAioECDD2I2UlAsyqKmjahhADeVFSFiVGSVVBIXs8rQ1VJQd4JGDLknp/iBkWxxo8IXpUDPSPCbePvt+/f6bMC7xbaetCkp//qyiMpPSEciM7obC5r/8txcjLy2dC8rR1gdXw/v17pmnk7X5nWR2RxLyuPK5vaKVZx4lxmsAojpczyyLhni+ldKWUWElsIYlbt3I6SE/05fUFtOF8urCtK25b6O9vxG0jy0vKssIoeH19xYfA0+UsKL3FYTPLOMnX9dRJyfvvfvs9yuQQZFLjUyJGx/O7Z+rc8u7De6qqIs80dZHRNQ1PzxeKvfYz7jYGFRLTPO/hlsS2rKQQaI8tSQWqquJ4OjFPM2hDkeeUVc3byytT39McO8GC2Yyqa9B5xul8osgsWkP04sSMYUNZRXM6oIxhXTeUzvBhk120UTtIOyfThqd37wgx0fczVdnIoYFAwZd+QkVo2oOkpLdtD4XlJKWkoO4FZzbvGqBx6Ekk1i0w9CPaGHQKuHUmpSiqoJ3ek9yKUTA+3ohhYxqFfSsvnERTygGodIbNCspSiuPvny+8f36m2/1/cfc1GpNzOJ6Jm9sfagchsmjD9frG8Sgg8nFx2DwjoYjbP/Xw/lEfzm1stzuFtSgCNss5tBVvr463txun81FeCD5yf3zi8vwBtMYHj46RXCu64xE3zfR9ABT948HTu/e0Tce6rUy3G/PO9suLkpASRVEx9wNptzarJOT5IssI28I0znSnM8/v3+PdxjJPPPo7bXdCK8OyTBASSmvGcWZzC5n11KVYw22WU9UNbdthTOJ260lKcToeaLqOdRZb8zDOfPPtt4DCe0eVl/iUGB4TfnF0XSPFZGMwdcXry5WurVjWjRSD9Ad1oq0K5j0JOY8TGkGpkQIxwrJtPD2/Q6EZp5H79YtqRG6RdV3ifeTtMZEbTQyB4+k9y7pxvT2w1sqb6zJTPL1jcgsoI/SQEPiP/+nvyYuCD++f6XaE2+kkoNzVb9RNxewCfp05Pz8xLw6/JW5uYIvgfaAuS8qs5OXlhXfv3nG6wNv1TlbklFXLNC1sIZLpxLt3z2hrScqQYpCukTJEbTAqUVlhDial+fRyoyoyqrplnFe2dWXdNrpWzNufPn+WUbKXNKzShrLIMNbuQGdFVlSCaktRYAHLwqzheDkzDTPrHrpIRpHZAuc9MTfSE00b4+xQWowahi/BlD9yLb/59V/t3c+ALbuvN8vgxaZRVAe2TXZej172O00pMtZpfNC1DetaEbz8ufKq4O31hjaGLQTBSKUvWDMJXMzLTNKaqigYhnEXBUttZ/GB0hrKvCDluRyS24LKxek29Q/ysmbTmvpwAZszPx5YKxaOYLJdodOxJehXzyUvGMdZDAB5Tdg2Lucz0zSzef+VXfrxhx/QxsjDUIqYLOcxDhxOB5ZxYJ5XskIeUN5uN0BR5xnTMOBjYp4HyqrAZgXaGp6fnnjcbiLdNZIELsqa2a2UVcmlPhMS/PzjD1R1h7YZ47CQ5wIJKMucn378hL0U8hDsHFYLWzOzGW1bs20b8zJSty0R6fOdn54kxIamrTuWYWT1ju50wq4rWXFk7HvcsnB5/w3Oe1LS5CaTyVLwaJujEhxqUZS5eSKpSNQaH8VuXrfd/p5TMYyb1JcyQ1FmLLNwMTXCPg0+8P3vf8fpdKKoCtZVxpkpJaxR3G5vVGXJ5hxZZtDKsEVPXjU4H+R2uDnyokD2k3/a8+DP/sCr2lqQNRHhvs0L2+rIckvdSOHaGCgLMWvXZcHn1xeK3HI+tixrIGwRvRvJiyznw/sLw7wwec+6zlyenzHzSNV2PG43+tsrS1ZyfnqiahteX17lzSAGIonC5qg0EIIINL1z5FVFlpcEt9AdDzRBbk/TtAqBPLO0TQ0xUbUdt8eNsso5HTrmeWWLsn/MS3najzGR5UJsf3l5oTscmKeJss6Zp41lHhmHO+8+XEhJ8fn1RlFknM9nbrc7RkFe11yvN7q2xRhD0zT89PMnOehUwodE9FHqCCrhQmJ1A2We433Eu5Xm2DEOI9pYTqeO233k2g88v3vHMgsuKymB3hIDNjMM4yC7H61pDwc+v3zicGzRWYHJC14/vdEda9wy0rYtnz+ObFugOR6oyxy3LtR1w+l4ZOpvBG1RoWJeZpbtgfeOx/0hcfTkSZti6O+0VY0Jic075mWi3Pcfj+HO6dDx1LTcp5HkpMOU7WGEcRyYkmaeHxitSEYRlsDz85lpWrg/7lRVwdPTic0F5mli3cNLMSaUTmRlha0qVEwYrSgOYsTY3E3Sf0VBlgk7dV0dWbLkuWVdZqZhAFNInyyzBM8OdU47VFrLWNFYhscbf/mbDzC8Y3VCtIgpkrRhXD2n84ltu6FzS57lxBhp25ZhmvEhYXTCGNmHkQLLKCGHbZb9nd49fSkmcmvJdEaIsDh5au+6VnByRvpvm3ekGNHWcmgOhBgpihJjM4paAjTTOHO/J1SWczwdSN6x7LDncRADRWEbfv74grKWddtY1yvzNIIy2H1fWBa5qIymnhAih+MZN62sy8T798+sy4xSBh82LIltmTi//0DaNUnTeAelyKzGmJxxeGC14na9cX66MPQ9j/tV7BfTxOnyDh8DP//8kcvlwvn5mWXZ6G9vKCwb4hecp4EiL9FEPn36JL1DW6BS5H6/oq0lhMSvfv0bXj59ZHg8OJxPMjacpScb/Lrv5gJWZxiLHPIpykhzFdj34XTk/vKJkJc0TYfehatbnMm7liy3zPPKafdrjsOVspFgUVlWEMK+htHMI9Kryyxd08pePCqy+kjUBdPQo63UYWIMaJtRljV5bnHOsawr58OROm+Yl4mwCd1HK0Pc5Ea8eff/5939H//xZ3/gpRhIPuAjJL+htJaUW1rwwZHZjKquOJ87Pn1+4+XzT3z37olxjbx8vnJ+PrOOE8s4kRellFF303lW5DgvQOK8qPCrI4bI6ek96zKzpUQceoq8wC2zPEEj6Km8bgVDpsBtG6UtcevKMk5iY9hn74euAZ2xLT3ffHgmJsU0OcF5ovj54ye6tqEsLePoOB4OvH38SIhRnFtBkqHDMJJby/unJ17VjevbxKE7kNmCZXU0ZcYaxIlWViVdXZGMQaVEXpV8//sfOZ7OFGUNyKhzGkdCDNSqljCFshgSm1spqxw3zYzXlWTLfY81MU8DT5czy+yYpgmjNZd377jf7pRNR241JHgMPeviCWgOxwMqQAwbRifqY43IdRverg+enp9Z5ommsHz6+ErVNry83PBRiuCXywWrE4/HSp7nfPPhG+ZpJW6BQ3dEGcswjixu5dS1YDp++P0fOBzS/jk1WZZhjTzxqrKkLGVXNs1SvI4xonVGinBsa77953/J3/3999xvdy6HltOp4973eA9u72PJ6HE3FqBJPvHoH3z7i+9I0XE8fuB67en7L1SOxLysoBTLMgKBaVqFiFFKFLwocpZV7yCBuFvSNZUaUNf/hexxY7w9qOua1QnFIjNWwMaHjv7+oCpLZrfwuF+FpGIV0Xu6Omd1G6/XO1UlwtzucEBrxZj8/rn+CPutGlkBjP1IlRdUbYkQyyLTLHSTLCt4+fSZwuSsW2RZZo6HjtujZ9tkjHs8n1nXlWUcWCbDNDustXw4dORaM8yyd04KNrdK5SEvsFmGzTRxW6mbgnFcQVtZS9Q1q/NkRrO+LkzTgt81QNZoCmuJRcUySjw/pkRVd4jUw+AmMSpkNsP5jdePn8mKirY5kpc5t6RQmWEde/KqAKNw48LwGIkxkmeJIjNEDcvsOF6eMDtqMMaID57cip5HyCoBv4jNhBjx88S785HXdcHY6msGoaxrjArc55EtRKJzZEVJ23UM/QNSRBmRRhdZxuF45NMyk1Dcr1fyQnZy/e1BUeU03YXkN9iFwjHK6DgvK9y64vyKMTnzslFkViZYKUoKOM+p6xqjLavbPZ0K4WsWBVobVrewrDNZZlGZEbxdEBXY7B15mf9Jz4M/+wNvGif+6q9/wfd//zuMURRtQ5FpDk9PLNtGsBJYKfKczXls3vBy7XdbwsT108aHb79h1FoCDz7hQyT4SFtVkCC4jTWBUVFK0cZispx1WiAmmq7mcDzy8nb72gFrupZxmKmbiqfnd0zTyLe/+MDjracoDYu7k2WWIpedkdYdPikux5ZleaFrW3lqUhJgud96mqrh5eNHxnnmcj4S0ayzw2SG8/HIDz98z9/99ne8e/+ew+lE349cbwNKGebF49aJMpevmc0saz+KBiYGDoduN6QLt9BoxfXlDW0zXl9fKPNqL/R6ukPDsiw0hwMQUDZnnR1Wa6IyTOuGTp627VDG0vcjNsvQKZJC4PEYaQ9HrHGk5Hnclp1pGfiuKNAxEJRCxUh/fxCTJrPQP0aeny+MywrBUxcZtijZ3EZQEVtUZFYTgufpcuTzpzd8tHg/yW20uYA1jI+REBXDONK2tbgOh4H8/ESuDY/+IYXZaeZybHlME7mxZEXG9e3ObDN+94efeHq+EJXsbYKPoHLWdeB0alhPHb9PX0SskW1dmIc779694/r6hltm6rYjz3NMSiibsaEpC8t07zmdzqQUWNaNqCPz5vAxMk6z/HijSSHtNgR4e3nl9fMrwyj7v/UfCD6VSqzTjEpSl8nKnLIqWecJrTNCke2l9khmxf/nfRJ01jTRHiW5rPaC8xfvXgye17c7bhmpqpLOtHx+e2WaBi7P7/YdnsfmORooC8s8Bj5/fkMZURQZDOs4CtZLCc3/2w9PvL7debveid4TtsC6Skm7KAvqpmFzgcf9jtKy3x6Hibws2Lzbwegtfnuwec+HD0+gFd5HjILf/t3fY3KJC6YYyK3l7frG5h3rPNIdLxwOB8K6sDqP0Zanb58YHw+82/CbpyxrlmGiaTvKqiSGyNgvaG04n08MQ09U0JQ1bvU4txKDOP+qoiYrLH4LkgkwhrY5keUF2eY5njqi92zLhEqK/n7j6f2TSKWNYpoW6UdOCzETM4ENki0w2lA3BzEVGMvn11dMntNUFf31vt9m9ylDVfH2+ibF/WHAaBnVTtPMMM4YxIlX1jWff/qJpn7mcX3h8nxhXTzDY2QaBqw22CITtqaxrOvGu3fv+PEPv8caUXGtsyMphTaazFo+vH9mWhw///D7P+l58GcfWnl6upCCjNbKpmMcJryXRFxMkmJr2pafP75g85xvv/nAN99+oGtqzucLZdXw8vnKlhRVUxGTR1mNMYplGtFaE1RCpUAicjxf5NDb910ouF/fWNxKUVjquqHpjhA8v/rlNxzPR4ieQ1PR1RUm15gsp8gyzucTyeSEkBiHgX7s+en1lZQ8eZExTLKILrKcwiqOXU3XNrRNxbo4Xj99RGcKv638/PEjddOyhcT98cCHQNW08tSGeOWKosaqDGMsU38nJU9d5dK7Wx1KRd4/n2SsMgx8+OW31IeG417mhUjUiWFy2LwixMg8zCzjwvFY4zcPSUr6eSU32m2ecGNPVWQcD7Jkr+uari5RccPqxPlyJC/kafQxTPTjSvCBez8I3cRNdFVB3VQ7cUIW3lobVBTe6dvbjf5+ZxgGYkh8+vyCzqCtxBOIUqgQ+fjTC58/fuL8dCavcsZ55XA8EpXh9e0NgCwvaQrLb757x9u9J/jIso6UheHUFbRNTlnmvL3dKMuWw+GJ+2Ogawq+eX/h9fMbr59fv8KjSaBtRlE3Qg7Zx3p5nuHcwjTPHNqKQivu917K+eO0mz80yzQxv/6E6v+A8suuA+Lrr59SYnKRWByp3v8lv/zP/xte36744IGEDxun5xNPzycwGqUMw2Pg/HRmeFw5nU7UVcWybCStSCrsAOyVxTmutzvjOJF2596X9KfWGW4eqcuCY9fy48+fSCpRV7Vg6HZllndOqiLJSFk5bGir6fueiGL1Uf5esww0TPMqY7UEzfHIoWsEAGEzTILPP35kuPfUZYlVCqvEdZnCRrZjrZZtZVpngtK4zaMizG5jXVbKpqIsDNu6EFOiqGtOlyeKvOR8/oDViqHvuT96UImhvzOPPYlAWRdoAiBBkNfPnxkePcMwsa6LFPJ9lP209wz9gyLLUPvuqqwqmirHL47gN6qs4LsP7wjbzO1+xTsZLWpb8Xqb8Jvj0DU83q6EZSY6oToFL3mDzXuU0lg0BJjHWTq9ZcU09qgvgPp1w22iIDocZWf3+nYleI93sv9c5pmnpwvWiPGkqFoIgR//8DvRaW0LUYGyGesm+YDcaGxmcdMoNpllIcsUHz/+RN022LLGuY2qO2DzQr5vs4y3653r2ytVVf1Jz4M/+wMvxsgPP38keBkRVnnGox94ewzi1nKOt5cXjueWsb9yu78SQ+DlemdeZozO8N6zzjPX1zf6x4iKkXUe0FlGXde8vb6yuoUsL+nHkS0E6lrEpGVZULUNq3M8vf+wl3tL3n/7Lb/69a9JEYoq5ze/+ZZ1FqDwoav45hcfWL3D7p6wiCE3BXlSPPqJohTyvcoMNs/IbCHR+HGgahqcjzRth4qRPM+pylIAw1YQShHIi0yqE94R4sb51LKGyKFr2byUbrO8EIGtVZzPB/Ki5OlykLGLX+mqXJ7oVQSt0El2H+s8sywSoQfo7wMuJNH/zANaaZS1VHUtFI/gmaaFhGaaZ3746WdMKUvvx2MQJ2FKoKHKM5ZpllSakj6isRnXtxubWxgeD/LS4raNGBKFNXRNzYcPz/iUeLteyYqcZd0Yx4Hz5QkXImtE0ndtw+JXsjyjKnPmVegTWiN+tmViHGce80RzaPj22w9UlexSlba4aPj50wtvr6+M44Pr7Q23LVRlDjFyuTzx+vEHYD8bFKJNMpplGQmbo+ka+qHndn/w7S9/weojnz6/4N3K07lluX/Gvf4d5fIHePt3qP7veXz6Hds6fcV7qX3EmIDzL/6KX/1X/z1/8S/+a6rjhWxHOQEMjzsxwe36SlkUVJXs7uqi4De/+SXbMoLWVHWNW5a93ybx8kPX7SNR2RFFKbQCCHShO2CKlvtjpi4KcpvhvMcUOXlm5WEiecoqZ5oepLjRHo48Pz/Tti3RL+QW0IhcOMCPP4iFJPptf01YtsVxu93wKoGKFHVOnhmcc0iaumZbBbJQ1QV+E4DB8dBJJSFGjocDzfHM5fLE4XTkdBYObPSOdZqwucFHxziO5NbQtQdSSBhtGYZRxvTjyEbc08NnlM14PMYdll1RFAU6N2xhk+6akWAWSlNVDcvQkxTUbUVelng0n1/ErlDYjKKsBc8WAyhDezhhjOGbb95xPl84Ho74zTONE1FFjpcz2kjnVqkojshci5nd5hRFRp5lTMNITILkG4YJpRLn04m2FdGwtpaqKAjrAhr8MuHdzOFwoOtOoBSP+42qbhhnCfDJg9ZM0VaCT9wdjAYl49zgeXc5U9ctWkXCtuDXGbcurOtCWYnV40/58Wc/0tx8oihb3DoRhxtFXjHvt5UUFHnZME/S/M+zgs0nfvu7P6C13LKs1ZRFLlZiXWOMYZln8loqBQq4nM6iulk8Bjg/XZiWlawsuZyPPPqBGDbmZaFqG86HjoTi5XrjeDrilpnHQ/QYx6bi+vLG+fmZrsoYBiEWuHEQGnqRY4uazW0UVUNOYBwkuPDN8UBmZLTX7DezeVpk/6Xg3btnkncEt+IiuGWlLizTtNB2La/3B0kZyrKTVJVSrKtDKXj//gm3bOgk46rzRRKS47jSHY7Mw0Dbtni3ME4L1hgZc2kpqt8fA3XbAi3OBXKbSCnSDwPbOnE+HngMI9bmFNZyOB4YZkdWVHu9oMBqC8kzTBPJaGySwnBVlTi38fzuieATz5cz2hputwfDMKKtkspIjDRFLvvckMhz6YPlCaqqYOpHjJGuklWW5CJFbmnqJ77/4UdOx4bzsaUufsHvv/+Red1E06S0YLuiAHu31PN8OZMXGS+fXymKnLI8cB8k/djPy1c9UEzxq/VcA1sI6MwKpknnGAX99ZWwPCjCRhpv/PT2N7hxZE2J233AuU0wUCZj8wFr41e8l0C3NYfKEJaBoj1wef8dRVkTovy48fYibjS34qPG+cDxdOY2THRdzTQ4ts2hVOB0PtHfBzJjhYyzOZS2aGtBacLe35RdXqQuBX7cNAVrTGyr49C2+DXiUmCZBuq65MM373j5fKMsCoZh4H5zqBixhfRkdRIn2/AYuDw9CW82Btw8YTU8P58YxhW/LBxOJxYXMBjysmRbZ+YIWkf6R8/x0DK7jcPpwuNxJwSPLkpOh5bf/afffq11xBj48MtfEdzKvKwUNsdiCE5uiFpZgl85PV1QRhKy/e2N5nDC5qK7qssCpQ3jNFCX0sVbR2HE2n2PG0PER0eRZWSFZVlXlM2YlxmtFE19YHMz67LiA6AVmYUqL+j7GzF6mfrkOSEptuAlvOQCY+gxxnB/ewMSuTUyni9Lrq9vxBBoDh3d+cDYj7hdm2ZMSf94yMOxEllyCJ5+GDgcjlRVw+P+RggzbZ2TkofMyPtl2/B4e2PziszkuEUCUyolbFESlSjXyirj/rjiI6zjRF4Ukvp1Au5OMdCd/sl4/o/6CGEjK3JMVfHy8TPffddxOp25Xt+Y5pFz3vHhm2/5/PKKW2eqsqSoGrQ11EVFjNJjSS7I4eRWlnFGa4vWwnw7HIVjGVOiKlq0zSkbof4rLbbtZRwJfmOcF46tSBOv1zvLMvL+3ROnY8ePP3yiaRoWH/n08sovvn1GkZimDW0tXdsw9g/Olw5rM+ZpYHXSmTs/XXg8BsoiF+iuNfhFyBIxJIyCZZ3xmyc3hritHE4d1mS8Xnu6U8bzpeDx6BkHUR7ZPMOqxBA03//wM3VVCXjWbTSdxWYV2zbhxhG3rFyezvSz/B4kIafQRjHsZua+7zkcjyg06zLCTlH3SbMFRdd1nM9HbvdBwhmA0hajLN9+c+Hjx48Mk+Pddx+Yx5l1kQ7PMI5URUNWVIQwMc2ebXlwefeOqlyY51l2qW3L9XqlKAq6puHTywthW1GmpetaPn/8hPdwOj/jVk9RaR7DgLvexHq+rvzt3/+Ooiiomo7VOVLURCWcwOF+43J5wm2ecdmISBLYqoTzidf+hjF/VL4IIFejleb5u7+EmNAklscnutKwPq7oeWBLHu/loeF4aHh5vTFOK0ll1N2ZvMw5n9+TNyd+92//X6ht2n12X+QHkf/0b/8NH779gHr+Jan+VgIaKaFUtbNTLTHLKIqcoizI84IQIsNjkmKz1WCs9CJTwOicspaHNec2vFuIURJ80i1Ugt4KnmEYOZ4L1mUGlUi6IHnPuoySdi0sP356xcQkI85toypazk9n3q53jLUyioqQ5zlKgVsdZVVgspz72ytaK7kRbbJn3LaReeplp2k15+MRW5Us68rlJMSST69XbFYSQqJtKx63G94vHJ/ek7Qmafkzexzt8cTxcJBwVYxoBWVZcb8FxqGXr1/w5HnJPI407UEoOezVgq5lWRbWpedwOhN9oB8e2CKjKEvmdWEcek5PF4q65u31DWUEq+WCdNlijLI7do6yaDF5DasnzzKq9sD19RWbF4zjhNKG0+HI5lYOh5ZpGjg9PUOCZZ6ZxpHj+fxVsGyNJrc56zLQNjU+SnimrCqmaWbqB4qywGnNdrvSdkeq5sD1Pv7/2PuTWNu2/S4T/MaYc8y6WOWuTnGL954fxs+EgSQdgQiwEmMagRDKBkgoG0gohYRt6ckgSHo0UragAR0kmiCRQigbIAgJZWIJyaQTHGEcYPzsV957T7mLVa9Zl2NmY6x3I01CBg6eFZFPOaXbuOcs3bP3uWuvMcZ//H7fhx/6uI5tfJ/dQLbd4gYhlpR4nqLXRkUmJTRtRpzMidMZbdNeqjI5XdUSpglN05j/f2377/FgvzfP9/2CZwmB7nviJKYKCvbbJ5arFavrNWWes9ns8AOfoRuxLOOCCnyfru/ou96QHMaOZLZmu9/iOYau0LQtzsV47PoOd1dLXr1+x2p9wyff+RTbC3j27Jo3b95h2S5D3/L82TXv3t+z2dwThDGzJMJ1zG4ny2v8OKJvG3zPox0HDucCOQlTdNYjthKsb655ePuWdLGkrBsTKxaO2ZPqAc+L6YqCKAjprAE/tDkcTjh+DNPI1BuPWBT6NGXNNJlFvqlrmsbCdx2KukVMFlNd0+oB5bjMk5hPXr3FVQ63z56R1Q3H3Y4kSYkjn65ref/uHfPZjMDzmSScDjnKtYmXC+QkOB1azqecm9s1dV2SpjPiMCTLSx7u3+F6Lk1nCq53N1e4vk9RdWwfTjRtw2q9pusz8mOGFJLYcxjQBFGIRHDcb/H80Ny9CDgcDAPT9UNs5RiSh5iI45Cma/F8HxX4DK1m1D3KdfFsm7Gr6bsePTp0nbkriqKQjz9+wdPmwPGwIwxDlrOIzf7IeX/Cc22ubq7Z784I3RPGMUV2Nj1EKRixaJoBxzHuNz0YKom8GAv642cM3T1FWeIqi7efHVCOY4IZ2gSlzlmGYOLZ3Zr1esH8g9+Dl6xpu94IWceBS8f3omu9jDalpGklv/61b3G93rK6eWSe+lRlfXHfaZgm4mSO7hqmceB42BEnM6q6pG1ynr14gZSS/HhmtZhTtS0WI64taZuGMPQ+h1KbRyAnfYnCzymrhjSOcT0XPXSUegDLnHh01YFlIydBXpY4ysiOq6bhfD7jez7zxOeclShX4Tg2CONRyw9HUy8RgsD3OR1Pl4VG4AUGGj9PE4qqNeAAJcjKkv3BwJyXizmODMnOOVJCMlsgpcKPzH+rK0qCyKe1WvQ0EoQugW9IL8fj0RjMpY2wbPqmR9oK37MYu47Ac6jqhvN+y/JqRRrHbOuatu5Yr1MDUHAdqrqiKgriOGGaJs7nM1obss94ORE6YYDteBT5iTBMGYaBoSwYL0ou3Q94Xsg5z5ECksWMMi9wPQ8hJK7r0zf9Bc7tgQbd9YYXqnu07eAFAbZtaESuowh9D2E5RJFCa5O8HNqeARPeS+ZzA6WvWyxLsFgtGceR4/7IpCf2hy2uHxBGAUHgk+cVnhegbNuchGNzENBDj+U4VFWNpWzojcZJyMub+Xv4fN8veGPXoRwXKSU3t1c8Pe1pxhG77Qw7LwqxbYfYtdg9vSdJZ/T9SBDFWJZNkxf4QUzfd8RxjBAWs9WaUWt2j++5/vAjmrrh09fv8cOQd4871ldrTkVBVVYoKXBswdXNLeUwsVjM0eNA0xmQbdePKMvh8WnHcrU0c+sxJ/UCirzAC0KatiU/n6gLhfJcLBXQlOUlGamo244yK1gvEo6HPU3b4bouo54ocjO+cBzJ6XDGCRL02DIOE4v5nG4YLnddxgyO7TONJbN5SF01eGHKfndgGCWxH5iL5UmTn0znTDKyO5jSret5jFrjKAff8fGubKqyYvf+HW444/p6xfb+PeU557A7kp8zvC98ifPpgOva+L75oXDcgLYbabuMpml49vw5wzhyOh3M6SwIDV29aamKAm+5QuuRru9ZX4e0bc3pYCL3cbpgHDV1dSLyXeI44eHhCT2OPL+7YX84oTyXuirxXZcoiinrFj1OLGYeQ9+gHSP6PJ0yuq5FKZdJWBwOJ9J0TuApTocjUihThi/MHWUY+iYZWJcUVcv11YqyqjnsDhdH3XdtCXD/9i2PlqSpu8vJWOEHFu7sjn4YefmFL6MHzcObz3jz6uuEXsY0aV78wI+QRLec8oqmLOgv43qt9efhESEEv+9/999w/+Yzvv4r/4r9IeP2ZsFqkVBVHX2TE3rKLKyWpMwKopkhnAS+T9f2ZtzV9/Rdg2ULmqpm7DvmiyWpstk8PJjd+OeQlwk9TbRNj21pksQogvKiJPA9giji8f7B3Kt7HtklZBJFCUVVk2cVbhCQzhKTFJ4m+nFkbAz8+ebmBiEEeVVTVyV1U6OniV6D3XW4tjT3b33P6Xjk6vbOyG11R142tE1Dks6whMQNFKCp2+ZSrTHp36kf8aMQtDZU/zjB81LKsjC1oVLRD73ZHDUdQZLSdx1dZbq+2geEJElnOJbL7nA0clw0QhoUW1v1jH2P7XhMUjKOZmxclBV9b0JFvm/YmG1dk8QJ8+WKp8cHhrrC90PCJCIvK4rjkUlaKNulrXsQkkkPFKW5TujaBhgREpTnXJRKpv8rpUVVV4RRROTanE4ZcRKz2+0YR02czAh8l86W1NUAuqNvaw7bB7wgxrJcnh4emC1XF4XaiON7BBf3IZhpTxinpubjOfSdUSON5k1KlmekiwW2smibmjRKOVyCYt+r5/t+wavaBi9JOZ/PVHlOvFjSdK3hV/YdXTeivJFJm1FWGPqUZWnwPr6LsCXr9Y0hfvQ9ZZ5x3G1IZwl3d7f0bcM0aeIoND/r04SQNghBXtdIpfjCl79AWRQEdOzGkShOoKhpihph2ZSF+UHLTyeiJKHrJ3a7B67XV9i2wh5H0jhCKUXVjYSBfRl11uyPB6LAJ3Bd8rLm+fMbjqcMx1Hkp5x5mpIXOQjJMAkCW+CGKU1V4foOfWGsz1LZSBuGXuMHEcp2OHc5ddNhXezhrmsEqE1VoWxlEFlSoIeeMIqQliTPC07nnDiOiCMfKSNsz6duBzbbHd0oaUfBhx9/yLt392RZwbOba0YBm90OPwoQl75Pks5YLWY8PG5QyuL53S3HLGd7OGDbCqEnPNdht3nE9XzaruezV59hW4r5csnm8Yk09snKEj0O9PjAiOMqPCek7keiWYwtJUqA4yh22y1XV1fs9xX3Dw/E8QzlOhyPZw6bA8pTDP2Ioybm8xllXTO5LsJ22G43zJcLfE9xOB7x0sTcTdgKYXV0vbHBN03z+bjmu0SU0QpwwoR05nH78e+grmuEdJit11TnA/F8hRCCaHHN4uYl9598jd/4xmfs90eev3yJHd4SJ1fMlwvq0wa4iIIuOqTsXLL+4HfiJ9e8+uav8frdt4lDj9ubJcpx6NsSJ1xQ7/bGy9jVDONAdjoSeOaOFEsiLYem7pnPl5R5xul4xrKloenEKcVxaxB3QhAkCUNmRvmzOOQkoGkLkBYSA0ZIFzMi10VPxuIgkISBjyUEdVFcaDADtmXhey5l0zKbpbx7uDc2EcdhMY+pS4u6NoEd6RjdjrHA++hp5N2bt/heSOi7RPOUfmjotaZpW3xLIK2J66sVwzDy9Pie62cvOR2PIExvTTk+h93WeBYF1G1LujB+vzIv6dsOz/VoK4ObS+cLirJgEgLRQ54b8lDXmHRmfjwyjhrbtlG2je9YaGkzXXq2YtSMw8A4DqjYRXQdUgqSdMH5cEQIgRsE2Eqx2+zwopAgifGDgFFPVEVDGAQcDnuiKCIIHANsTlLGYTRTEOMORgqBbVnm82TzwDBfMWJxzgvDFFY2lhQcjjuSZEYvYOh64jDAks+MhaFtcILYuDfzEstxYTL30p7jGdZmFNKUmaFQNQ19XxunYBgwcXEE9iOt1mA7bHc7uITevlfP9/2CJ6SFsCwcy4JQc9xtCcKYum0JogjPl0hboSyJ7xmH3M3Niv2xwLIV66uUOAp5eDR2hOfPb8izAj30YNnUZUVbmR5ZnCTMZzHdCEqZuwmJ4Dd+4xsAzJIEJSS2rVD+RFe15s2kNGMn2R/2NP1AkqSkcYRjSw7HPYvVnPyCpbKkxTnLmc1SwjRhnEaiMCJdLvn0O5/w8PiE7Sj2+yNh4HM8nrCtCc+xTKijadFdRxgE7PcHXMcHbdFPPUPXIpAsZzH39w+sFwmdFhRFiWUp+smEPuYzn1efvOYHPvwi33n1jsmyGfWEmPSFXqKp65aqbvjiFz7gfDqTnc5crdcGGts22FLw7GbFKcvZdjVe4MMIjmvjxw6HzQ6pXDrb4eb2hrKuef3mNbP5EjkJbCGxPcv4uRyPfhTYliLwPaZpZBwGwjhllxX4vsPcW5Ed99hByCwMcHyfAcH28YkwTbCUohtGsuwMQhJFPspPyc8FWZ4TRhGu49L3PcIaqZvGKFYASzXocaRpDZqs70csKdFdR68nBmFGnIft5WRnAq0mWHKpDczvPubZx78Tx1a0XYvSFstFQp6fkZZF4Dmczjl91xHFMT/y+3+c+zef8PZbv8q/+9Wv8eLZlvn6mr4tzUL33SCMNCR/x/NYLeYIYfHF3/VfcR/GfPq1f0VeVKyWM5TzP7B89iWub56jhUWfF8wvCUZLTNR1S1Hm+MrBixMOp5zAVxcAtoXvaWaLNflhg9aaSWu6piIKAoRlYzsO80TQ5jVjP9BaRoiaHc7Y8xlD1xvpbdcwjZpeWgjLxvNshPQ47I88u10z7g1E3XcdA2poW8pSGASeH/Dxyxd869uvOJyOhFGKsCzSOKJpOxzHYdITbdXiKw+kuU/dbQ1ScBxH2r7n5vqKeRpzPhyoasO6ldJmfX3D4/s3KDfED2KapmfsOxaLBV03EkYh0NO2Riulh4Hlas3pcMDxAnPnC4RxYu5C25Z+Gk3/TllMGDh2VeZMGsIwoOsH8pO5x/Q8l+PxCAhGDUgYtXHMjb2LtE0Abega/DCi6wcc16epGhYzszHt0XR9a+TXcYKUhixz3jwRRDGeE9J3NZ4XMIwgpNlw9MOAY7mAIEhnFNmZpu/xAg+hHU7DSFOXWMIijlPqy6a46UbGfmAaOyzlMuiJ5nTg+YsPyPOcfuhJ04SnpyfQoJQiCHxOxzNYkqHtv6frwfe8lvBzP/dz/L7f9/uI45irqyv+xJ/4E3zzm9/8Ta+Zpom/+lf/Knd3d/i+z4/92I/x67/+67/pNW3b8tM//dOsVivCMOSP//E/zrt3737LX4/rKLq6RV7e3Gm6ZLWY8eGHL4mjCDf0ubm5QrkebdvAZIrSURIReUZsuHna4yoHx3Woe40XJvhRaigQaczLjz4y6UnHpqpqssMB15ZUWQFjy3w2o217sBy8KGa33VFkOY4tyc8H6rIkCl2SNMWSFt3QE6YpVV3iOCZtNYs8Vqs1tlIo16XuR467HWk643A88OlnnxInEZbl048Cx/fRWNw8u2NSHsdzydj1WLbF9rDjlBfYlsXpdCCJFGPbEPsBYeDj+R79KHm3OeE65uvq+s4UgPua+lwQJTM++ew1vrKo84yx7xgGTXHO0eNEnMyYhpFXn71HSsX6akHXtVS1SZ5lWYVQLn4YYLsWTw+PFEWBsiVZVlD3PVVdczjuedruKNoWy1bk54x4OUNcCPPS9hgRuI6F7kytQ08Cy7ZYL+dYUlDVLbYFXhBSNw1l0/HwuKHMKzwvJD/l7J/M7v3lRx8QpSnnvKFre2ZxgOtIquxEWRbsjzv6waC+0lmCrxRldrnDu77m6f07iqrl2bNniAnqLIcJDtst6WLO9e0NcRJd2IIGxCukhSVdxt78eb7jMpst0JNRtdhCUuUFY1fh2JLFco20LMJ0yY/+kf89z770e/j09RPf/sY3Kc/77/6QfXeiie2GaNtlu9kRBQ6+b7O+ubv8fDjsD2e+9mtf5xv/wy/y8PX/J7vX3zAnMMsgrXaHE9Ix42BH2dRti+M67HZ72qbheDrST5rhuz28S8CiyQ0tpWsrznnG27fvafsW9ERdVriOxHMUaRKgR83plOF5LlEaoXyzufB8j7urOUJIul5TlwW7zY5hBEtaJlCjFGOnYYD71++xJ83V9ZrZIoGxo2tqkiAwd6nTSF4WaGHu4PLziWSWMvYtm92eaZJ4fsThfGaYRoZhIAwjXD9gt93hRbOL3WKkys6GhNL3IEbqylhV7l48w3XNXfeoL6P+sWccB/QwkeUlTWeUQaMesS4WD8f1qMqCwA+wJFR1Q98PDBNYlkvXdfQXyLScJrqqou0GvDiGCcRoOqdCOGg9URUZyrbN50Vdm8nTJFBC4gcRbdfTNhWL+YwgTPBchyDwLoDx9hIU0rRVYQr4nmtSuJNAKqNhOh0LirqlaWt8P2CaNE7g4vgeru/T1iXKMYeKrm1hmgjilDw/Y0lDLmraBveSjRDSuPekNBvYSfxmEPp/7vM9X/B+4Rd+gZ/8yZ/kl37pl/j5n/95hmHgJ37iJyjL8vPX/PW//tf5G3/jb/C3/tbf4pd/+Ze5ubnhj/yRP0Ke/4/uo69+9av8o3/0j/gH/+Af8Iu/+IsURcEf+2N/7HMi+3/qY7seE9p04+KUeB6z322xbIcwjDhs9xxPJ+I0xHYkYRTQtuYi2HYs6m4w3ZqhJYpDhrbHvoQ+9GRQOHXbslosqMqGQY9I2/y1Ltdz+n6kqSqSOKRpavP1a41uO3qtzZhIOYxa4zkSwUSelbx9/ZY4jg0Psq7IyoayabDFhC0m5DiyXq3Ii5zbm2uuZgmr5QzPkQxNR98PNF1PWZQMXUfX9UZD0jY4toerbOIkwg1cNrsN1zc32MpiQvPpq/dcrWb4nsub1+9pmwGlBNE8IUxiokWKnnom5SBsxWqZUtcVemi4WhoLQ10VpOsFju+wP+a07UiSRASBixYTZXFiu90zdB22sPB9nxHJoI3tXUwGkhwGAWM/crjfMU/nhIFHtt/jOS6WZTNiPmQFE9FsQdv26N6oXzbHA5MAheJpczSEd98xzjEhUZYgjkxReL6YkZ9OnI5nmrok9F2y0xnXc0zyTyksMbGapSRxRFG31GVNFAXM5glKOeh+4NntHZaQvL5/wHZc5qs1yvVIogjPdXh8eGK3fcJWDlJKpsksxIvrG6Qt6YeJUY+cdlvqsjLvX2mBZbG+vsGyTS80Xczx/QDH9Xj2xR/ih/7LH8cOFmYcdnnvS2li77ZtmQ/ItkKPBrZwPp/MomvbzNKEIF2xOTV87Vd/ne2rX6N4+2+w+iPKnnCURVUWVEWFG4TG2sB32acKS4+ILmMRSp7fXV/u8jR6aBmGnr7teLp/RCmHlx/cEaemXO17Hmma0Pba+AGVidULjNBYjz3Z8cDT7sjV7RX7vMC2LX7g4+f4rkLrjkAZwbOjjPNxRBMlCROXFKxtmUlMW1MUBU3X4fsBUejjOTZ9r2Ey0tk8K0wlIs/ZPjxxPmYmXCQFg25RysISAqkchCUJwgg0tF3PYbvHdX2E1mx3B7AUfhhhWwIhps9hzRMTYWgCN9/FezlK4QWmPN5WFVHoge5hHLAdhcR4/bSwcV2H9XKO6znMl0viMKDKzthK4bgeURwx6R7bclgtF1iWgWTUXYdAMHSasqwMPk3ZOJ6HAGP2GDVda0wX/TiawrrrEM7mzBYrlOvSdQ2e5yAnox+ypKBrWhg1bdPQ9j3TiDGsHA+EYUDoe3RNhW0JwiCkbVq6TiMclzCOacoaPwgRk+nxpmmK5TqXa5bvLVpMTN+9RPhteraXO5Ff+IVf4A/+wT/INE3c3d3x1a9+lb/8l/8yYE5z19fX/LW/9tf4c3/uz3E+G8TS3/t7f48/9af+FAD39/e8ePGCf/pP/yl/9I/+0f/JPzfLMtI05U/8H/9PeI4pu0ZBYLBWcmLoNKurFZvNzoxIApc8OyOQOMoijkIEmlNWApKqrgh8D0cpJGaGL6SF5XhMY4+4BFCEANs2l65BENC0Pdn5iOtHJjrtB6av1lSUZYPrGsNC2zTEccjuUJDMZ2TZmdgRZFlBOFvQlg2TFES++aBsu54iLy+S0JZpGpGWjWNbBFGMsBXbpyfCKGI+j7l/+45JCNbrK7ph4Hg647uKq8UMadlU3cDpeEKIiTSZkxc5ruugx4Hd/kC6WHC9XlHXJoYuJ42jFMq20FpTVqV5E1sWlqNAmK+lzM+4vs/j+weSNOFqlXI6ZZ+HNaRtlDaB57LZ7XH9gEkYOJXuBmZJjOe7FGWL77kU+YmyrpnP5wjLQto2bdNSFSWu42LZgrLsGMcB2zYbmDIv8P0AjUBME77rUFc1RZWxWK15fHji9s4YJbZPDyBs0ktsuhsalG1jS2iaFs8PiJKIMq/o2hZhCVxb4Loewwga2B8OxHHMNBrbt1KS7HRCANc3d+RFwa/8wn+L1RovoutHPPvh/xo/TXGESVe2jcFuJfMEiSQ/HZnN5wwIEz9XDr7noCcT+baEQDkuX/tX/3dozd+vAKQliWYrrr78o9jSxrZtwECJf+Wf/xNcazKnqquPWX3wO3j49Gvs331C4Fp8+MEdi9vnuMlztOXjez5dN5CddyhrIlIDQtd0VUae5dRVyzkrKMsaW9ncffn3YEcrZnGEVN7nJ23HsbEtwaShbkcEE9n5xGy+xPN93r15i5SS+WpB01T4XogfumitOR/P2JbCu8DcyyLDD2OSNGVEMI5Gsnw+HYmSlP3miY8+eoklJceLZmg2nxu2rLJN8lDDcjnnfMoQtsU0asLAN342LfECl+y8Z+gnoiTGdg1TdBp6xn7AD0Ky04H1zS1P2y2245AkEcUxu3AzLZgmNBNdOzL0DcqyOBwOzBZztIan+3ekq2uGtsP1PIoivwAjXKSYsGwXjbkLdGyHSWji0EciqJsWx3HZn44MF8OCH8YMXU1TFijHYcJC65F+GC4S4RFlK/pRU1cFq/UtTV3SNy1aa+J5Qlt3gCaOYprebFwsx8GR0gR3xgHdd/h+zCQwn0HSom0qwnTO2BsO7f7pkWSxQkooixwvSKBvkI5LVTUoR5HGPn3X43keVdMaTZO0qPKM/+7/9n/hfD6TJP/5brzfdtLK+XwGYLFYAPDZZ5/x+PjIT/zET3z+Gtd1+UN/6A/xL//lvwTgV37lV+j7/je95u7ujq985Sufv+bff9q2Jcuy3/QPgO8HCEvRdT1Pe+NpW87m+KHP+XTCUQ4WI1VR0RYm6ej7LudzwaAFQz9iSQvXdZmwQSksZeMqByZJU5TGtMCEsCaCwCeOQnzPp2kGpK24fv6SZ7fXSCGo85qyNhfms0WKFBNlkdFNcM5KPCUZO1O6bbWk04K+78iKk0GWCYeiMUqQ9XqB8hRN19LpydjR3QghBdPQ8PzuinHoePf2ntl8QRjE7LZbPE/x4tkNjuPy7U8+4fWb+4s4dUBImzw3WB/bVkRpSjpLqeuah6cn8lOBJST744ndZkMUXOLotkPbtfRtz2FzpGtqiuyE49g0ZcnVzYqiqvjOd96gHBfX9znnJUWZUdYN2A7zxYosLxm0+VBUnqJpO7JzQeB7bDZbtLBZLNdmZdGa4njkfKHidF1tkprrlLbI6LuBoR3wXRc9jAxNY6zMlYFee05AlRcs0pSn+3sOhz1+FGNJU0Vp2wpfOdiWIi8bqrbjdDgwNIbg7ng+tgpwnIhxhO12z26zR11M48pxsdD4l5FVHMdIIYyS6qLtMWSxCSkFgWWhLBulLPwkoula8nNGWRZYrguWxdA2KCmwHQ+NRE7ScDwdF99zjEIIPi+1T9NEWx5pdp+Yux5MKMJxPNPpajumaaI+b3Fdjx/43X+A/+K//m9Ibz/mN775mm9/7WtUj78G5Xva81vIvkWqH+D0CU+vvsFn3/o23/j6p7x588T+WLDbnwz9ZJqoLxzFw+GCHhs7JktQtgNFUVGVDVIIjqfMBFmUoqhrklnE85cv6NuGpu2QrgNC0VQ9QijCKCCJQ168eM7t3R2r9Zph0IYuojWe5xN6PrMkQEhhRLLHnLZpuLpaYyuLrjX351JaeK5NXpSM0wgC+r4DKfE8nygO8H0f34tIZgnd0BN4HlKPptbi++z2WxbrlREyuwGetOjqDjFpZrPUCKEngVI+vmtOXt04ojyfuhoo8oqrZy+xbMvg0SzFpDXKNvmDvCjJipLzcU/gOri+hxQWu+0B59KbLNsOS9p4rkOaJPRNSd/WrK9vTHBGaKIoZn19zdANTBhYQNMa2wVohB4IIw8/CsjOOW3bYElJVRYMndlENmVBMwx0fUccJwhhX2DUHQJNf+n6nrZPDIMZ8/rpDD+M0ZPAth2YNCOmq2nbJtNwLjs6TJ+1bVrGQeN5Idb3+IT327rgTdPEz/zMz/AH/sAf4Ctf+QoAj4+PAFxfX/+m115fX3/+e4+PjziOw3w+/4++5t9/fu7nfo40TT//58WLFwBUZU7fmXs0ZUmapuaUnc3pyDdH9H6cKLMjju8SxhHZuaCsGsqy5Gq9Js9z5CRwHZu6LLEdF40gnSUXy8LxUhK16FrN8WgivV7gYzsuWZFxLgv8KMQPFL5jisdZXuJ4ATc31/iuY3ibYYgeO/Sk6fqeKDYm4HSW4PgedXmirQ0vUdgOTdsRRyGu6xs55ziy356Q0mK72cFlh5nlFdiSZLbg6WlH3fSsVis+ePGC2XLG3dUVvuMSOIZg3g8jw6jZPu0Z+4HE9/FdRZj4DH3Ns2fX3NysOVUVp6zieMhwLyOq2So1seOmZcLCth2TglQWQTrneCo47E/Ml3PqqmHsO2ZJxG6/R6AJXZs4MCcKLwzoxcTb9+9p+w5XSfquo6obTueMWZpii4kwCBm1oK1rnh6fmC9XLOcpnuvQjwNCCNIkRFiCoWvJszPDBL02hunlaknXdYZ20jWEvsfVagmWpNMa2/GR0mJxfUvfDrRVYyoYrs0kBX4Us1ytiBdznDC5+MNs9KQ55yWu69EPI11bmZPfJcAAxi6fHfZ0XUOYRJyymuyUMZ/NkVgIYdF3mnNeIKQgTlICZWELOJ4OjGNPXReURYFAfm62n7RJgmZZwbtvfY3i7b+mOb0nnkco1+X2gy9+Xnx3fY8wdA1YYJi4/vgrfPSDv4swNMSQqXyi2n7G47u3fP3r3+Hb33nDw9OBqpe482fMP/phlh/+F2x3B/q+BwTn/ZPRW1mWgWBbNralCB1zAmn7lropSZOA+WxOVZaIsSPLC87nE/OrK4SeOG6f2G+f6NsCx7EYx4E3b99TVwWz+Zym7TmfT9jSQuqJ7W6HloKnxycTVps0w9BRlA2nvOJ8yi7Ag5FTZlKDz58/53w40TYtcRKBmGi6lvP5RFFmHLKcw/HMLJ1hIfD8gKos8R0HpQymrsgrHN+mayvGrsNWDpYQtHWJLQSzNMT1FHl2RkqbL/+OL5POQ6CFSVNmGZ7v0XUNtrKRwqbMSiZs9GS6mMoNqIuSrmlwwpiiHsmLGtuymICu7bGVw6hheX1Lnme0TUs/aGaz2GDrQg/G0ZTJlYdrOxTHPV3XoSewbJux7xFAked0emISEsd1mQazGZdSXRKemI3MxQEaRRGzxRqlPJQyxnJHKY7bDX0/MiLww9B4/UbzM2Armyo7ISdouwnH9ej6jtP5SN+3//kL0f/b89ua0vypn/op/t2/+3f84i/+4v/H7/37Dfr/lFb9/7fX/JW/8lf4mZ/5mc//PcsyXrx4gavMG8ySAinMm78sa2ZRzGI+x0Jy//Bg2JRBxOmUM0sTqrbDsh2ariaJU5LYo257osDHsi2ysqJqR5I4wHc9wFzA+oHHbldQtwZOLQHfUuiux/aMQqgRGXU34AcRh92e3LKZJPiuz+5ph6VA2TaL1cp0WIShZTi2wyAn6qZETxNZnpPOUuQ4cTqf6LoGbMlyPWOSFgOS0PVxHGNnP5/PtFowjSOPD4887TY40ma1NlWNui7pe8VyvkIPMPUjV+sVlrLYbPb4jmLsehzlMPUj3/nsDXfPn9F3LZKJOAyo6wbXd02CK47xPY/Dbk/bSYMamzQqjmgqU2L9PT/yQ7x/d8+7t+/wLEE3DsxCn8fdAct26PqRYejxw5jIt0mikO3+DJZDdTqThxHpfM7EiG0rsrykKguatkHaEtd1QFjsd1tKz2FCkaYJluXS9w1hMkNgrN/KcemGHttR1N1AXZxgEkaF0rVEfoRuKtI0pe1blOWwfXpkvVqSnWqGbqQdzE44nS9R0qiOhq5jlgSUVcPTNjeC3qbGdiajyxk1XhhRt41J8g0dSAthScILAWY+TwmTkLKo6ceWdgDleVzf3PH29RvmqxWT7g0MfNJIpCnuTmC7EbtTxuH4TZ4dD4zZPZW1ABWxvLrGURIrmNHWBY7QpPaZYBqYr2zyfM7xWPD+fm8gy5aDCuYEs5T5zQvcwCcKYvKiYGiNx9Dcs0+4jo3vmfHe+ZyTLuccdgfiNKGrOpZXN9hCg+WYqP04Xka1Hnl2ZhwFXhATBsaPV9cVGs3QT6yv12gxUZQFx/0BpEVV5dze3NCearwwJm9b1je3TKNm0qBchZDmbliPI03V4rs2gWc+cD3PQ0mBf7nL1rbFNDlUTU/fdcRJTOgrnp72jNoQh+qqZjabIaXA8xz6vjPiV2ziyCWdpxyOByxls3naECUpCJtZErLf7JCW4vnLj+n6gaIsQRi3XZokBFGMXeS0fU9Td1jKo+87fM+7dOomiiJDOYowChETdMqEcqQUtLU5QZvKlOD+/XssW+E4CmGB63p03UBV14x9Q5jGpPMZb9+8BwR+YMSzYoLifMLzTeLWsi0cJWnbFtvz6C6LY9W0OJYxgqSp6VO6QUA7dKhLzzMII5NCdhz6UaLHjjAKsKxbmqZCWhZcqh+WbcPk/ievN/8pz2/bgvfTP/3T/JN/8k/4F//iX/D8+fPPf/3m5gYwp7jb29vPf32z2Xx+6ru5uaHrOo7H42865W02G37/7//9/8E/z3VdXPc/8JdjwfruOW3dMQwNt8/veHp44HG3Y5ICaVnMlwu2T1scN6JvNHmW0bUlvquQysKyHLSMeNw84HnKdFMsm65p2dUls9mcwPd5/dln1H5N07U83tfM5nPqrjI8QWFOFvPVgmHoUZ6g70b8MKQfNPqSNIzu1pRVgyVtdvujIalPE45yOB0vjM1goutqwihhtz3StQ1J6POFF8/417/2dW4+eMHrd/dUVcuoJaFwENNEHMfsjyYKnAQB0lFIy0F33YWFaDGbp0xi4u7mmt0+oxsGwtBD6IG+0Syv1ihLsN9l+FFMUdYEgU9Z1xyOR9arK/KqpDifCKKYw+FEEvp0ekQ5PnVxRrgOwwDogfv7R5arBQ+bPZZQPL+a03QTRdFwtfZYrVLu3z2B7tCTTVbWZMcDQRiyWK+oq4p6HJktlhR5ydC0hFHKoDUDgkBKE/BZry8p0ZaqyXFcl3GUHA8HuqEnmc0JfZfjfmeCSHlJks7YHTKSIOC4P+E4DmVV4MdGidLUJW3VcNydEJZEeUZy+/7de5QKGJSkaVqUPdE2HUM3gpYctxuaMiNQEUIaWavjuDRlQ1N1JIslTVVy2B0BzTgN7DYb9HTF8bBn1CPpfEGd5dQIgihACkyBvqmN5VyAuQ2E+c1HvPgdVzy9/4RPv/M1jqeML3zhJV+4e0Z99buxLYmaMrzuDWM/UOclnx0zqqq5jBo94uuPsfwZwvIMxaOsCZLEkPqPGZ7j0AzqsjsfAMEwDBRlhfIipFIMbYuSgvx0Rjo2rz79hK7vubl9ztVqwXG/p+3Nxu76g2tOB0OZ6dueCSiynNk85eb2ytyJCpvHhw2WJbm6WnE4Hmn7nrubWx62eyzXIctz4jDmfMpJ5ymWgLoqkcpi6DTP7p6TJiHv7x8IApcwdKmLnCSdmx6aHvGjgKH38cOAtuvxfJ+u7VAqpqprbN9jYjIbHEsxX6yZxpFBjzztDzi+h2PbNMVAU1UMI9Rtx3yWcM4yvMBnKArCIGR9dc1D31GUJVXTwSXOv76+Ynt/Dwjy4kwURzAJJq3YPT5iS5uqyHHCAD32CDHR9SM3dy94//oVw9gT+A5tN5Kdalzfx1EWttSsnt9RlBWH7RN7uWExn5GfT0YnpByUUqbGEIQ4js0kTGl+kjbFycAXzscDnu8iLJC28UUAZIcj0cxsKqWQNFVh3p9Dz9g12J5PVTb0VU7XtQh/wrJcoz/SJVJa/zNXoP/w8z0faU7TxE/91E/xD//hP+Sf//N/zkcfffSbfv+jjz7i5uaGn//5n//817qu4xd+4Rc+X8x+7+/9vSilftNrHh4e+NrXvvYfXfD+Y09ddRyPB9quwfU8Ht7fM18sUa5LWVdkRcGgIU5mYAls28J3FVEQ8OzuhmGcGPqO7Lzn5mqBoxzOueFNLhbRhRtZ0Hcti9WcyZL4rkMcp1gXVY30fJLUVBOEkFRlxThqgsDDsSSWFKxXc/b7I9U5pzxndGWBGHuSNGRozP2HbclLOKbHdp3LvVVHEPpMwuLbrx/wvYCH/QHLVsySgKEtCD0HS1oo12O1nhMECeqCRRu6ljdv3rHbH2jqgq5pkEAztCSx4urKePSausaxJNunPd/8+qc0dYXr++b+p+1I4hiE4ng44CmFlIp5nHK3mlFUDfk5x7I0H7y4xbclaexi29BUFQ8Pe1wnxHNC3t/vmaaRq+Wc7dOWx/dPLOYJaE1TNTRNh+16IBxmUYweNFIIxmFE2hZVVSIFOEIwas3Dw46m11Rty3wxx1IO/aDNSVpaSASME89vV1R5yajh5vYW13HJs5yubXi8f0+ySBmngcXVFVVRYVkCP3B58fI5QkyMQ4/Q5oPAj0K6JicIfBMSkQrbD4hmCUEcoRzPIJMmkEKSrm6I5nPi2YyyMo41PdkMfYuYBp7dXtONAw+Pj0zCQms47Q/UbUWeZ5RFyX6zpWs043Chq1ywYuM0IpVCegE/8gd+nP/yx/8Ewp3x+vU9utqzUCf8cUudHfn0k7d8/Ruf8f7xSC8CZHTN6ov/W66//F/xwQ/+b4jSOcksRAoIPY/icKBpWrI855CXnLICIS3G0YS3xrakPO/p+paqqui0JkxTpCXNfZPyeH77DCkm7t8/kucFljKBCGVLbAXpLEZMZuw7TZrz8cT9u0f6EYqqoe9NTrdqOqbJ1CF2my2R5xLYFlWR048jnuvgCKjKkjAICW1F7Dl0Xcfb+3uCwOPm9oamm2i1oKxqkksP7vT0xO16jo0mzwrkhT1aZCdsy8azzJ3d6XCmLFtsW9FUhq6jR9BaMPYTwlKEYch6vTAIsSK/YMQm8lOGtBVB6HN1dc1sMcf3fYIoxbYVj/fvUK6DbZsAnaVsk94V+vMFimmizs6IaQI9MnQNjw+PhomrHOqmwfVDXD8y3bpxNM67w5HsfCKdzUFYPD08MAkbPVlURcXjwyPZ6UhZ55zPR6qq5nA4UhUZge/BpM0YdOyo64YgMMnLKi8M8WccaIuSuiiQCLzApxtGPD9ktVowjj1OlGArj743rNY4neGFAWHyv3J49E/+5E/y9//+3+cf/+N/TBzHn9+5pWmK7/sIIfjqV7/Kz/7sz/KlL32JL33pS/zsz/4sQRDwp//0n/78tX/2z/5Z/sJf+Assl0sWiwV/8S/+RX74h3+YH//xH/8tfT1db3ory/mKIAgoi4mirPAdx+zcJo1tORzLinEcDfsvTTjtT1TNQBqn7Pd7hKVQjsDzPGw9MfWtQZaJkqqsqT2Pm7trNo9burbFD0wUuus7o72ZzCV3dj5hWQ4ICdPE/lgyCU0U+6SLlCIvuLm5pm1qxsnsar0woMgrfD/AD1y6oaU45SyvbuiaFtdRSGE8ekVRIQbNaj7neDrjOYrslIMlKevScBXrmtA3ZV9bWCyXC07HE7ajOOcVMYJ2HEBrbM/H8QJDYcdiYsBSEjcy9I2+7/DDkKJpiJKQIisoKmN10LpntCVBGuL2Afv9Ga01rrSwLIHWDWGaUuYtpyznejUj/uAZnoKq7PBevKCsjJFhkgo/8gCJH/pURcl280jgB7RdTVHl6EGTzlJsS3LKc5M2CwOaukbaDof9Hj/00P2ASs2i7DgDH738kO12z3G/YT6bIfSI8mzyxnBV6yrH9z2EtOhb8z1npYEA09d4YUhZZFRlQZreYlGalKYeiUMf23V5etwwDB2L5ZJyHC89OcPl96LYqKT8ENEZj9o0QRgZDVN2Ko1oeGjpGZHSNmGUpmEaBWHo4rkeT/dvGLoaKSYmi8/ZlhITpmrrjCR2+L0/8gPQF9RNx6vXjxRlTT+MSBWyePlDrF98xH53ZDZfIsbBbHY8h8DzaLqGfuhZrZaMuoepJ40DlBfw0FRG4/Td+0mt8QKfeRLxVOVY44CYFFEUYTk2reuw3W65e3ZDVeToUVMURlD76pNXzBZr6qYBBb5jYc0TTnmJYKKpGo7HE/M0IUhjzuczgzYJxbKsGeoaz1FESYrFxN3tis1mixBG7Ms08uLZDUVREPkuEsGkJ0I/pKzM9GSaBtLExyLg8XFHEsdmdFdVKNvCcly8wGMYTXVD2gGuss2423WhH4g9RakHut4s2HV7gaKLCWnZXF9f0VQ10rIQwFBXKGVTFxVJEpPOzc9m1w80Vcl5OJLOl3T9RJGdmKUpndQEvodrK4qiZNCCaZxYXM14++oVi+U1SRJx2D3hXnILetIIBFVZUVYlSZrS9yN9VxAtFjjKpakqkIIknXHqalylsKRkdzwipbmTn7Rm1MNlFKtNaEprLGVs501Xk2VHxCRIF9f0fUuRFwRxxNj1ZOfCfN+X+8MgDPFcxf3DI0k6Z6ib783CdHm+5wve3/7bfxuAH/uxH/tNv/53/s7f4c/8mT8DwF/6S3+Juq7583/+z3M8HvnRH/1R/tk/+2fEcfz56//m3/yb2LbNn/yTf5K6rvnDf/gP83f/7t/Fsn5rR1xLCIJ4Rj/0HE5n9Ah1lRFFPjrXaClx1IjvOSjbpipLJu2gApdJSuTQo2wX3wsoTid6PfLy5TOur5bUVUschyjHpm4rXn3yHa6ubqkts8t1PQ9LwDDCbLamqitsoRkGjW4rJivEUha2tHEch8OpRNkeTTdgiYmubcnLktAPsCzJ0DccjhO+76PcjsenJ6IgJE3nfPbtb+N4PpYtqaqa3FbM5jPkpNnsjsz8mLoeGYaR2TzmdD5iS5s0jWl7iy9++Ytsd3uy85nUSgmVw+mwY2hqrtdL7h83Zq4OKMdc0s/ihHmScs4K2rpGeD4vbq457DcUTYfWAW/eGV7i9foGS0BVFBzbgdliAZZ90ZYY8O/r16+4vVljBT511zMCXdczDpNJb9kWx+0GJ4xxbME0dOjOYjab881vfhvHdXjx4g5hO2jO2LZFGIeUZYWajPOsrWriKEEO5t7BDmKKtjNjmSxn1D2rRcyb9zv0MOAlIUl6QxAZ+oMKQwYNs9kCiXG0WY7N9e0Nu82W7X5nSD3bE8dNiRso1DgSxhFFXjFOE45rfuyEEKZDZpmpQn8R+x62Z0MFkYKxa5mksS4UuYn+265gMV9wPh2wbAulLIqiYnW1Yv8uRNcZAuPCE1Ji6RrVvMNpauqyYrs7kucVwzBhewHJzUdgR0Tza+OAtGxms5Sma4n9kFA59LXpWBnObMB2bwS2pyxHakGnIYxTljcvePedr6FHbZBjUpKXJfPlirauafPCGM71QNe0OK4xdAR+zNB1BKHLWY8gJVmZM40DySw1uDxlTkjH3CwGN7dmwcrL3Hwwz2Y0fY/yfNLYZ7/ds1yteLp/T9tGXD+/43DOGNoe13E5FQ1inEytB0k/5LR1g+P6HE5HBBNp5NPWDcmF1iKERVnV+KGP57kXzFiFIwVNUTOFAcNoUqiLxYwB6Ccoy4LZbE4UBpwvXkrbkuae37KIkoQkjoh8i8PRjF8Dz6U47/n4gw/4ldOJ5fWapirQ44gb+gxDT9eZdPpsdUVRZJ9zOb04JDueWK7WhIGHGHv8KKHKzxdLBhwPT8TJjDRJ0YNGCNCjxFGKpsrx4xlD25GfDnhRCtL4Ph1pkS5W1JXhq8pJs1gsDAT/uCdOE8oio60ywnSFH8c0dcXQFkzjgJSgp5GqrnFdn9N+e2GdDljKRQuJ7gZzJ95/bxe83/Ye3v9Sz3d7eP+Hr/6fkbaiLEzQQyqb2HXxXYv7zZYBQeT56LEzc/7FgrzI6UbNajZnHAaEZdEWBYuba/bbJ65Wa/q2Rdk27969Z313g33ZWSKE+cEMfMZxoK5rNk9bVvMl0rGxlSQ7HLA9B2Ur9ARoqNuaOIl5un/ED0OkmPj45Qtev3tP4PnMk4QwTfjks3eME+ixJ40j9vsTtg1RGHI859Rtw9X1DbZtkWc5tpTEkUdVtjiBj2tLpJRsHjecsozlakldFYRhTFuVhOmcYdTUdY1tSeaLBWVTGdTP1JOmKXoUWFqAJUnj0EhVT2ck8PL5Lcq2efX6DcMksW0LIaHrWuLAx1EODw+PIATPnt0hbcXpnNHXBc+ev6BrKtpRs93sGEdB4DnM4oS8PON4PlmeEc3mMBjn13a7N+b2YTR2alviuAHn7IwtBoIwph00ehhMWrU0luggTtF9x2wWI6VJU3Ztb8ZL2Z7Vcs35dDboo9mcu+d33L97zzgMKN9jvz1iW4IqzwjTJdKSrFdLmkuStK0HitOR1fWauqooqhaJph96mOD/8d/+PZazGKVswtVLkqsPTFDFVhTnk+EUKteUxZFoy8HSpveEcMyOeuxQyublx19gc//ENPa8/cYvMzZnLGlEv0IKrtczfN/j8Wlv3qOWIprd8OxLX8FPUiLf59NPPuH69hll3TKNHcNkEFh1UZlOn+6NC7KpTcy+701p2bIZ+wEtNHXZ8Pjqm3z6a/+S53c3KKWIrl6i0mcs1msC36fMMoLYjKj1pBFioul7mAR1WRBGEbayPq+dtH2H54f4Yczu6ZHVck43arKixHdcmEasS7917EbSJGLQE5vNFls5fPjilt1mQz8OSOVSNxXjMDCfLQxYuShwvYCqbfFdC2VLoijhnBfstztevHjGpCearqfrBjOq7cxJpuk7qrJAKhdXSaZhYJgEnu9yPGa4rkMYhQSBz2F/omsawsBl1ObqZBgHmrYxVRgkbVuBNvfRvhew2+/QfcPVekleNGR5bpiiUQCWzZvvfIIfzui7CuV4dHWFsqQZXYYhXdORLuYIBqqypu8mHM+mbxvCOKXICjz/Inh2FNJW7LcHXNciCAImAfLCBe7rGiklylEo26bXkzm1DgND37FYXXM6bOmGjjgKmM3XF+hGcdkU1MhpQrkejudRleXnncninHH9/AMOuw3TMBImprDfdYbl+m/++f/1e9bD+75naR53eyxXIS1F4Do0/cCb7Y7VaoktFYIRP/CoaokfSwLPY72a8/jwSJXnRGl6OYWF1MUZWzlUbUN5PpPEKXEcIjUcTwXT0JNGPmWW47s2fVMbk3HoUTQVvvSwbNdE9THjh8XqyiRILUF2ylmulpzPBUo5PG0PLJcrAB6PGe3DE4EX0nQ9gaOYzSJOhw1NrYmXS66ikO3jlr7rGDuNtCTK8QjCiLKsKfKSc9cQpSl+kuBHEUM/slrdUnc1bhQhJo1jSarxYlGYQhLfJ9vvsW2HMIgZBoHnSMqmJq9qTqcTeui4ffGcV6/fMGpjYqiqiqIouHtxR9/1HLZPrFc33NzccMoLtocznuOwXiScpeljbXZb0iQliCLqumGxXjJ2Peks5XQq8PwYa7Iomort7kASpyigaBvidMY4dLRNjWBivlxxPmd0A/i+h3QUdj0grIm+6Wi6Ctf1uLtbsdlsqOqK66sl60V4iWaPWLYkK2q++fVvcnO9RgrJ7ngmCCOmqWfmLFHKYXW1psgKmqKkmjTDMJpydFma6IgUjP2I44ac9rvPbeRg7rBt5dHUBW1Z4ocxk5ioqpJpEuixw/YEgzZ3dI4PlpT4fsIwad7f30M/wKTxw4Cqy7/rB0JKyf39Fo0gWd0ShTd8+IO/m+PhDNKlbUey04a+HyiK/HP25tQPDHWB7jv257PRIc0X2LZF03Xc3l4DRufTD5K2G/E9jx/8od/JJ7/2r+iHAaUUSItksURYDnXb0WrBKozpu4Y8LwlCnwDLOCuFKS0zuXRdi23ZNHVHECbovkcpk8KdrxYMeiS73FvNFkvGwUwPBj0S+B7CEjRNyXc+/QTb8Qg8l6woTepQWAjHochrYwiZNIwjXTvhuAlVO9IPE2kao1yft69e40cxp1MGQnC9WtLUDfNZRNs2JmVoK8OqrA1fdTafMXQdTFDnBaHnMQ0drmsjhCKvKmzbhHyGtqeqS9wwRNg2Q99jxxZ+4NN3NtLxGcaMq9WcaRKcLlaEDz76CFcp2kWzwAABAABJREFUNk9PaGlR5SNd39G1RlAdRiFSSMbRNvYNX9CUBrbQD2bx1n2PlALXC6mriuVqRTf0eH5AW+Ukkc/udLrYYiL0OLI/n833Kw2QwfV9jocDTJooTLBsC6SpY7iOYYOOfY/tBSjHJ8syHMcjDH2kZXp4p+MOSwiS5ZKma/D9kO3DJyTz2fd0Pfi+X/AWy4iybqnLDEGCY1vEYYQUI7ZjkeU1TVlTNw3KVmRVg20JojRm87gzbwwGsvOZ5WpNEiu+/ekr5AR3Lz5EOA6PD+/x/Ijlak5+OoEUvH//jtvbZziWiZdvnva0p4zZasHses1hc2AYBV3b4XtmV5bEMelshuvFbDePtL1NfTozNhVBGHF7s2YaJ9q25fHB7Fqv7z7g8WnDYXtACkHkeiA1Gknqe1RlzenYMw4a9ITtOhTZGYHGT+YMuqeqKvq+YTafwTTRdAO+5xKFc/pe8LR9j3IDQt9FiYm8zGlrm7bv6NqGOIpYzEK6QV+izjXj0DJPE9q+5/C0Q0q4vrni4X5HU+a8ePmc4+nIqcwZ+9bExAcQQjGMI67n4rsOm80Ty7kprZfFGctymUKNlJJn12t2p4JeghdGDIMxLNiMnI4Td9drbAn7U2lCixd2IZbCFpqrxZxjVhpw7TiwXq3YPG6IkwRlY8bIk6CuSlQY8n6z4/Z6xWl/JJqlKGUTeC5t2/D08EAYJyAgOx9ZrW8Mpq5uOR8OrFZL3j9t8K0OoXvjrBPicrJsyfMcpVx8T2FLgbQkjjDSXN9ziaIUxp5Tf2DoWoLFiio/mVPRhWpRFmeqsrrYCjB8RQSr51/EjVfcfvRluqaiH0aieUJdVUxthx96LIM7As/ndDigLMUwTqxvrtg+7fjg5UuU6/H4sEWPPbYtaLqe+4dH9DQxSxIs3VF3UDRnpkvIRAgQY4ttWfRVyWw1R48959MeKSBNPMZh4lwUyNbBUTZ+FCKEYYtayiZdzumqBjFJLMsmPx9xHYs4inCkTV6WjHXD+m6JHgeC0KdpG87HI/P5knFocJRFXhTYUhKEpkJUnM9IKVCuzyk743kRtm2A1nVpvoePP3zO/nDGUg510+J7NtFsTp4XeL6PFwRY1omp15yOe5arJU2xww4CELZ5T481IJjNAlObOZcsljNc20LYDo7jIyXkk2DsNTBS9ANV3XF3d0N+PvP0uPkc/yUtiywvmM8XvH8wfWUVBNzdrPmNLKcbJOnCBH3y04HF1S1dXRsrupRoLMZJGDqPtFCex9TWxiqPoClzNBOHMieez9kdjrRNc5EVKxCmImTZikkPRFFAnpcwDnhhAJbpjW4eH7EchdAWmsm8p7qOcLlkGMzVynG7RYiR2eqKsW+J5nPu37wmXa445wXKcWmb/x/q4f2v4amanq4dSBZLJBPDCGEc0jY1XhCRphZCKQIpmcaRqqzILBC6Z3W1pMoLpBuh+4nt5sBskRJ5PsJW5HlJVeQoWyF0T1EU9FoThAFNXRGFIQhJURTMYp+ubTltdxRuwLObFe9evYLB49V3tkhbXsrTI4fdE8qCcRip6xbX9xj7ic3jBj8MSBczJgFlWSJtyXyWMA0DvdYIIdk9PfDs5QcG4yFhtV6R5zn3795j2Q561CSzBRYGg+bZAj0Inh43SMtivVpyqiqyssZ2jIHAsm2iKOZ4LnBtietKqrojTGKa1oQUqqamrmvCOKJpW0ZdE4UxgWuRFzXKckmTgGlsgYkPP3hJ3Xds7x9Qjsci8ukHKPKMqqxYrZZ0g+kJSSmZz+d02hS679+/p3Q9FuslQz/Q9ANtXRrnlqvotebTN+8oMsMSDeOEq9WMIjvRNB15WbBc/QDDOPD07jNm61v6/Y711QLbVhRVg5YS3/f5wfWXORxPdH1P0/bMV3M8L6BpG+qxZ+h7wijh/t07kmRO32nquuHh/Xss20Jozf19R9t26L7F8Y2U0wDUJOn6OZ7vomyf/LxH2RbDIGhLQ/GxLclhtyWKYxzPp8hzTvs9tjSHkyYvuXt2R5Zln1srJi0uiDZIbj6mbHoz2us7knTG7dUVWZ6z258Yu4Gqa00xXsNQVFgCpt4YNHrbZhIdH3z4Ae/fvkZKQdWOtHXNbLFguZijp4nTuSDXDcq96ISAOj9T5QaIPA3DBYTgmGBGXYGwybKMII6Q0iM/nVisr0lWCafjiXpzwnJcpDLGhShOWMyXPG62TEz0XYsKQ5qmQilJfj7TDRppm9GZHgXzNEFIi6aqmCxDpikviVJXWSznM4RU5OcTahxRUuLHIQ/bA7unJxw/om1alHJomx6tRxxbGAZvkppRJAODHvHDAClNKKXXhmPqOD5N3zJbzAhdRZZXPLu74dPPXoOwsJXDfB5zzkpT/u5bblYLdrsdj+9ec/v8AzxX8eqTVyyur1itlxd8m8QLfJq25d3DhmS1NHUJx2EaRqI4oOs7Jkb0JclcNyVBHxlxre3QNxVhGNEPA2kaMowe/dghpMVxe0Aphed55mqgydF6wg8ijvsDtuPgOB5DPzBbziirkmnUdGNtNg9NQzNO2JZNVmY4rkfTDrRDT3E8sFitmaURu+0ekGTHPUEUEyUJ26dHhGOMM9/L5/t+wROY9GKcRNy/f8TxA+aziPHQMw4NN+sV75+2ZgTjeFxdLzjlNZblEPg+0zByOp1JZvFlbFCSxjOKKodxoKkbrq5mOLbD4/aIH/lMQtAz8emr11hS8uzuiu1mQ5KmtOOJKInY7k5YymOcLG6fP+f1q1fUdU/gDKxXc5pxNADXfmAWh9jKIgqvqaocrXuulgl163LMS85Zxmo2Yxw1IHAcxcP7d/iuw+58or0EEaJZyv5py2p9hbQgOx2Rlo2KQ7QlCJKQqe0Yxt5wDOsKhWYSAtdxKfOcrmno0ATBnHkaMyKYOkmZ1TiO4lCZD+YoCphGzaBHpsmwE0/nE77v8dHsJe8ft1R9jy0lYZLSjz1aSuI0oixzpJ6YJ4kpqwYe/TAw9pLqcKBvjywWS4auoSwblOvQVRWe56Icl2NeXNJ4DQjJ85fP+da3v43yFK4lsTyHL374g/Rjh1SKD774Jc7HM1oo8qpBTC2DnijOGWEYmdFa25oNUV7gui5N3dA2FU1TE8UJu/2Wtu057rcwjuTnDEu55HlG7JtotbIldVlTDB1R6BMGAUGcEC4W1E1jFDPzOWWW4foB66s1+9MJN4o/p8g4gSFYLK6WWJMh/vdtx9N2TzJf0u5fXXDaXCSzAsuyUMokbxerJYftHuU4JMmcqGlJIo+qarh/95ZoeUMY+Oi24fH+kb7X7KsdfhCgtWGRDmOHlCNhktK2A2VVM/QtXdMQxHOU49N1BhYvJs1iFiFsF2HZNFVjNEtdS9XUhL7HRx9/SJZnHHY7pmnC80POh4OBZ0tYr+e8evUGaVlcLVe8+uwVtuvgBz5SgNSatukZxom2brm+XpIEikb3tHVH22uDsxpG+m5ERS5STwgJq+WSp/sn0qXHbLHgsN+TpCm24zBoAxWfL+ZUTccwQNs0ZEdDMnJcl1HXKMsmjhMDe7YsTqcMpYxxZZHGbA5ntg/vePGFLxjXZtnQDoPBjQmwJXRtTeQrHs8HJALd9aBHFsslyhYcDkeuX77EcxX7/QEhFfPFCt+xKQTYjkIIQVmUJHFCnpXsjzuy0xHXC0EKJBNhECO0Ga/XY0tdVkxCUGQZuW2xWK4NLN41SWrLcXEdRVMXTFri+C5VWRtQRxKT5xme71PVhrUZJgnHfWY2NY5LW9VMylCoJmFxOhzwoxjv6oayyDjtN6YOAWRFTRwndGXJarkGIdlv/8Nkrf+5z287S/N/6cdSNrPIpS5KZvOUQAm6siPwAsLwcjE7SqIgYtID798/gdbGcL3bI8WEkIKuHWnKilGPaEtiu4qqrQgDh6t5yjEriZIYiaYra5Iopqlrqrri6XBieXPD+noFWJTHA3poEdI2keBZzPp6jWXb1E1t5u5NT+AErNYrNk8mOr4/nhgnSXbOiGIzwnt2vcZXLlleME3Gp+VcKONSeayWN7SXgE3oR/jxnDSNmMSIVDZCSuqi4G61RPSaZLakqFq2+z1BFIGlWF6teHy8RzMRxwG2ssiqBsvxYdIo38P1XKq6MV2yIqesWuq2M2zOsuJpu8PxfMqy4dvf/DbOxdFWFCVNXWFbNqfdkcN+B9LGsV2apmLsO07HA/vTnu1+i+MFxLMULME0QV8X5McDQWA2KENfg2VO677jYCvF8XjixYsX9MNI2fdIRzG7WhkzA4J+1DiBj1IWru3AqBnageX6hryo2G+e8N0ApKKqa5hgMZ+hHAfXdQl9l+J4Zhx6pJBESURTlhT5CVvA0LWczgbimyyWBHHCR1/5UaS/pBYzmmYgSpdm3IrACwJGPWD7HkEQoPsePzSnf/SEpXzyU07X9XSdobLooWNoKrLj9nPT+TRpw+kUkvx0osoq+rYnTmOOxyNv33zG4bCnHzQjgtXtLQhBN4xsd0faARw/5ObuGXXTIoTg+bM7bm/umDRYl+CF6T82XN3ccnu9YH51xzCOjKNm6BvevXlNlp3JDkez6asL8uyEY1kczxmP2yequmZ5fY1SDowdtgTHVSbJW5qpQRD6tH2PG4bE8xmg8RybKPTQo0kLuo7D4ZghbIexG1hdLcnOGcUpx/MclCWozhmu7xIF5l7PchR103DOc7zAIwxcDvs9gwYtLfphIs/O1FXBcrkgTGYMg2aZJni2hec5jBYMAso8x3Uck9DsWz579Yau67h7/pz+ouhxfZdBa6S0TMjJczmfMvKy4vr6miAKcH2P29s1t8+fMWmNH/icDhmfffqGoTOd1N1my3Z3xvUimrrhtD/Sth2PD/dIS/Ds1oypV8s5SRwwguFhVjnjaOgxlqMM0caPWK6uTVVJKdAjjhdeNkuGl1lf2KZe6BkpdFOxWi6xXYehbwmTOXro8byQMJ0RxRFRHNLpgdlijrykkqfB/NmO8lDKxbYskjhCeQH9pDkXOYfTgaoq/ifpW7/V5/t+wTsejqgwQdo20zgxDiOanrKueHh44vF+g+O6HI9n+q5jtZyRRh6h6/D67T111eA7NsKR+GGMtBSCgQ/urtD9QBKFvHr7yGazJS8rxgH6cUJYktvba1wn4PC0pykazvsjSeiwWC1xHY/rqxm3V2vKc8ZynqDHhnbsef9k/lun4xE9Nszns0uAARazBXcvn7E5nTllGbtDxmyeoiwHhKCsjfpGCMlu8whMhEFEVZZkpz1B4LE9nlG2w2q1xnUVtnI5HM9MEsq2MfWQwWiKhmHk8WlLlKaUVcPpnHN1e2Pi4YcdXdvRNQ2nvMBSHkM34boOQgrORU7bdqaoHEWUVYkb+Nw+f0FTVWwfnkALyqqjaY37TGuNAG6uV9TNyCRgtZyje/CCmGnSXF9fwQBMgrtn1yxnIVWeE3gu0ySZuo7sfKBtKlxlMEX9aD7IhWVAxO/ePpFXDUXbodseMU6kyxnYtknJSmi7ilkSURY1T5sNUoDnqsu4uceSECUhx3PB/BIjb7rOCHMdZdiR0hid58s1h92RtqnMCcydsf7wK3jxAsdzSUKPIHDwXQfHtpglM4QGx5b0TUPfDCjXJzudGAeDH+u7jiSOuFqlSNuYtPU4ghDmDg+BHjW2hGe3VyAM5WT/rW+iv/MtnH/7q/ibJx7uHyirmg9ePmcWB9R5xmwWE4Yhvmdg1qvlAsHAw9OO0+GEo4xxPp3NzPczTZxOJ3aHjA9/4IfRE3R9h9aascmwLRtLubiekaP6QUjTjXhehLJcbGlRlyXL9RVF3ZHXLUESoxyXOs9YzufMAqOacT1zt1NULY2GHouiKnnaP9EzEsU+gx7wg4C67rBsyWy1JE3mWK5PXlTUbU/V9ZyzDGHbjKNm//SIUC5Z2dBWFVWWE4Yh+90e1/FZX695//7eINuQ6HE0pzEtqLKcbugQto3j+whLMgwjEphHHkPX0HfNRZHj0fc9VX4kiSK6znyt88WCXkAzaTaHA0XdUZc1ZVHjeR56aLm6XrO+WpJE/ufGkM1mR37K8KPE/D+fIPAdkiTm+tlzVjdrZvM5nuNwdXNNMl8QpwZg3nc9eX7CdZX5DBBgW2bMGsUxthSczybMlKYRF/MZjqOYhMJSDq5SzNKEaRgZhwnlOtRFyXF/wPMDxq6layoEI93QUeYZXdt9bjvpRs1hf2AeeshJMpstcGyLujAj1O/l832/4EVJysP7B4a+Zxp79oc956wkCkN+6Ae/xDhp5osQ3xUkQYDjBQRhzPZcECQplhOyXK3pes3T/VuDCWtKDsczUinyouCDl89ZLmZMQ0sa+dhSUBcF53POYpWSxCGnvKIbBFEcIqcJYUu6buCw2zJKi6bXxLOUNA3Jz4XpAMUR2bHg6XDCCyPKIufTV5/wrU9es3l4NLxES1DWJUni07Yt4zShsXEdxSydMY0Ddd0gLUUYpji2bWoadUuZHfEcRd/WnLKccdTofmDsOxzfo8hy8vMZ3/O4ubnFsk3adb/ZoaQm9BRdXeE4itNpT1lWeGFIEIXM04ir2QJbaKTQBL7LYbMhzwrms5kxSijFfLlgvZwxDgOWbXN9d02aJmz3Z/q+5+n9gzEvTxOOtLhbL6jLEt91CKOEp6cdyvOJkxnb7Z6uKbEswYcff5E4SXh8uCdMYtAjUzeQRgl6HOnaAsaBsiiN3DRNyc85T/ePnE5nlvOUrirQeuDlBy8BQ92P0gV+mjJNHWVZontTLveUS5QumYB2GHD8iKGuiGcLDvsdeZEhlIUeJ5q6wVIW3aBZX9+hNRzyGq0lVVkDkt3uiVOec8wKjocdUo74rsMwdKTpjDCKWK2X7A8Zr1+b6orr2zBN/2MHD2NiuH/3yP6zN3Tf+LdM//1/h/3Nb1C/+hbtboP9nU9RX/8Nmndv+eavf4cyK3j+7BY/Dhm7hlFP6H4wReh0hnIt6r6jrCvyvOB82DJ2HdEsNfqdrkXYLl6Y0HUDlpQMbY0fx1jKmDiUHzFhMwkYu5qxa3CUEQ1XVYYjJzz3QvGpa5bLJXXTcswK8rLkeDhi2y5iEkz9RH7OEEJydX1NnM6M7Fib02cUuDR1yXG/vRgHjiBt0mRmyEVcjOFdx3K1Qo+aLM/B9ri7veG42ZGfM4YRnh4eGYeOMIyJk5BzXtF0A13bgYar+ZK27swppm+5WS+JkzldPxKEPvMk5nzY0zcdYpqQ0kJPGpjo+9bIVUeBKz08N6LIG4YJummg63os275MpSRlazienrKYLUKWqxXNJbCUzpeGgHM6EPkOh82Gcei5ubkmCs3fa56badXy6powihjHEc9zsRyfp8dHqjIjL85keWZO8v3I0A+sr66wLBuBwFEWbVtTFTmnown49QN0bUfb1ijHpakrrq+usJVtPleUQnkelrLoh4EgSlis5jiug3IUi3nC0+MDVdPjeAHT/3/B+609bdugPI/gIjr0gxRP2Wjd8/b+nlF37A5HHC9kuZxz2O/45LPX3F4tcC3J29ev2W2PLJcz4sWMTo/cvniG63vUdU1ed+yOZ5QyqpXHpydurmYsViuEkLTdwOJ6jeO5nM4FWVZyc2NOVpOYqOqS8zmjzDKqrKDKK5TrIpSPrRyGrsNzPYSwiZMYMUnsUXK9Nqes/HiEUTKOE8rzGLSmKnMsMeFFEefTGWVJXD9gez5SthVSTwx1T9kMnI574tBnGCeEZRPHAZYU9HXJapkSBj5FUfLqs89YzlOK8xHExP54Zhgmojhh6Gpur65YpgllVdE0Hbvtnn6oub1ZE0cJfdvzhY+/iOs5fOM7nzJKm9lqTdt27J52LOYLhn7gN/7drxuTuSXRYmB1tcCybNzAp9cdAxZNN3Da7y89ujnnc4HleMyWCwYtieIU27axXJfFYkld1VRVQZEfEbrHUTbZ8YQezQisLEuOZ7ObDwIjq6yaFiHgfD7R9R1KCALHdJLevX1AWg4ffvAcW5rT3nyZIkSPUgZXVmZnwmROXdWsrq5gaJmG3tB5sKiKhrZvzCKapEgN+elkCBaOoqsqsuOBeTrjh37XV5BKYFvGZ5jGAZZyeNoYhVM4m5GXlUmwYu6m9KjRWqO0YPz6v0H++tcIszNtc8LSFgJBPlXm1Ls/wNd/lf43fhWahs3mYPRGnoOwBHXb0XcVbz77jGHU+J65fxRCoLFp6pa6NCqjftB4nsfN7TNTDr+5Ynl1DXqk72vSOMIRAhW4KNe7uCgNk3LzuGHoDDqPaTJBJzegbDvQBsYwjSMTmvNxx2Ixox9asCRD31OcjeFbAOX5THHOSCIP15aEng9iou9q4iSkHQaqqiWKIr744QscT3G1vuJqMWPqOxbz1BBUfI/5Yo5tSa7WV8yShDgKLpYVswjVVUPXdWw2T6xWc6QljF3A8YCRpuoYOmFCZbZinCaUqwiSi2Ejji+n0RJHCSSa4nxiHHqKrCD2jVW9rIw4Nc8LxrFHuQplCaSeOBx2SKGZz2LKsqJqeibX6IukkIRRjBSgh5EvffSSu+d3JIsUy7bph5G262Ca2D094IUh0lJMo4Xt+CAsurYjTleci5KiMIXzsqqoipKma0H5OK7EVZrQc7i6uqYpM4Z+IEpnSGnTDoJeT7iuS5zG9H3Hw+tX5IcjbV1TlB2HU8bYNCzThHEY6Nrqe7oefN8veLM4ZHf/jqKqWK7XSMcmq2pzp4Lg+e0dnu+TZzmv373H8zzW19e8e/eODz/+gChyOWZHuqHj4w8/YrmYs9mdaLqBH/rBH+DFs2s8VxGEIetFih+knIqWEQjSFGU77B43hJ5N1RT0w8jTZo8jDX8xTlPSyCdKjd4+jkI8JVCWpmprvFnCpEcsNHEUkaQxy+s1lhQMfWtoIpGPF3qEUcjd7RXzxZJ21CAt1jdXlN3ExETgRyjLQgrwAxc/CEnmVyg/Zjmf4dkWm80j0pL044Tj+cSzBU1dYtkuXT9wc/eCqulB2Ma7N5lZP7aNsCdC30MPmlGb6sB+u8H1bBzPZX/YMeqJwDc7v6IqUY4FNmyfHlnMZyyXK/aHAyOT0Sspxfv37xiH7qJkOSPExOp6xSk/4QY+11dX9FVB7Jtuz36/o2pqurYmncVm8Zw0s+WKEYGwJXcfvKTXBteVJDHTONA0rdnFrq8osgzLsgiTmNM54/nzK1AmdGI7Hp+9ecNut+Pu2R1a2DztM4IoZblY8vzuhpcv7/Bcj6GrKYucNJ3zwYcfMjGxWC3wXQcLge06bO/fU+Rn1nd3lGXBMHYs1ld4fkQ3aHa7PU1dMuoO23V5/eYtWk9U+RnPVSwXS/TQs3l4wMjwBN/dF9v9iN111FODj4slbGoaXBxAUOgKoQWesBG7B8Qv/xLW23ds7re8/ewVjCNaj0yWoqpK6rKiyHPOp7MR0A4dp6zA9TzC0JwUqqbj7su/l6sv/Ait+4xo/TGWZXHYbNkfchOP1xrHUYag0xmrQRgFzBYzugk6PaKnEd+zyfYnmk5T1Q1CQBxFBEFM2zasFzOkNhWI9XrFfrNh+/Seq7trlFK8frfhVLS0wwhDz3I+Z7WYEXo2lmVhScW3PvmMqq7wPZuhqQiDgFkU8vj0xDkvaLqBcZo4FyVlWbJ7ejQw+m7gnJ0p64LF9ZUpZisjkD3nOVVrSDJh5FPlOV074Lou4zBiTROzOKEoK7IsI0xm6EFjC8nASFUXCEZcpdDCQkrJerVg8/geIaVRZ7kOr1+/NifIKKLtW7pBM40dSeBQZhmvPn2HdAJi30WgieOI3WFP39fEcYRrCeazhNliSRRHxElk6kRlydXNgiQODZNVjxRVSVu3xFHM6XBE2jbjOGKNI31V0DUds+XKUF7yI67v8eLDD9lttziugxQa2zL/rd3ThrasWN3e0Q4jKkqIFwmurwhnKbYyppM0Tb+n68H3fUqzKktW61uO+xNCQhIH1I5Cdw3bU8a56Gi6BiEkQvko1+fh/j3r1QqlHK5vb9kdjtR1y333iJpsgynb7ilPJz768CVN27PZHwjCgKnTPD08Ec/mzJcz6jJnebUkz3OuVjPOecN2u2d9tSSMPE5Zxjk7wwSOF3DKK9wgoqpqhkkQJ6Y82tQ1x1GzWi3Z7A/Udc1svsBuW/Q00VQVvYanxw22LfFdhWAiSiPaumP/tCGdL7CldTETS+qqRPeKUTl0XU8Y+oRhSlM2+Mplt92TzmfcvHhJdjjT9y377YEkCXCVoh8HNrsdnu+ThCaVOU0TlnKxJ7i7uWJ/zvjszSNSSJhGXGExm8/Zbp7wbY+hbfHCGDlpjqczV9drujdvkdqw+dq2R9qKJAzpuo50HjMA57xmQvD+7Vtm6QyhTCFa9z1NUTLOFjTdSFM2OI5r7sMsG8nAebdnqBNc26HqarKsoC4KiqomTmYM0mLQGrSL59kIJh53R8IgwPI0nZ5IFi9oL0T7ssi5ef6crmxpup7Q92mamn7o6EaNr1zquuHNZ98ymDvfg8kIRqUALQS2bRvotW2z22wJ4hlSwiQ0Rd1RZSVpMkNrgeO6nE4nHN8jjGKyzSPi3RvmXcVuNFzD73I60RPe5FKKmpKGEJ9GtvRTTyx8BmtkZMCfXBzbom1zvO98gzjwGaKQ3VPMfLWgayozzrIlp1PGarXifDrjeT5lVVK3FV7oEc1mZLsD17d3SG7RGhzPo60r0nSGdCTL1ZK2rc2oWpgk9XbzyPrqilEP9HVPkgT0o2TsWtJ5gm0rJlKkcvCUTXY4EC9SNrudEeEKm24UpPMF0pbsd0cWyyXHwxnlKIQENwzYb7dge3Rtheva2EoZAWoP2+3O9AMXc/anjEkPzGYpketyOJ4Y9cBiueB4OiKEYDGfU9QNWkyMg/FTCiHoBlNdGNF0bUkYBOjIo2o709/zFENvYPB5ljNNE2VeIJTNKT+TxBHToLGVQ98PSDERhh739xv0pTLgej5tN5lwSJKQn09GOl0ZuLWwLAQdcRpT1y2fvH3AcxVpavOwqbFsE+CJooQoCvBcU7kozicsy2a+vGJoeg67rakKhAFDU2E7HtunR7wgIopjmqokP+akyxXTZLE7nJgGU40IfY/DbgPSIjtlWFJgW5IknVPkOcpVTGj6vmecJiopCcMYadmGpOOHlPn5e7oefN+f8CZp4UU+y/Waqm6JfZ+rxYzQNTig5Srh5d0z4jDAkRPbzYM5DUU+h9OJzXaLkhOWHrGmkWFsePZsRRR4uJ7H/nym7kak7VHXLb7nc/f8OSOa4/5AXTa8ffUW13EZ2hohRrRUvH/3yPFwQDIhbUVRtczShPlySds0OJ7DapliC3CVYr6cU/UNn719w+mc0XU1nuswiwKkZdMPmjRwcSwLR7mUVWfAy1VNELoslqaHaCkLx1U0RcEHL59hWYLT7p4sM445x7WYrWaEkcc0me8hP5ckSYxtCdON6ybaYbrM2X0cx2cYBE3VUpYFdVszXyx497jHds0o2XIckrnhKUpbEUQJp6zkaXdgGEa+8PGHBL6iaQ2BYug7mrI2SbazwXjZSrI/l3S9sWmncYyrHHMadSMGJnzX4eb21pSVB42UgmkamBjph44wCLm6uQVhUZYlUbIgDAPunt1gi4nD04a2G7Ach3gWEkUBXVPTdh1F05sTsO6Z2oG+7njanxgRdF3LZveeti5NOCOOCNOUKAiZz2dYjk2QLtBSEs0XBGFM17V0TcGHH75kkSbsnjaME/hBROAHDG2NFwQkcUScpOz2B54e78mOB6hyxPsHhn/93zP+21/C2z3inCtTsL9ogQSCfjLmglSaIM4gBlIZEDoOwppIZAASqqlBDBa2UGS6RBQFt9sj8zefkb19h+N4OK6HuIQ1DscDh9MRbMWHX/gSfdvRND1j3+NFPuf8THYuOOz36KFndzgjlUsYxijLZuw1Y9eg24a+75G2RZ7njOPEzbMV5+OWMsuYJgvX9ajyHKEnHNsYKRzHoh80YRD/v9j7kx7LtnVNE3rGmHW16sIqr3ZxqnvOjYyMiMxUJiBIUiSig4QEDYTED6DD36GVfQQNRBMJEQFEZGZE3CLuqXbhhZm7ma16rVmXYw4a086J2ySUp4EOMb3hri3f7nu7m9k3x/je93l4fXfDcj7ny8cfaLsaLQTjUUiaxNRNgRSCrm7RvaRTkJc5aZwwjUaUeYZAMJ4tkU5EUQ6s29PxiGFYJMcTwrDQSKIwQuuOqmrQwkDrHss0mY5G5PFwFZemg9ImcD0cIRA9mKZJMI7wg5DL6czlfEIhuGQZlmXhWCZlEtO1PYbhEAURnuPS1jVKdcPg2B8YhSHrq1foF6u7JQ1My2W/OyGtgcFr2i6jcYSU0LYtURQSeDYSie0GHC8FV1drlOropSQrcg6HE1lWk5c1s/Ua82U1Ii0L1bZURU5dV4RhhCE0y6tr2qYiiy/DPtq0iI9nsjSlrQrG8+GU/rzZ0XRqQM8Breopq5Isy/GiEZYlCIIA0zAHT2lV0vSapunRvSTPBiPLn/L5sx94jm1TFRVB4NNryeenA1XTYTkOi9UNXafZ7/aDOLNThOOIvtWcjzn0gtFohuOOMGwXYdkkSUaW5ozGEdP5mMsl4dOne5LzCdU2dF1N3b7ghgzB7d0r7u7uKMsa0x4WxmHoslzOSdPhfjryHELHRPQ9m6cnDFMyci0cU1IWQ03hcLzQdf2ASPNtfvL1Gy6XmKftgf3zM3lRkZUN40nAcjnF81zyLOHp8yNpUjKfjbi9uyJJUi5xRt3UPD3vaZuO8eyayPcG4klvsN8cqFpFh2Y8HdG3JYYhCaIIy5aE44Dz5YTn+fiejwBscyBB3NzcotqGuspYLKb0dYttu1iOxeFwGHaZ5yNlnhGFAXc311Rlye+/f48Gtk/PTBcjbMceiAxNPYQ9dMt8PidJcp6+PLG+Gq6suq6nSBOauubLwyPCtinLgjB0mM8i4iQdQNfzBT2QJBXnS8ZyMcW2Lbwg4BRf2Ox3TGdzRrMxXZUzmy/I8orDKcN0fd69fc0oDLBdDy+MGI0j8jwZCvmjiKZqcF0facrB5B0Pp/bZcoXtD0EDx7GZzxYc9wcM26bIK/puQIglSYzruijV0jQt5/MRN5py3Gwp8hzXdQk1zIqS6dMD7o+/gc8/YsYploKOjkY3L5UE/cfQCrpHGR2+YTE1QoSh0fQYvUFNR923GNqgRaFR+NolNB1qUSN68M8pk4/fIZ6+cHjeUtctjuMM8AOt6eqKUeSDlIPhva15dXuD7/ms724wXIvdeXD4pUlMGHjElwtZlpOVJdPJmL4aAAW9ElTloGMKRiNWqyWObeI6NoZt4vkeAj1Ug3TPYbfhchlkyk3fMl+t8T2fIsswDIM8y1nMplwtl1i2A4ZEWDZoiReNSMsO3YPueqqqIM9S3DDA9XxW6zV+GDJeLKmaIUE8nk7Ji4YwGqH7F+h039LUFaYpsF0XNLRVQ56mPNx/xLAMwlHE+ZiQpxnz6RTPi7BMiyKvQFjkdc1oPMKUAseQxPGFODkjBFRlziVOmM2XhFFIUeRkcULXa9peDdJdXXPY7bH9cKhGmRIhBxtLXiRkVU3XVlhCozXc338eTlRFiWkI6qbicNiCYQxDrumYjMZcXS2ZrlYEoxGm6yEsc0ikZimu5/DqzStc10aaNpohkGfbDtklw7Ucbm5uEVLSNCW9arAMmE1noBVCNXR1zfF4GMIqqzVNWXDaPVPkMZfDM6PJiD9tZOX/D640DQF5klKVBRo9pL3iI9PRmJvbK8q8wbAGyLHvR7Rtx/rKHfB6bcV4MuHzwxfW6yWjkcdqMiJLS7ZPe9rlColktZwNQRM9xK1lU9K0HdKwhlDKJcGwbdpW4Vo2fV9Ta8lqOQfgq3d3fLj/zNPmicj38T0bz/V4etwhhMY0rQEuHYboHtaLCee4wDJNCELiU00YBtjO8AWzLits02Q6nUPf0XaKtG6I82Ioi54vQ4+m7pCGQJoS2/UpipKrqxX7uqIqCqIoIktyqrojznLU8YBhWri+xyQK6eoa+hbXNghHY7a7A53SJOczkyhit9li2CadqlGVwvMCZvMZUnVs90cuxz2jyfhFwVNgWRZBENHWisVixn63p6wF08kMw7A5HE7MxwFlo8iLmtXVErYSiebqeolligHZNJ3ytNkzGo24ubnj/tM9jhPgOQ5l2SDkUN+o6po8zZlP5xR5SnK54Pg+p+0OxxSUeY5hubjC5Xw4kaYJQeCRxinH4xkpBVWWMVuuSJMExwvxTDClyer1K542Wy6XC+FoMuwdV1foTtFYkl63+KNo6BpZDlgOpuqYTJbkeY4fjTg8P7Eazcg/36PPJ+yywuh6Op2D1LS6RYkOVzgo3VPR0qPp1R9OtmBqiWUYZH3BVIzoUbR0BHg02qASNZHwEMKmFS0+Lq62kYagUCVjHWJ1Pd6XT3TbJ0b/wT8h9n1OuyO//Pk32KbJ50/36LZlOZ8g6anyGNU1nI8nmkqhdIfr+ZimZD6N+PF8QZo2Rgef7p+4ur0hCBwsOyeMxmyfIUkT2qbHsUxmyznNtqVVOWWSMJnNKIqWV6+/YvP4SFdkNErgWA5FUaKUJk5i3NCjR4NjY9iSukzpmxrDceiaFmE3RGFAHJ8H7qVhkKQxYejR1Q1CC/IyQ9MTjScklwuW1HS9JvSdAbBuuxTnC14UgtZYtoXn2zSNTZ4ldHqAL2Rpguf5CNPE9236rqOpSnQQMBmPyLKS8SggywoM02M6X6J6jW17g2g1r4e/T0Py7puvKcqGJCuwPR/HtnCDIbGdnE54Ucj+eEFreL1cYRoDmahqGyzTZrqYk6XJcFpHIqVFNB7jOgZVWTObR8RJwfPuwHJ9w/l0YDwaoXpBY1aEwYzN4zObpx1pnOKFEW1dURcZXadxwoC2qonbQdwbTZeMo4A0ueCGEeV2j2oV09mCc3whiWOyJKfvB/1aGEV04TDsqurfh1b+nR6NfNHQDwvg5XzK3c0thjRJTmcM06IoKyaTMUq3Q+er60iSBIxhnyJ1R11XNK0iL2uOpwTTdSiLAmmalHVNHJ/RQJqmHDY7mqqibTv2mx2rxQTLEkSjEV1VMwpCDGlR1x09PefTmelkiuX61FqzXM2RtktRNji2zWI+IvJcLEPSlDmt6kEIts/PCNUyXy3Qfc/26Yk8qwZ8T1VQlBWtNumlhdQCWkXfdKzWSzw/HBJuoiOOz/RSY5gG3333PVXTMVtdDSb1SUQUTbClZDSdk1cdvhcM+iPbokdTtoNRIowiDocdjuMPMlXVU1cVo3FIkSW0dU18iXn/8R50zWgypixbuloxnS7QWtO2zYDGgsEP13cc9nt2myOq0zS9gWkaHI9nfvfb35FXKZ0a5J9pVvD+w0eKqiIKfOqiJs1S1rc3WJbEMAR1WWCbNp8+PhCGIY5lDH0r28E0BEIKrl69pVOa6WSolDRtS1HVg07HdPFciyBwmF9fM13MBgjvsDDDsl2qsubTx894vo9pSQwTlrMBVt52asB+dS2r1QzLsfj63R2mEFwuCXFSUl0SuoeP2D/+nuqf/1Os+w+YSYJqa/K+pKWj1xotNJ1W2GLo+9kvcfGXEh5CCmbaRXSSWiuSvsDmxbQgOiLp40ubTnT4wqEHKmosbWFhDr1MKhxtY2JgNjXJf/vPmXz3AyvDpMxbul4TjUNsx0BKkPQIbVJVw4nu3Td32LaJlOB6Hpc4G3itWUrg+3hBQN21FGVD30EepwQvyqvJfErVtRwuF6JRiG9bjCcT6rJA9Zrj+UwwjegNi7IsUWjSNMW2HRaLBV3dcDyceLp/xBQCy3JZXV/j2INPsNWazeaR2XKOIQWO6XDY7IgvGVVdI12JaQmmsynxJcXxIiazJVXZkCXnwRpQ1eR5Tdd0SCHRneLd62umk6ETJ7TguD2wXi2ZTyeYhkD3PbbnE40nGKaF7wxG9K4bWK9NW3E+Dyf+sqwJ3ADPt6mbAtOyKIqaw27HfDZlMpqiO9BtQ5EkNE1DW1Q4hsbzXU7nhI8/vkc1DfklxjIMmnoofqu2xXUdrm5vMS2b8znBcl2UgjzLqKuK0+GIHwaMZ2M81+bmaoljSybzCDvwMF2XyXTykrh18IMI1bQ4jk2y36Prlu3jFz7ef+Jps+Hpy2ca1TJfDy+JUhhEYUQ0ihiNxniuj2EYdL3mcrrg+f/dDQl///mzH3iO5zKbjwmCCMcdUn9FXhCfT1zSnO1mi0Sh2oam7tgfDwSexdt3V+w3zzRVSeh5aKX5+ONn0iSnVQMJvusVGgh8H4RFkQ04pSAaYQiDX337FtXUfH7cUBUFVXHhP/yHP6ctS2ZjjzCyacqCp+cDnRLYhoVtODw+7SnShJurBV8eHnh8eGY+ndDWDY7rcTwlXOKE0XSO4/hY0qJrFdPJjL6HIPCHFJ1jMwpcLNvifLpwiTNM2xlAsVKANOkUlHlBUzY0VYMhLb55d0dXZpRlTVVWjMcjmrpl+/RInl7Y7XdI06Tra4IwwLKcwRHmWrx+dcNqveR8ORGEAW0z/FkJ00L3LaE/UBqKSqENh2AyRktoupbxeIZp2pyzjMcvTwgU49WKyWIBhjlEupUmSQpUW7BeznBMg7xu+XD/MLwdjqY0ZYVpG3iBO3Az43gg5GPjOC6H4wEvcEmTmOPhRKsUu/OF1c0NXVVC37K8WlMWJaZpABLf91gspqRFQd1DV9d4psn5cOGwPQxiW8tClSWm7LFMjdCaUTgiO18QlsXhdKDuFGXXDntaBtzV46ePiDLmtTqw3v0e6/d/Tf3bv8MpClpVUeqKTOeUVCjRDYSZXuEJB186mEISSGc43b5Ao2EQJpS6wcXE0ga1aBCAg00lBoC1hTmELujxhE0hKuqXoecaFpVoqHSN1w/l8F4o4sdPtP/sX5D9v/4556dnXNtiPFlwPOeUnSCOE5aLGWj44de/5Xo56JwM3ZOkJablMp5O2G2e8f0A3zJJ44QizcmKBqUFXV1yPJ6wbJ+66hDCJr5kWJbLaDzi+noI0FR1w9PnL8xWC7IkQyn9wni0sSyHcDwaqjMK6qbh+emJrusIQpcsTYimU9K8xPZ8LEMzGQ3ewb6tyY4nTCEp0gRL9qRpSlYUA9EoDDFt+482Et1r6rbBCwN+9/17Ntst19fXWKbF6XTifE6pup6iUmRZyeOXZw67DW1fs93t8MOQ7f5AEic4lsXtzZr4fMF2HLI8JYkzVqsrjrsDx90eIQ2auuK821LlOVprbMsamKSmieN4XK0XKNUSzRYDMN1yyMvBJHJ9c8PiaomQAoEkTTOElJgveQDP9wiigCD0MKTB+XDGcT1OcU4c54R+wNvbK26vV3iOxWwy5nw+UdY1jdIgBdPFgtF0igZMaaDKYZ86mkwRcvhYnS6WtC/uRMezELonOSeotid6CcX8KZ8/+4H3+PRI2bTUdTHsSFpF6HmMxhF1USKEBGmR12qAA7cdVdfSti+dGWGA5aD6nq4tMR2LyXxCVVWorkNaFkXdIKXECYJBl9J2mFJwSS9M1wsm8ykYDm0vOZ6GZFvXKpq65dWbNxiWy+PTlvlswij0ePvuFdPpCKk1P//lrwiCkMMxxvKCFwKGi+s7YAiKIiHLkgGt5Jh0quR0OnF9e8UoGpGnBeUlYTwaIseX+ML+cESaEknLdDwiHE9puxZL9ry+XfG827N9emISethC0nX1EAgJRhhCE/jeAKGWNnVVUxY5SZZwygt60VMUOeF4zG63I/BcTARdVTEZD2xM1zRYLueUaUpyPGAaYAjN5y+fEYaBaw3w4bJtKbICP5rguB6qbTBsA8M0GI1mGIZLnhaAxjWHK+jpJML1h5pJcr4wHvksZmOO+x33H77H9WyW12sMw+Lq+obZfIHqWjzX5niJccIJVae5XDIMISnSnCD0BsddXSO6jvViijBNnp93hGGA7BuoX6zgvgv0OK5H33Z4vo1hG2hVs1rOiSIf13WRwiDe7PlGlPzH/QP/8+CZ/83PTP7X/3jEf/4PrhgHNkoPbFSpJS4OLg4ONoFwmciQpTkhMj1saaCFYshlvuzuYPCY0dELTShdTCGpaQiEiyUkJRUWJpYwqGjwGAZoIQYjtqksHGmRU1LpBrt3sIVJb/Sc6yPmdk/7T/8523/x31CdLyyWK1arK5qmxXVNZrMxs/mS3e6EY1uMRiFVVVIWGVVTY3seCEkUjrAsG9v1mE3H9OqldKw6PEvimZKiKlG6p2lr8rKhaRqargNpcPvqFWVaDODlTuEYEq2Gl4oyzTCkxnV9VNMSBhHb52fatsVyHGzHJb7ECNWhhcafjHj15gZp2UjHxbA9pDBZXi3Z7R7pmobrm2vauhuEsJbECWyqpsGU1uBWBBzXpSgrsjxlvFwyXy8oy2oYTI6LakpGo5DldIIhBE/PG0wDJpMRRZaRpimGPQyFvlcDhByBH0aD2syU7HZb6rrG9UOE5VI2HaMooq3L4YX0xQPZNfVQBwo8piOfJE0H0swlQZUVu6dn6BVhEJDGFxzbQKJAtei+Q7cdeV6QVwVFkeOGIadLQpoV6B7iogIhGC9mQ8/Rd7iczpRNTds2BIHPeDLHDcZMpyuqLOH56ZGm67mc9ijVkJyPgy9SlYzmIxwLyjzG9d0/6Tz4sx94oteousa2JW3bDrR228B1Xd6+e43tD/f8likI/IAqSynzHCENBhCzzWg8omsVwXRM1Q1l0+l0iuv5dHXDbBIhVcdiOqHJMwwhmM8nPB3OKNUxny+IPAfVtRwuCcc4Ja9bjucTf/tXf4PrSBzX4Lvvv8O0JHWecz5d0IbJ0+cvlFVLkRdkSUJZ1WTpcN8d2JLscsEPAuaLOZ8+3pPnNb7n0guTS55RtRWT2ZggjDgdTliGwWQypq4a5ss1bdvhuh6rqzWv3r7CCwK6tmc8m2AYmpubK46HM1WZ4diC1XpNr3ssx6SrS7q2QxomruPjScFxu8c0DVbrBZZtkjcNSM18NqNpW9KyBAlJktKqjqqucXwXISW311eEgUunFIHvMxoNabOmLohGIafDnq5pBgGmlMRxymQyxXdcilqT5OVQLfBDxpMZiA6NJs9LXMdguriibjXT6YTRKGT7/AXT7DFMDUKTJylllnHYPJNnMT090jCpmpa86MiKlrrtuP/8wO3dDXWd06NYrNcDi9O0B5SaaVPXHY3quZxjJvMp++0OtMDtam7LI/9Z94n/sf6e/2Gw5Wu3ZO5JfNtmPg74L/7Tt/wv/ydf8e42xBLG0INCoYRCyKFYLuRwLVnrmlTnJH1J2TV/5Gf+AUFoSYmQGksYOMKiFsOez9YW6gUzLbUBBuS6xNMeQkgS8qF8ziD8TClRWuH0Lo6wkIYgJkHWDe4P98i//VdUnx847vd4gYdlmawWY7TquLu9pesU8aWgbjq8wGc0HuEFAV5gs91tiQ87pJS0quV4PNC0HfP5fCD+FDVlOohEV6vlYIgoC+bjCPoO3Su07vHDiPE44KvX1zw/PaN0xzh0SS8nlosJWkryPBkQXm2NacrBiBEE9PR8+vQRw3Y4ns8U+eBqLNIzZZljaMHN+grTkNiSgb5UFpgayiSlSM9Ax+l0HLp0jaLtFFXVYtsO59OJ0XQ8uDfzBNvzGU+v2OxihHQRfU8UjbAsE8MclDrjUYRlD9WE5XJG+gJbPp8HmPfdm3dEszmCHt3WQ5e0qWg0SMsZUpKNQqtuCJ2NIizHpc5z2rJG2BbKlLSqZjIdoeryj3AEy7TwHIe+U4wnI9brJY5tMIk8Is9mtV7xvNkTxymjaEytYLm8YrFeMJvPCMMAuoYo8JBS0NQlbuCRVymH/Z7lcoFpCizTAi1Jk4z97kCe5LTlcPAQloX4E/vJ/+xDK0EU0AOqF2y2W2bzKbvDHtv18LsWXZe4rk9aDCVuw3IwDJOyHGDQutdcTjtGUcglTrFMA9kOJfBMVmz3BwzTHPBTWjOfTyjqnv3xQpYkLOZLDrstjuviOx77wwnTsQkD+MlPvqEohl7ebDZl9PYVZd2gbAstbeIkZjSdMg5G2LaFNE3Oxy2mGxCfjgTXa6QpeXx6ZLlaM45G1F1H13UgTFQzIImyJKZpOqbTKYieOI6plaKsW4LQI0/PtK1N3QTMJmO6dkgKaq3YHfeYBrTKwDQtJvMZQsK/+atf8823PxlOmEVNVZQIx8TzI9KsQEhzQBzVFT0C1/M5HU6Mg4DsVDFZrEALPNenqwdtzLltaKoW3QuaesB6GbY9XC1aNuPJBM8x0brH80yUa6KEgShz+rYl8iN8P+Ljhx+xfJfFfMpssSJNcrIkZjwK2Z1PfP+bv2N9dcV0uaJRHa4ToKXAsXqyrOTtV1+TZjnZec9s4eFYBsfzgdX6mt3+hNErurrGj2akcU7gj5FCUKVn8rKlrYqhz6daenr6y4mvZcHV5q94PeqwFzWmACFtHNfG9xxsz8HxHUx7YKJ+/WbBaubzL/7mC//qt0fqGlxhDfxDOhQdtW5otRoSxgw+M4Bea4QG0fd0qsPERwP9y4BTKAwkUgga3WJpk46OloH96GCSy5qyLxnpEFMIlNGTqJwJIW7voCV0huCiMiLl414E3V//K4pJRHZ1g2VKtBp6a0lekucp48kCUVWkSYpSivQSUxQ1luwJI5+iKAgiD8uwyIsS1bXMFjNmqwnPXwo816eqSpLLhbvXNxzPFxCCTgvCUUia5pi2zeZ4YrFYYVgW292OXnfMxi5bxyFPNa43uPe0GKg228sFHYREo+kLG1NztV5ziVPC0RjLtnja7AgjB8/3edpu6bQxCJMNELaF44YoNUhjB7KJz/EUAya2AZNxSK870ArbthDCIM1jDNNkFLho5RCGEbv9kTzLCEbRUAUxa3TgcTju8LwRr9+9oW0Vddtjm5KqbzAMg15K/MChawfLQlMUVGmKH4aYrkt+OvH8tGcyjhhPpxiWxXF/YD4b8dXbOzbHC7KH5fqa+HIh8DyEZdN0CXGakuUFlinp+h7RNEgx6Jpurq8o8hzHNvEdhyo3XqpQAVEUUZYVnjvcuPhRQJokhNGYPC8HE4o3Jo1PrNdrqrpBmiany3FI/05nVP/eh/fv9izGM+zA53y8YOietm6wTIsqK3g4ngmiiKvVms9fHhHWoLZ3XJeqaYjjMwIYjUdcshzf8ymrkrws6PqGqlPovqGuKx6enhmPRuS1Ik5SwmhMOJpSNC2oBqUUpmnihwP13rRcNtsLfhiQxjE3Nzfcf7rn5m5IFUppIgHLcGiaEsEghbRdj8XVijIKOMUp0/U1qhvgy8IwmAYejmVTFDVC99xdL/Fcl6f9iaZpWMznxMngjTOkomo6XM9jtZgjpOR5s2E0jgjDK7ZPj0jAdx0c26Ctax4fHrm9WfPN1+84H7e4QYApJXVVEscFq+tbjLYlCH2qsiHwQ6qiJrkM9mTfsgjubnnaHaFtmcymmLbL6Xgi9EM6r0epnvn4lqZIqJqWTkrybPikapuG8/nCeDblHKe0Xcfrm2vKuqUHzvsdy6tbqirH8322T08sFkvyWPPl8xeWt9e4lkPXS/IiQTD40MLRiPPlRE/FbrPler3GlAI/8KnLjF4I8jxhNp+yfXrkaXtgdb3gsj/x/PyINARpW/PV23dsdhua9MKbkeSdn/LOb9FJTJOXdErRtArXd5CmZDwfYbvOUBSWgq4fgMSWbTGdj/kv/0chP31z4J/+yye+7HJUrwmEi9AwYNA7WqFQukcguTENCikHY0arsJH0aHxh0YoWRU+ve1wcpGgodUMgPJTuKWVNqWtGMkCjqURLpRv83iEwNDkVscoJtY+DTS97PNOmUBWt6oi0T3BK4HKi1zXut78gq2rOpxjTGb7ovXn1mv3+Gd91ycUZ17VQ3WA1b9qWp6cnLNdnZDtkL+gqXxloJcmSBKFawlHI5ZIi9QAzKKuB/mKYFmVZMJuO2Wy3TGYzLMuiFjb/+tc/UJcFozAkzyoKoZku5viOjevYuH6ApQYNVHaOGUU+RZ5Tq0EEfHf3iu12w3Tu4YcR6TlhMV3y+dMnru9es++OWKZJfLnguj5JllEWDdFoxKf3D8zmc+rqgu16WK5LdjkznYywbY8sSzBch6xuUF3L3fWKOE4py4ZLEuM4NoYhePfVaz59+IJtGwSe4HnzNHQMDYnrh3heRHK+4Lk+YeRR1wNd6nK+YNs20/mEvuswUTiGZjqZDIxhBE3TMRqNyIrB6FBWFaenDZZt4bsORZLgBRFlPZTVT4c9tmXw9PiEaZjc3Fzz8fvv0EK8+B4FWZEznc8xpaSqK0zTZjqdURUFeXrBDQIOpw2mITGdAFMM1aaRNEnOJ7Rq/3hT8ad6/uwH3sPzhiAI0QK8aERZlETRFMutkEIjNSRxjGVa7J6/cPP6DkPYTKNoiPjaNlfLNUla4dombugQX1JOpxitYbVaULcdRZqie0XoORhCkKQpN6/vANhtnimaijdvXmFaFcdLQpaXFFnCt+9useRPiJOcru85nU5M5zPqpiUahai6YzwdcbqkuFpT1JomrzkfL1R1hVCCXrX0qsELxqhOUfT1QHrohg+Yz48bwGIUjmk7RRCNUO0whPPj6eUKw2E+n+A6HsfDEdMQ3N5eDdQOBnmm4waU5zM//PiRd2/vuL255dPDI0hBNBnhlA5VlnF7e0PXKoTu2T4+4njBC4HFZH84oHvNYjEnuVwGRVJWEITBy97twHS15v7zA1EQUpcleVEyXy2xbJOmbnH8ANO0eXW7Zr/bc7nEeI5HrSq8IMJzLarO4BCnuI7DZrtluVjw/PTItTBwxmPitGQUjMmyjIf7e9589Y7sfOH66prN0zO77TNuOCJNE067I2EUkCUZTdPy6u1bLucL6X6PajvKYjBge9LAOW24efod34YVv1xf49kG0vZpfUlb+MSHC1o3FMWwV0HDaDEeBiBDf0oYEi2BHizb5utvVlxdj/jbXx/4q7/dk1UDJNzBwupNfMNDIgZggrbJRU8UBJx2RyzMF/P58GgBNS2h8HC1RScVZV/jCpteKgpV42sXD5deQtlXOJj4vYc0IKMiVRmB9ol0QE6Bb9nkXU3SZ4y6gMi0ab/7kfPThuBnf0GrBM54jO8YxFnMZDKiUR3SdDDNIUxRdw1JXjEfTwf3oFY4tollWhgGuJaBGYxYrRZczglZWSKkQBo2ppZU9RmJBmlQVBVXV1c4vsd+d8APA27vrtk8PnK9WlLVHbvtFjrFw/0XrtdL/CDk48dP+OMxxmzG+bTDsExWq8WQHBYay3RIL8VwotaKPI5ZrNb0qkWYAt1rgiBgthj8l9PbOWVdE4xGTGczhApJ04yiyMEw6LUgy1N2uz3z1Zo0PtKplk4IqraFLCbwHGzbw3IsPtw/UBU5i9mcOD7jWjaGbWNbDkJKqrLGj8YEfkDb1owmUw67HYYYSvPJJcePfAzHZbfbEo5HTBcLnp83zMYThAlZHNN1PVVdYQhYL+e0bf2y9jGYTpY4jkuaJAjToOtewiVVyWS5oG8r0qJF2iZdqzBMByEFhmXj+j62MYRkTNcfVku2A0gOux1C9LRVTfVC5SnyFPvFJfmnev7sd3i676jyGN33wxcTaVLmKXWREY1CbMce3q51x89//gsM0+Pz52fu7x8YTaZYtkmRxiTnPQ+fP7PfXSjyEtM0ub1eYFs2prQQhgQUlmXStjV+FLL5/MRlv+XVqxsc1+X73/9AEATotgF6DMPgt7/9nu12x9PzHtVLej14zCwhiI/HwXadFJzPB8oqw3FsnnfPXK2X3K7XNF2L6Vj40RiEJowippMIz7W5u7lhMZsOyCrXpCzLgY5Q13Q9CHpevVojTYHSPQ/3n7Ati/XVmocPnzidU7I4H2jwps3jwz2GbWGHEUlZ8rTdYJgWve5xLHdwhYU+Xx4+0YshYt3RAR03b+5wfZ/lYkXouniOSxCF9KphEnqUWczyeorj+0RBgGtZJJeEq7tb5vMJVZHj+S6q17SdoihKhLC4Wa8GQkuVE4RjmrYiTWPK+EJX1VRlzf6wZ7vb89Nf/pJWtXz+8kiappRlzuu7FbPZjKoqcRyLzfMjk8WMWnecLxeKqubVt+8YL5ZM5wv6HopyAEsH4xEmmhtd8Z9YF/6T/Ld8s/0XfM0WmcU8ff/A5ZCgOoW3XOBNItZv1ozGAZZpYNkG6SVne78jO2d0SmMYBqge+hc82Is3LYwC/sk/ueW//z+4IbRsLG1Q6ZpK1pRmQWmUVLKilTVO3RE/H+i7duB1YiCFxMLENkwaOlrdMZQPDGoapBZY2sSQkqTPcbDxsDGFJNPFcCrsXTxpYxiSjJy8Lwm0D0rgShsMQSwy+k5jdhZOUhD/1/9P3O9/w1y1w1WmBNP1adoOz/XIzxfqJMXQAltI8iRDdUMBvcwLqrKlU8PHkm3bPHx6wDAUhhBE0QjH9hmNQrxgjDQcHMshT1IeHh5J42zwwDWK9z9+pH4hAyF6lAbbsamKks/Pe3789JnZfMLIc8jiBCEM7l6/5Xw4EJ9OtE0LL2nusiiG1LBhYdk28SVFdD3T+RRpGFR1hVaa835HnsbURUarOj49PnNKMixp0xQVjufheC7rm1ss22U6HvGzb76iaxosKYl8H0wTTBPLNDjuDmCZVKqlbluiaEx2SYhCH9dx6DpNmeUct1vuf/ieMAzwbIP5as7j5gtKtWRpMYSKvAC0wXG7H17URwF12TAZD+uTtmkIohHHS0Hd9HjeELZSneLz44bz5Qz9wDkoy4LRyKfr6iGoNopYX69Z3t6gBVzOZ5arJUr3mG7AdL3C9weRbNsomroimsyYL6+xbIfpYoVlu1huRFVXf9J5ILT+E28F/3/kSZKE8XjMf/G/+t8RjqeYpqDXmvBFe3OJM4JJhETi2CZN0wIay7MxtaasBp1GnOR4tklZpMR5TVHWXN9d09Q1kWtwyYrBYGBZ9KpDaIkXhmTpBdcerL/SkOy2W2zLYhyFTGcTDnFMmWW07YAnsmyPrCjJ0hTPt5nP52RFhlACy7GxDYizgtl8wf39A1l84c27d5imHJiRdYVtDX0s3zYp6hbVdTiOy/37HxnNVrz76jXx5cwlTgeDdpHyq1/9BcfTifv33zFa3iBUy9X1FZ7rUNYdeV6yXC7Y7bcsZjPKqibNS0xDUhYFy+Wauqlpuo6qypiM5lRVMbBDVzc8PX1mPp+RxCmTycD8i0Yjuk5j2SaBZ1NUHWHoctjuSdOc0WSKH3hUZUNdlkSRy/F4JghChJR0qhvszmXDzdWCNMs4XxIMY1CQLOYzDvsTr1/fYpgGv//hI5ZhcnV9hev77J4/4wfRsCOUBsklpm5qHMflq6/eDWndpmG3O2FITdu2jOYz8rSgKSsCA25CwSzd8LNpT58cQfe0TYuUkqZVGFKg2o666fBHPm++uePq3R11ktLkOVVaEh9jqrpDaI0febihRzgOh+tmQ4Ix6H7ivOL945H3DzsOcU62N6A1MXuDVneUuqETHVII0MMODzQGElub+HiYwqSgRJmKuCsZ6wBfuKSyoNEtI+3jGjaJyKn6likRjrS5iJS6b3G0xUSOQGhKWVHrlrpr8PEIpU9JTS8HyHKrFAEurrBpzY5CD7xXb3wNv/wZOoqw3ZAexXHzRDieIw2TTrUElqTpjYFiojWeH2JIgW0aLOcjPt0/8u1Xr3neHXh8fMKPJniORZKkuH5IUzdoVbK+WnPJSrLLCd8Pmc6mZEk8sLX7nuurNadLxmb7xGyxoqhqoGcURWw+P3J1d4dSCt8dPIVpmlIUQym8Uy2nw443776iqioWsxmbp2fevL5lf7gwnoR0TUtdNyihsCyb3fNws+G4zvACMxpSqIfDidtXr/jxhw/YjsNqvSJJEpazMaf4Qtdplqs1u80jrmMzJP4lverI8oLAD7m6WrM9njjtd8wXK+aTiKYuaTpI08Fd2GnBZDZhu9nR94JoEtK1LevVivPxNGiphGSxmFBVBZbtMY0iTpeYJMlp6gpoubq9ZrfZIw0Dz7FwbQfLCXl+fEIamtFkgmk4ZFmKNwpJzmd82yYcjzifD4TjCWWaYVkGaLAsj9PhQCegq0uUUqheoxU4XgC64f/xf/4/EMcxo9F/907en/2VpuO6mLbB5XDAMAShv8byHSaOSXGJWSyXIAS90Oi2oy1KyrZhtb7lckk5Hg44rs3tak7guaSNIj6cGEURhuEgdUmWZlzdXpNcTqh2oJdcL5fsdnuqpmG9XnJ9NWezvZC1ivPnR0a+z3g8pgMMw6ZtesgzLFPiWDZlWWNZLuNFRHy60GpBlRd8Tu5xfR/XHmSnUTSi2J84b55594tfoFvF5nBgPp2gkaRZyT/8R/8h333/A8/PT4yDIYkaBhHf/PRrLkmK5Ti8++anZFmOFczAMNgfz9ieT56lICSjaMwlToGBKdrW7eDri2PKIqdWLapVdO2wnzSlQZGch8CN6TCd22x3O6ZROBSHu47zseb69pYkHr4Q5WWF63tIQ3M+HjBtD+lY5EXDdLlGqAbL9UiSBMN0GBsOj1+e+eqnX5PEF9brOXVRDoJRz+X+/hEvipiPRzRtR9MMC/Cm7iiLLVfrFUlaoHTPeDqjLYthuR5EoDsmI4+2rrANh+13v+UmDFiqEyt14leTCeG1iRu46PUtjx+eaMoGIUEagm1S8v3mQtl0TFyLU1zwq6Li6ts3OJaFNAzcwCU5Jggph0KBkJR5jdY9bd+zy2s+Ph143F0G3YvWGEJiKIdKdSijx+glkfZBa5RWtHrQ58DQtzMxMIX5R8amFmAg6USLxMPSBkooSl0TaR8Hi1Yq0r7A1jZmb4IBjWq5qISxjHCwkYYcrsC6kr7vCWVA35v0hsKRPXlXoenxlYeUkko0lJcnwv8mx/j2G06TMdF8QRSNB4r/KODh4QvbLOPq+pbxZERT1SRZQpFeuH39hofPj9RNx8PmQNsMvdEoGooY08mIuu3I0wttVXFzfY2JxpJgOybPT09MphPevL1lvzuSlBU9mqvrG26vVzzcf2G6mHKJM+arOaMwQGjBdr8nrw3SY8zi6pokvjCKIsRsNVzb93r4PK9r4iQlji+UdYlW3cvHdkLbKFTXMFteYZiSIs/R3dB9cx2HLC+IAp9oMqEqUrTqSPKapmoIx2M+vv8R07LxXJP0fMa1Xa6uFhxPCYbVsdkeGE+nTEYjLqcjj88bVss5yenEdDJhu92xWCyYRyMMBFXdURY5qqlI0+Fl0fMCDBTJ8cjqasWXL08klwtozZt373h+2iDpOR9jXCekUw2242ObFqYpWF0v6bqWw+HEYnWF57vkaYJt2LSdpshLfM8nPhwJR2Nm0+kA9xBgOCZVVqARmJZDkyaEk0GMfNhc/qTz4M9+4I3Gg9peSIHthTSqRzUtRVkRRBPSssHxLKIoJI9jXt3d8fjlidPxwGqxoJ9MOZ62HFIfz3VRqsLxHLI0pigSJtMJx92WKq9ZLhaczzGW7fK8P1LVDa7rsN1sh2s616anx3RdkiyDtEdIgx6T6WyC6QTkecHVakGc5nSq43Dc47guu8cN09mctmnxw4D95pk0TUiymKvVAm6u6IoCw3ZZrdccdzswDETXURQVpmVhWi5ZUTJfLnnz7g2OZeA3LT9++DA4sGybPElBK+gl52PCfL7k+XnHfDql0CVNrWh7xf75mbtXr3Bdn6rIMTrFL37xMz48PKBUg20YNM2AQ0p3GavrJYHrksYFN3dXRIHL/nCirkvm8xnH/Zn11TXx5YxluyRpQZ5kfP3Td+wenzgdtrx584rj/kgwHnM6nInGE25uVny5/8J0cUWnekajiOftAdu1mXku2rDoipzZdM7pfMCZOViWjeOYLBczDqeErgfTsWg6g0NywSly6qLk27c3pO8/85NQEi1iJn5K6Jp47gov9DA95+WaXPDmp695+PGR+JzSoanrFtcyeDMLWI18LCn48umZpqxYf/saw3WwXQfbH+zYVVqy3574fIj5/vnM4z7GsAYsmJBDclCKgQTTS4WNNQh7paKVLQ4WhjaxsAZwtBaYwkAzpDJbWirRIBEvSUwLU0gMIUG8BGC0out7LNOg0g0VNQEuuS5AWkMisM8JCTAw8IwheJN1Fb3WBHiYnUkjGzzToVINbd8Tah9fuhiGIG1jvN/9higYMfpHf8nF9ZGmzePDA7Q9i8UCKRTJOcENfGzHIzlshutDLyLJ9uRZRo/Ej0YsF1N+/93vCaIR68WCRGiC6YTpZETTdYTjN7TlIAwWwuKHHz4NO03D5HIaeLCGMDBsjyzNyOMLGsHpeECIwfZepBld29B1g7g3zVIsadBVFRgGjh9Q1A1pWuI6Dr7vkacZeV5yPB5ZrtZYnkvdVMyCkDJXnC8nDHewhavBcMxqOeXzY8lstaLMSizLGeoE4YDkGzyeCtN2+PjwhfXNHaLvqLKMPEnwwoC27VBdN9Q2ZhPivMAJfLSE9x8/MZ7OGI9GoBU3VzMOxzOizanpiSYzXFOyfd5iGgZZkmFaki/3nzBMb+g1FgnXb97y/OWC5XhkScZ4HIKAw27HZLFGCrjEZ7BMZvMpZZYxGvmUdTMkt8uCNEto24aiLFgs5kwnE8qqYPO8oW1bTMOgf+kR/imfP/srzf/Z//Z/z2Q2RzUtWZYym0xwHRvTdsA0eH58JskLllcrRKvo2prT6chsuaLOMmbLOT0Gu80Oz/OIwgBhWHi2xSVJqaqKpqlAgGlZBJ4/RI7jwem2ur6hqSr2Xx5QwuDu3Vu2Txsm4zFe6BNfLvRKEl/OTCZTrpYz9scTpmXS1BVZPRiwbdPB91wM2+S0O2JLGI0j4pfl8Xp9Q5omxJeYKk+ZjKeMJhMuScp4HFHVDR09ZVmi2443b1+Tpim0w5D4/ocf+PbnP6OtK5qqJfA9NvszWkjqoqYsLlzf3dH3irbrkKrh5uaOvGqwbIM4TRCdoqpqDMvB8zyMFzHnx0/3+L7P9XxG2fWczyfevr2jUxqlelzXIT6dUb1mPIm4nA6MZkvSOMWyJI4XUZfFIIMVgsPuhDQsqmbYLeVZied5L569HC0MyrLAEBYaTV0W+OEUz3eI4xNhNKJMUm7WUzanHMu28X2Lrqook4SV0xMcPvCX64Cx1dKUJX7kMR6HWI6FYVlDYMI0hoH3Qjdp65rD85Hd5kTbKKQUCEMOfa+up25alFJMZxHL6znRdIzqNYe04MPnPb/+/gu7y7DL61VP4A0dODFwgDEECClpjwP+ycFGK6ho6MWgfDKFMRCAtB4SKmgaWkxj+HXKrsXWklD7eMIhkyWN0dG0LUsxGQaf1ZCrGtkbjAnphKKUNb0ePIceDoHw6GWPtnqqvqHsWqQWBLjYwqYUFdLQdH2P7gUBHoaU1KIh1xWmNghlQHc7p3v9hkwMtZvxdEpdVcSnIxpBNI4wUEjLHRyQ/YAoO+/22I6D7TgD01UKvDDksNkwGo/42S9+yn63w7NtPn95oul7XNcnjxOWyyVpmlI1LbP5nDTJCQIbqYdbBqRg9/TI6zdvmc6mvP/xPY5j8dXb13z3/iMIA9cyBxel7/Pp4QuL6xV1WqKajmg6JooGcerlfOLm5paHTw8sVgtOp/OL4NikaTpuX11zPp1QXcdiMaMsSizb5Xg4Eo4nhK7k8XHPaDqlaxtGgctmu8eyHQQaadnopmG+WLLZbodwSnzB8RzevLrm/cfPVHXHYjklSRMc16PKC5q65vWrW86nE64fUNYVSlh4rsP+8RnTtIgmY0zDIL0cMJyA2ThiPolQhuTL04am62jyindvX3M5HzEsh1e3ax7uPzOajDgdTyxeEvC90limiZSCIsuZTCIOhwOTyXiQF798TmkNvudzPhxwvJC+yfm//R///ZXm//ePHrA22ugJozFlVbHbH+gwGE/GA9DZdMgvCeMoBNtkPFvS1B3acNHCpC5y3ry549OH96iuQRo2h65FIxkHPr5nono4HPZIIZiPJ+SGgRaSJE4wpMHrr79lv93x4+++5/rmjqfHJ8bTCZbt4DgG09kSSUeSpNiuT1PnzBczzu+/EI7cQQDruxzPCfSaYDrCMAVh4JPECXl8pmoUXV3huh6KAaVkGUPfq2lr8jRjfbNGK83j50dMx0K1HUJqbq6v6IGsrGnqwa7suCa675muZ2y3LafjkdliiS8FdVlTlSWbpyeW10v6tqVre66ul+wOCdvthsAPCMdjrm9vaIucRgvmqzVt1/P+h/e8+fod+8MO+aJe6buap8cnfvkXP+XxectkNqHKMvqm5Op6xfe//Q3z5RKtJWla0NHS1TmeF9E1JdFyyn6349XtGs8dYNN+MCYIQ5qX+sV8+ZbN44ar9Zz1esHT4Ue6siTbPPCPFoobP2Vs9ei1xpAF9ALfdxD9sMsznAF/ZDCIPnWvMV6GkuW6XN2tsE2TL/cb8qJGmBLHHt7ihZTYpsHzLubT5kxpWlzyikte0fc9dTNgwwwp0FrQ9RpbvCQsBfSALaA3DEQjKGWNZVj4vUurWypVU4sW17AwhIFCkXbDNa4tJaDxTYeyq4ehg4mrBx5qa3TEKmNMCMrCMyDXFWmfMyYckolmT6FrCirQEGiPvh1i+yPLI24LUp3jaYUvPGrVYBgCJXoyleP1Dq50sAyTsq+4qATxKad4fkL+R/8ZhuHgeQ777RbTtFkuJhRlDkhU17K4uuLh/gtFlpGcDlzf3mJbBk3dM5ksuCQxypAUXcff/s2vcR0XP/LpOs0kCjmfL1y/ukYKMEvJ3fKap80epXq6c0Pb1RiWyWgUMZnNGEU+ulfMFwtGk5Dt+YJlWkymI5qXYrm0TFzX43KOEarn9d0dcVaSpDmWIfHDkDhJ8EMfrTVKKeazMV1TURvQdy2+ZWL6EU3VMZtNsS2T9HjGFgZZ1SINQZ6m1FVBFNzQtTXz+YRWqQG6rDTb3Q5pWDiBhyhiDFPy+eGJr26WHLIGYZqEYUhXluhe4/oBT89bbNehNw2m/oTxZMLvfv+Brh2QgVVVY1sGN69fcTrHNKrj/ssOScd0OuF0vuCPR6RlTV6UuK5gszvRC0lWNFimwTgKeVCKm9trdtsjdVXihxHT5ZqyzKmajigcIwyTrhvS5mEQoHuwbZfAX/5Jx8Gf/cAzHZv0fMALQrq64ZKmRFGIkCYj3yMVkGc5ZZxC1zJbrbEdwdOXZ4IgoMoyJpFHfDwwjsYIy2K/2eBEI1zXI81illcrJoFPW9WEvkdZ5oxHAfef7vGjKe/eveNy2DKaTJDSYj4bEQU2SZ7T9Yqr1ZrkdCHPFWVVc9h/5urmmjhOWa0XVHnO9dWSJC0IgwDbcinyGEJ/eNsMRlRti1YN8+WK1WrJbrtlt3ni3U9+wuVwRneaq6s1p/2ByXTEKPKIk4F8cXV9Q1VUxKcLWZoyiiLCwGO32+P6Pk1dsrpac74knI8nbl/dMppNqJILWoJrudih9dKdsTAtG2ma9KZJXTWcnp94++1P+fH778iqGssUzBYrjoeY6MUKX6QFr968Zbvb8P5xh+w1fZJhSjiejthRiOEGxGlG13QsZ1N66bLZpERhiCF9osAH6fB3v/vAt998zXIxJc4r2kIMuw9HUJwK6lJxqDvi339H/v473LbGl9D8ImT91QrLspHCo8iGPx/NsDvL03JYtDsWduhjSgG6p+87RD9Am1WrkGimizFWkhNfcvKuQhoGp6TkyyXnWDbskwLfMRmFHgiBIQS90qh+4JwKIZBSIIccCpIhjDJAqjW9pXFam0rXtLLBlQ6hCij0ECix5HAVGpgOQgi01vR6EPQKNIYQCM1wGuvqoStFg0+H3ZtUosE3HbK2xNImIxGQqBzfdMi7ilLUGFri4WIrm8qomdgB5zYj0wVa94QiRPWKWg6DJGsLVN8jlcGpK9nXGe7qGnP9irkboNuaSeCSTcZoLSmqAf8Veh4P95/xHQ+p1YCf8zyCaERRFBRZxmy+xLE9LDlcA/a9YjSJuP/0A7qXhONouEI2LZIsJ28UxdOWKAqQlkT00FQuTdeSZwUgyYscyzTpm4Ltc4plD6uPtm6Ggafg08eHYThOppy2z5RViTQkQTjm44/fEfg20XTK+XzGLTx0r0FYXOIDb7/+ivglQObInrZrqZqa7377W8LJgiTNaJoGaZnovmW1WtGrlq/fvWF3iqnynGg8pqobEBLb8YgvKcvVmqvFmPc/3KM0BK7F73/4SDSZYsphH1+2DV4gMYXkvDtzUh2WNBi5JqObq+FrpzVIgbPLhdfXN+w2z4zGPmmScY7jQXFVVlBVTGZT+rYhS2J6IfD9iMVqwZenDcvrNU+bDbrVBH7IaDLly/1nMGwmUUiSpHR1i2orfM9j9/yM5ThI0fP5/t8LYP+dniwp6Hpo6ookTbFcn15D4LtUdUmRXJhEPovFFGGYPH1+QAqNgaZIz/ihxzHO6FqF0lAVGTc3V0yCCK06bM9nv9lRVhXrqwWBP/i02kbx9Tc/xwt9Pnz8SG+6NG2L7ft8fngkiVPmswVZnPFv/upvUL0ecFF0+IHFcr2kVZqegZGYly1d37F/fkY1JWEYkaclhu2yvl5h2R5hNKMqSxSggLdffc35eKLtGvLsQp0nuK7Dw4f3dJ3G9zy06jhfUnp6BD2u6xKfT5TVUILNkhQhBOfDjtCxCHyXw37P5mlHEI24vb6myIZl/XQ+IS9jhFAIoMpykiTh5vU79vs93/7kW/LzgTy54LgOhjQpi5aqruhUT1WWvLq9Jb+kuJaJVg1h4FOWBU/3D4yjkG++esObd3fEaYKU8PbVHeiWXlp8etwhDcl8veQcJ5hOgBA2WXomiBx00+KgiZI96l//v2l+/TeEZY7VdaRlyf/1X37P/+m//o4kLdHd8P/gBQ6d6ulUP9BuXrxvqixpq+oF1CzQQiAQWJ6LN4m4eXvNu5+9Zbye8uGQ8n///SP/7MOGf/N04lzUg89M9UNh/A+nOEAyDD0EiBdrudZDDEW8/B6GGvpPtWywhTVUJajozQ5XWIwJkUrSd5qu7WjbhqZt6FSHVAJfO4R42MJE6Q6lFZVqhx0hw3DUanCngaCjQ2uNq23avsUzHTqtqKgp+xqjN/CUS697ZnaIIQ0yKmKdgNa4vUvXDyCzj+WR964ivb7B/4t/zPIf//d486v/AMsadnJ9D6rrsSwT1WnauqfuFcF4gmE7mK6DkHD35g1hEBAEHkp1mLZBmV5AtdRVjupaNo9P+LbLerVkt92/6LqG8E9TFcwWU3zXps4LDrstZZUPjNeyQkiDWgm06XD16hVFnuMHIyzDQLUtb+5uiCIfP/KRlkUcJ5yOBxzPJ76ceHx8wA19ovGMtgbbCXGCEAwTKQxmqyuOScbzZodhSg7nGNUpLnFCtLgiGoX0Xcb11Yyb1Zy+bWnqhvMpZjqf0zY9eaMp644wCFgsppRlyeH5icvhyMPHeyTwtI/Z7k/QNUyCoVaQJCeE6qjzhq5TjMcRX3/7DT/++Gl4qR5PMC0TP3TZbbaUTcfxdOZ8SbBdH2FIpGliOiZZfKbKh523adn0UhInCXGa8He//YG2G67LpTRpuoa8LKi6AYAwikLyohpaOH2H43qUecpoNCaMRrSqHxBlf8Lnz/6EN5mMMQ2JlILbuzHnS0GRX5iOQ5K8QCnFar3ksD/x+eE7wtmSuu24vn3N8/aRwzHGMQ2QgsB3MJ0JSjV0VUPoOlTNEAi5v7/n27evUSj2+wOTyYhPnz8RjMdorYnPZ/woRPc1TZ2jdYdflNze3PD+4wd2+wOL1QJbD1H05y+PdL1G9QZRFNB2Na7joqXAcAYnnWkaHDZPXC3+gm1X0ysDx/N5fn7i1dWKvGrJy2oghkQjpOVg2ga/+Mt/wGa7wzbg5vaaplF0XY9WmuQ0YH7arqUXYLsueVXx6vaaU5IOPcYspWlKujLlpz/9ltp1OZxitqeUMAyw+o7IG3p2WVrgmALXtYmThF/98i/o6BFC4NgVu92BVitG8wWf3r9nNl9gWIK4KLGlJs9T5os1VVXjet6QhEsTHN+m73saMexCDF0Sn49MJlMW8xl//a//mvhw5O72hnE04vi731DGR9KqwFIC2wCFxhKSTvdUqkHpnn/5/pmnc8b/4p98yzpwoO/xXQcpJWHkYwcDFYW+pylKyqrFsCzswAVzwFUp0+SHzzs+PZ943p35eEg55y/sRq3pXzp2w/d/GGjDCaxVg/ZHGvIlQq9BCOTLKQ0BjWzxtUtOQWd1uK09QAREhSVNDDEMIEMPDE6hhySjRA4DEzmQVHRNJRpaFLzwNW0GjqNm+H17NEr0KPqBbNIPTjbbsGj6DikaTAxsbeEph4qaiRlQqJpSNVQqoe8kuy7HvX2DWt/x6i//0QA9dk0syyQMfapTi9KKz0+bQRlUV+TxiWA0xjRs8vyA43hMJxOqsqFHcH//wOuvvsL2jui2pyhLDMvidNhxfXUFjk3bDEqq8XhEllwwLAulOlbLBVmactptWKxvCMdjksuFLM+HMJdtUJfliyLnxOs3b5lPR7z/8SOWZZJlCXWRMIoikjilLErm6xvqqsHzPOaLGcfthsNuy92bN2SJoq0a6rokzlIc22E2jSjOKZfL8CI6m4z48YcfMR0P6pK3X73Dcmze//CeyWTMfLGEXrE7nDFsE6s2MCzJ6RITNC1d3bC4vqLIzoSTW2bjiF51bLZ7oumUd2+u+fR5Q1EMqL8yy1kvZ2z2R3abZ8bTEbPFnPiS0CvQfcloNkVIQVZkzJdzPn98T6dhsVghFPzs5z/l8XFL2fRIWyN6cAybNIkZjaeEvs/5eCC7ZGjVspwvsQS4rkVdlSymU7K6olWaphlA2CDZbXf0SlHm6Z90HvzZD7zz+cx0Osc1HQ67M/PFhKJIOZ0TVAdRNGW7H04cq9tXSGHSlS1ZlTJfTCiLISq/fXyk6TXFZsdqtQJpUNYVhuUg2paffP0Vj5sdXhgSRBPyomC1vsJ3LDIpaDuFa/RUTU80n1KmBX2vGU185ss5pjSpqppXNwu+P18whIHv28xnc0x6TnFCWSkM2yLNUrq2wTQko8mYx8cnPNfncjkzX67Jjjm//s133N7dYgmB7/l0uifPBodXetjTI9gf90yX1wN8Vgi8cMTbn/yUOs9p0vyl+gBN27E/XQBNqwSL9Yr9fgu2RRxfeN6emcwXdElG50DbdayXC/peURgGHz59Zr1aUZYFHz58oFU9jjuEEObzKVmWI3WPNAyU7nn39g3PXx7Z77bcvXnHcjFiczzz8dMDr9/c0Tct33zzFWnR8LzZUeQ5oFgulkjT4Xd/92+49T2ahyecDw9YdcO8q4j7DEULGFgMluauV+gerowJlaopRM3DIeG/+me/5r/85RvGjklkm9xcz+laRXtK8WcjDENi+z6q72nLht3jnkujeDpnPDwfKKuWXmtUP7j9ej0MN4GgZ9jH9VqjGa4v6TVtNzAx0WI45THs8/qXj2WNxpASS5tUosLTLlVX0ZgthjLxepdSVXSGQpsa0QvM3mDg7A9nSKXVCzezoxEtDR2NHnqDpjYwMVDiBSoNw9FTa2pdEwgPD5dclYwtj0OT0dAOQxkft7extUMuSpq+Z19V4AeI1YLFq/+I19/8jLwoSLIchMD2IyypeXx6IvRDyqpiPJuSXk54fvjCwR1OucvlgigI2Dx+4ebujlOaoQWcDgdcd0jdzpczGjWoe6TjYymFYdss5lOenrYo1eLYBlWlsGyH4+FENJoyCgOKssDzHdTL38tqNWOzP9EpQVFV/PjhE8dxyGw6xnVD7r8803Udo5nPynJo2xrbtmnqDtuQlFmORvCP/uE/JK9K0EMi20APV+Cmz/e//T2242H5NkoIvmw2TOZTbHdEluccTglyeFvBcoYgVlY2dFWJY9vkfUPoLVlMZ7z/4T1NVTOavMKZD93U437PYjnH8Rxsy+I3P3wiOSdcXy25vNSJmrahaVtevXlNnGZc4oKu7RDyZZBGI7LDjm9/8g1FWXP75jWX04VLHDObjnl63uF5Dk3Tcj6d8X2fN1+9ZbfZYRiCUzzIed++e8tptwOGNYcUksvxQtcOBCbTtek7he04pFnCeDJmOpvz3a//9k86D/7sB950PCJwTdqmwPE9wiDgq7ev0Frww3e/Q8gxRt+ilIMlTdpecbxcsKRJdupxPI/zKQbTpKkq1os5fdvRaY1pOfQIbC/iaXPEcTyev2yQpo3vCLraJOsFCIOiSAmjiP3TI7c316xfz0jyiqquUGWDaSs61bPZnPBtizAMSZOEzZcvuL7L4uqK9z9+wvN80ssB1/UompbFYk6dZSSHPYZpkSYFtzc39E1LlmVD8d20mHoOm/SCsByi8RiN4ur2jqoo6bqOOC3I4xzDMElPRzw/xA9G5MmR6XRg7K1mCz4/PFBJwevXrynzgmC6oH3cD9cctoVqBvB0nNakWYwQAsMy0YaBH424//SeaDQUgeuioi5L3rx7w+9/93tsx+V8PhOfT8xnUwJvxOmQsHl85Bf/4C9o2prTJaZVit99/xHPD0nzYiCZOCbZ5hnOR9wvn6iLCquXlEgqBL70sHHoXvAQXdcjELjYg4JlGD1/vFqMi5r/y1+9J7BN/qc/v+NqOXkxQwhU02H4DnXb8nl34X575sdPW4qqIfBsVD8IejXQ9XoIS/IyO4C+75FCDBUBwXB6E8PuzpBDJLPtFNoaagV/uNb8w69gILEZ2Ji+9ki6DG1qTGnidR66V1R9M/yefw9GKMXA1Rx6fopOKwAcaQ6kEyxg+O/WQv+xyK5ET6s7ejQeDlVf0/SK0HQ5NzlCQqUratVyaSt2fYGYTpn/7J/wy//4P+XH+894nsv5dMZ0XL7+9mu+/+131EWFMw5xbIe8rjEQWGIgjASBQ9c12G7A45dnDKHRXQeGQVnVVHn2kloVmI7Ph89f8C0LEwvHtAabuB5EyNsyI72kBFHAp/cfiCYz0ssZJSTT+ZIGQZoVoCVWU2NZBvtzQl03zGYz+r5ntpxTNxXP2wPLmaJMExZXa/q2Jy8qDDmQY3pdDyX2usU2HT49PPL05Z5oPMXxHKo8Zzydo+oafzSibTsC3yPwfR7vY7K2wcMcgk5AHCeEUUQaJ8xnDuvFjMfHDU3b43hDGrqsW0zH5KuffkWepmy2e4Io4u7tG3zXY/O8wfF8lCr4y3/wF7RNRRD4GNZgq7+5eUVTK2zbodeCrjNYrVbsnx5ZTANOh57PXzYYAr7++i3Pj49MogjHkmRCMJlMKYsCx26oypzPDw+4vkdWZHieTxtXuK7DeDrGdt2hg+otQQ17SylN3ry+4+H+88vXJrAdl4eHe2ar9Z90HvzZDzx0T5bG7DZbwvkNRycDrVBNw89/+Ut+/PE9UTTifIqZzyaMPYf5ZMzpdMYOQuq6oW67gZoubZJ0+EuMkxNCGHz7029JzzFWNCXLMvzRCM0gPzwdDtxdT7hcYsbTKY9PW/q+w3ctyqrBMCTJ+YjjeTRNjdBQVyWn7RPh198wW0wpihaE5LA74loWdD2r1TVFVeO5EVVd47oOnn+D1j377Z6nLxmWIQf6h1IYpkQKb0AlJRm73QYvCEmKktV8Sl2moCo6bdM2LePlArqWwDMoEsHpdMLyQr778UfevLqhrGrOh9Owu0tjMG3qsqCqck75lvX6jpYeLwgo0pzlbMZyPub7Dx+IxhG9MKjahigac//pAcc/8O7da1RdUbVjPn8ZqiK3b++osoIshSwr+cnbO8paURQFP/zu75jOVlhFSr/5QnHa49Q1uu+QWlDTU/RgSxNLGlSqxRM2IT5KDFd4w2lnuL5rdPvHAQBDDaBVPUnV8tdPZ17dzJm0LUjJw+bMse54PFzYn7MB4NvrlyvofjjJiZdrRMEQEIE//hj+cLoD9XK1aUo50OjVEEzp+mEwDzeaAkOCUsNVaNE3BHqgm2hqIh1QdCXaVGCDaCVjHdLT0+h2sCsINYRWXr5JOVgRpJa4vYWNjS0sWt1R0Qz8QyFerjaHASgASxiE2hsCLJaDJUzObUnVFahwzPV/8A+Z9Cavvv2WNL7wuNmRZyWG6fKzr98Q5yWGMVzRhq5LkSQgTEJP0tUVWrUkaUZZ1y83CeeBnL+Y0+meThho0yQIQ5LTCdn3dHWH7wRcXS3YPm8QEgzLxLU9HNPEtCxsbzQU5EdjbMcjcF0eNxuS4/llH+XSViVeEOL5HvQdGQKFRNJz2e8Yz2a44wXStpks5pxPJ+brNcn5iO3Y2HZIWtQE4/GQJE0uvHrzFjeM6LWiKMvh1sf1SZOYMAy4nM90Vc0uK2heKkLpJcULfISuGU8ntJ2majVF1/Pwu++wXI80zZBCsz9fMAyTIAg57Q8IbF6/es3pdOLxyyOT+Zyu19THmB749PCFqsj42U9+gu4VfhCA0VMWBUr1pElGNB6TpgkYEmlIRqMQ3/cwDYP3n75Q1x3BdURZN7iBy/PzI5Ztk+clfhASOi5Kdai2p3cF0/WCrK6I44SptGjqFFREmlVMlwuatuHz52foOvI4wbZMLufz8BIq/r0e6N/pkYaB6g2mszmmY9DWDbof+G2//eE9ge+CITAMjeFYqL4fLOfjEQ8PX1isrghcF0cY2KYBlsAwBTc3t2RlzubpC+PxlDLJBn+Y7VCWOcnlhBQ9nz68x7ZtDMPi5mrJZnfgeXcgCn2qF7JI19R4YYBqWy6HLcu7W5RQuIbH8bDFMA2CwGU6X/D48Jm6KXEcD0HLfhezWsyoqxzPD3j99hUfPt7TKYPVck7TdahWcTjGNHXOT376LYY0sD2f7X7Dl80Tdzd3VN2ewLZxbAPTMDnFOUXZMZnMeDUZkaQlTVmgkMyXKx4+vCecDCm5wHOpqpooHGEbkl73VJcDlu0hDYnpuBySHNvxsNGYXkiR5yzmK9q2Zf+8x3y15v79B968+wbXkoMp/mGD4zn40ZjtZst2a7CcjpFxyrqp6f/mX+LlCqPLaEWL0Rs4eLjSwRCSCwmtGE7jvdA0usYYxDj84fPIQGALC0+47En+7YlI/9vvPh0S/qt/+mu+Wo6xpGAfD4Zpz7XQvR7K4JoBiaSHIWZo8bKT6zHk8AX+Dye0P1xtwvC9ZQ5in77/e6pyPVx7Sjn8TCEEmmGYti+ePw+HQlYIOvzeG66njBbHsmlUi+wlvvboUS+hkZfhxaAPGi4wh4K6xBhGodC0skMaklb3w/8LEqGH0juALSzqTrGrLhRoZj/9FdFshbu8wrJdvLYb1Fq6x7YdmlZTVzmb3YE0SRhNJlimwLANykszdAsrxfmwwTDe8OrNHcdTwvGUkSUJr169JssKTNtGqIYyq8mKDN/38YMApVIMCZvnZy6XC5PRiOR8oLAdZqPxYD+JE4o8p6yaF8t5Spld8PyhNrBYr7AcC2lbmFoSn3N0W1NWOVlZEUUetgFNp/j0/j227yMtB9W0CNlTtSVPT/fM1jeorkc1HTc3d4S+i+M6IF74oF1Ll6VUlaLNc66uVsymI46HE2hNXlRE4yH4dj6UTG0foy+Yvbqh6RSCHscx0cri1d0r8rIhvpxxHINLkmHbDjN3jB8GZEnC7vEzrheQxye++ckvSNMY35/zb/7275jPp9zc3bI7XBDSoMoGk7llmKRphmXb3H/4hJAGcXUiCAOaqsL1fb48bpCGieeY1FXFeD6jaBrKuuLVqzu01uyenzBtC9Nw6DuwHBsNNG1LUZdgSo7HA0Jrbn7yEww0aVlSNRWObXKzuObT+x//pPPgz37gNU1LEET0fYtSmqvrOfv9AdX3rOZL8iwdYvvSIEszmjKn17Bcr1nOh6sHdI/oW6JoQpImGL1kv92ilOKbr99x//DAaDqhiBM8P0Q1Hd50zmIasdseOV+OBB5kaY1rD4v0spQYwkAaFqNxwOW4RxsWo+kMoxesr6758MMHrlczig5cz2YyDqmXK1TXsl7PSLOCyZsIISA3bT7df+HVm1e8evWK3/76d9imjeMITNOlFTVhFPHh4z2W7ZDuj0RBSFNVJJeY0XjE8/0nbm5vebx/xPJDwmBMcjrRlgXb7YZoMqVIcuJLStcrsiRmfX2DUprjfkePwfr6mr4H/3rBw+fngRhhe2R5zGo1pysHZqkpYb/bsrq95nI8crmUBLM5aZayWi2HQErb4wUODz985Gev7vjy139Dlp6YpAqnzal0jS1G2GJErBM6FI6wX5DIkokck/cFJdVwdfhijNP0L1eYw2xRukcKyUSEbPrjy9DTfyyUA1zyih9axdXYp1MvV5JCoI1hCAyhkpamUwMH8+WfmXIIiuiXX0j8YeCIlx/r/o/BFENKTKnplP7jAOx7jWH84VpSvHAye0rR4GuHQlU0RoMwNGZnIJUg7ytswxh2SrqFDuzeQr6EssXLf5tgGNQCaHRLIzpKOXghBcMpc/hzG37/qm/JVc5zl5Cakut/8I95/eodTcdAQnFcksuRxXo98BHbhq6psS3JdLLkeIqRUtD1/UA/MiSWbeD6IV3b4UdjeimI0wE5ddnvh4K/JfFDj7qsydNBzDqbjthuhrpRVVcoBJPJeOgzdprRZDg55FVHVua0bc1Pf/YTPj08DeGnPMXwfCaLBYaVYogO1XbovufhyxYQ3Nxcs1zMKZc17z+8x3F9PM9lPJtQVTWmIamqCsP2iHyPpi4Zhy6Pn78wmkxIiowkzxhPF5xPByZRiGc5HI8n7m5vuP/0hfMhpSobNs+PrK/vqPKMvm045xWW61LmA5c2Lkp8L+D1V98ynwTcP3zGCwNOhwTHdphOogFsgODDdx9w/JC66giCkNV6xcWycXyH523GZBwxu5rzzdfvePj8iO41VVGjtKBqCsLIIwjGbI8HljfXHDd7ZosVpmVhiBTXd3h4fCYaz0FKZvMVbVXjWibPjxt2Uch4FDGezQZZdV3x9t1bbNOkbTqCUUReFC+fYwamKVCq5ni6UFYtGII8iRmPRuj+DxvsP83zZz/whAG1qpG2TRbH/N2vf8NkumQ8W1DlCZ7vUhYNhhBMxmPOGNiWhUZSpCnTxYrd9jOuv0QaEj8MOB2OVFXNdDJhsz1i+wF93xFNRzx/eSIcLWjblu+++5EwsAg8i67rhwV4UTCajOlVNxRIR2tszyPLcp4/f8ILAyzDYfO4YzJdYsge2ebkac/z46+JRmNc06LtFM/PG+qmJhxHuF7AOPDJLzGZgG9/9hOaqkSagvSScX17w9/93e+YTkZEYYDn9nRtg+U4FGWBdl1uXn1Fejlxe3fLOc4wpEHbtkghcb2I9WrN5RLTFQWz5YqmLHBsizQrsR0Hy7E4nmJU26NUi+s7VKZEC8Uo8JDCpGlyTEMwiiKqtqGoc776+hXjMOBvfvM9eZXTjsaotiDqGzb/6nus447nf/3fMsIl1yU5BoH0aLUi1RmecBnLiEN/4UKCpU0sbb3kEiWWtuh7hSEMbGmBhkYopHy54tN6iNir+qUf8PeOd3/4MUN3oNfDie7f7uOGyoBlSrQeTmSmFH/8VwVgymHwKf2HITuwW3utMV/2ZLwM4P7lhPj3T3waUOrf1hckBpkosYVBoDxyVdEaHb1lIDpB0Ls0uiVROYaQBKZLS4vqeswXXZDJEBDqX652W9nRyA7XsJBCUPeKumuxhCTvGvKmozRz9HjGzc/+c0RVM3vzDs9zKOMYIRpC28OQBkXecH19g24anrd7suSM79kI3VPmFY7jYFkWohc4jsdqPma3O2BYDo5lU2UVi6s1VZqxWK2oWoWQBrPFbPCtWTbT0Ygqr5mMI1TXYvsRH99/4PbuDlGWHHZHRqMR4cQdAAS+x/Nmz3G/Y7Fa49se0vBoypq6yPDmS0673VBJEh3S8WmV5rvf/h7TkNR5hjGfk15SqrqjbWpU03F1d0fTtLRtQ6cFWVH+0cMXxyllXmCaLgJYXK9JjglXiyl5nuAFNu4o4Lg7MJmvUUJj2TazxZI8zdBCYpmC7HTm65/8hI+fHjiYki++i2oqDCcgr3NWqyXPTxs0Es9z8GcOvTaZTcaMxhFVUyMsl+9+9yOTyQjVQuQFpEnO5vMTN6/uUF077EQRhFHAdrtnMZ3SdIpaKXohaLuhnrLfnxlFI1zHAKWwXYvLJafrFL/65c+4uV7x/Xc/4LsuRZIyny9Izgdc1yJrGizt0ZYtUlp0bUMwnbPbHfj2qzf8+PERYZjMFtc8P23xR5M/6Tz4sx94x92R+XqN6MGQNuvliNdvbrm/f8awbGbzOac+gb7hy8M9aVmzmM9oGhPLM7Ecyeu37yiqmsslYRIFlGlGGAYcnp95+9Ubnrc75ssZ8TlhPJoQjQKyOIYX4sD1q1fkSYGlenqGBXjftXz/3XfEv8l5dXuH79p89dOf8fT5M0qAYXuczunAxaszZK9YrucDcNb1yauGXhiMJjNC32U8HvNUtRR5hUaxqRu+evc13/3+N1RlRV23zBZT8ixl89hguy4aTeDZCNumzFJM0+abn3/Djz9+ZLVes9seCUZj8izFdD2etwfms4hwErLfnZjN1mw2+wHr9MIEDIOAy+mI7Tq4jo+BSXI68ur1W+4/3SMsmypPWM6m/MXPv+Gf/6u/5oigqxvK05GpbaN/+EL++JGyLXB6OchG6alpiKRP3KeoXuEKh1yXpOSDVQITIcRQukZQ6YZOd2gxnOo0Q7/Mlx7Ri0S1oaGXHbawMZXBS0J/6KL9vRAL4t/u9eAPOzb+eBqUL3s6y5D84cLyj/PyZVAJMZh/DDmcmrQefr6Ufy/V8vJIKRFiSGtKQ/yxPK4RQyWhTyisCl86hN1ANal1g21adL3CVoMrrxI1aVOCAFsaaHM4YXa6e9kjDt+Ga81hKBddQ9IOScum1+hoxupXP+Orr75BSRuQJJ8+UVUNQms8zycvEizTpG5K2qbj6NiUaUxTV6xWs5c/EwPL8gfospCkWYqhh2ta0/UR5zNdp3h+eqJtNX40Ia9abBOeNgc8zyVNz3iuRzRysSyT73/4SJHF3Lx9RxR41HlJT894OiYMhxfRpq64Wq3Z7Q9oLXAsExD0PQgUlhjwb8Fkim0HTMYGne6HHmY0om8bfH9EW7cYJiyCMWlh4gUhhilwpUNZVmilMAyTy+mCKU1cz0VK6HSLbTvUeUPfQ90o4vOFyWxC4DlcDPjq7Q1SaP5qt+fL4x7P91GqxvdtwtCnaRvarmK6uua43VBWg/txuV4zHQccd1scz8eQgigKOB4vmMLl/sM9fhgMJ2TPG16YTMnV7Q2f7z/zi7/8FT/+8AnHc7EMyXw+4fFpw2g6wbFtDAV+GND1Hcnpwu3dHXHymSB0kGgs13sJI5lYtk3dKJ6ez1xd37I7HJjOR0ih2Wx3/PKXvyBLj8TnGFB8+7Ov+PGHTzRljheG7I8XTMug7xRlWTFfLDhdzn/SefBnXzyPRhMuhxMw2JEdz2P7tCM+HkjOMVIYSKH5/7D3Jz2SbGl6JvicI7OIis5qs5kPd4q4GRlBJllZVWQBnYVqAl1oNhvo/0EgfwJ3BLjgiiv+Au64LXTXoqqQZJGMzIyMiIwbd/DR3CY1nVXm4ZzTC1Hze4uLBgjc3gRKDQaDq6uKqbuaySff973v89atJgyH3RWL46C1wA9j9tsN+80OXVdIz2ab7Dm5OMX1fOyoRysdwigm7sfkRc52sybuRcSDmN1mwezomIfbOxpVkmYJYRjxcPuAUh2F3PV9qqZks9+xSzPOn71AY0jThF4vAF0T+Q6z6ZA4DNBY3N+8py4TeoGNFFC1iuu7O9q2Je4HDPsxQRCw3a548fIl/UGM5drsN0viXkx/NKE/GpFmOf5gSOB69Pt9qqrsQNOWzWa5Iu7HSNPy7OqcIk/pD/pcv73GEza7xZK7D9f0ez5NkdEb9anKnHS3xvVcmrKiyHLyLMUNQ25ub7FdB8uSDIYDsGz+9pvXxPEQkWYkX39D/Or39H77a9zrtzhFjq0MCI02hlhGKBS1aRnKPkpotiahNapDZFkOwupGc1XbghLEJuRIjpjKAbHVw7NdjA2pyFmpLbVucI2Lp31q1eKIHwj4O2kkHDpAzGEMabqOzRgQsnugLQRPjZo8sDWlFF1yghTYtgU8dWyH0ebhU5tOnWlbEtfuYlyfRCzadOPMpw/bOnA7EfSJKNqavSnI7A4T5iqXsq3RQlPZDRWKngmJTUBoPJTSFHVF2TTkqqI2LbVW1Fqxb0u2dc5jvuc+T1grA+cv8X/+X/OT/9s/4eznf5fKWFRVxXTUYzYdE8chm9WCpkgZxgOWj48cH5/QG8ak2xWj0ZCoF/PwuMHyI6Jhn+nJDG0MXhDy7PkL1tstX33zHav5Pc9evCCIQsJ+H2wLZQx13bLdVhilyfZbjiZj4l7I/cOSxgjiwYD+aAqqA08bqUFYbNYb1qsNTS24vHzO3d0D2/WKk/NzVpsVN9fXJLst6+2eSnfvbbJd07QFru8xGA6oqgLLstBCEvQCmrYhrRqwbIxSRL7LdrVnu0lo2pYgiEAZwsDD9QRNVTCdzvCkpM5y6roiLwvuHh4pWs3t7T2qKvn86py/+e3vSHcJ/bhHsl+hjCbPC7KqxolipG3j2B5aQb5P+PTlJ0yGA8qy4sP1PUJYxP0ej/M5RVFycn6EMg2TowlaG1aLZZdgkKZslltuPtxjDlMHjCBNMtbbDetNAkiKIufh7hZ0g2/b6KrEtiVJmmI5DoEtmA4HZHmO6wZIBXEUsnhcU9ct17e3DPo9Pn35gqox4AYstzvCyGM2G6M1JJsUF8XxdIhuah7u7vB8Hz/w6cU9Nss58kcmPf/BFzzb9ZiMB5wdDxkMeqRpwmJ+z8X5CcezMaZtKOoCy7WpmoI4Dgh7EV7oURQVvh+y3q7YpylJktIoxc37dxg0rg03799xcjwl3eeErsdPv/iMoqhoy5KLi0vyNEWohuX9PYM4RLU1ZZ4wf5iT7VOasqZsVXfl6bodFNi1EALKqmAwmiGsAG08Hh6W+J7H6ekxTaMZjCfEUYiUAsdyKIuyC2ENfTaLOW+++z3rzZKTyzOE5XB0co7vedRVxmr5yPnFCYvHJS2SrGpRRlJkBW1ZIS2X87Mp0nL42998ReAHWEIxPTvhN7/7Hc8//4x+z6dI94RBgKobTk+PaOoGW9qcHp8wOxrjhx6+Df1ewMnpMav5A01Vsf7wgebmDvUX/47oP/2a8Dff4mUldVNjH/ZZFhY2NkYoGt3SkxEIQ6ozXBw8HDzpdMBjrfGMx1D0CSyfVrakImenu+giTzv0TK8rcJaLkLDSO5RRWMZCaon7MUYHngrTR7S6EOR1S626RIGncWb3mA72rA3UrT4IVLqC9iRYEUJ8/GUTh+M9GQ06J4Lh0DR2ak6rU3g+dZvI7vsppalFx8cc6AilFI2uMZ7Gkw49E3R0C91iuVDbh0w2HCITEpkAXzs4qtv3CQ21asmamsemIuv18b/8+3hf/F2e/el/x8XnP0M4Hov7OUJ1O73Ffo/TC5jMhgxnMxos8qpFYDOZjlgt5mRpQhwPGA77tFVJGPhsVyvyfI8xGs+2ef3qDV4U88lnnyFsl4fHOWmaEPVHDIadEVxYhqgfIoQhDEOkkMwmE9Jkz8P9Da6lkLrBtgT7JKFRiiLbEwQ+x0djyjKjKAv8wGU0HlEUKdv1iuOzUwajGePpDMd1ycu6SxIYTVht9ti2S75PurRzaWFbkuPpkDLZUdUNUli0Vc1uvaIsMhw0qJamKQjDoAOOhwHb9Zo0SfCjkPV2g+1axHFIHMfYrkfRaL59c0s8GDNfbTGCLih5HONI2K42OLb42H2dHs+YnV3i+THz+3uqIiMtCsqmYblcEPRCtpt1t3tva7zAxXMhcG3CyOtigVSX1m5axe3NgjRNGA5iwjDG8TuwQlM2nJ1fkBYVUnY5m5a0qNuWs7MThJS8e3vNbrXGEoow9PEtyeefnKNVhh+4PD4u+Oq3X+FYDsdHZ6zWnRDu8f6e2WzCerlkt91zfXPHbrPl2fPnZPs92+2esmposZ6uKn+02x98wRsMegS9CAGMZzOqsmY0GTEahpyeHPP69TVVVdCPfeJeSBj1qJoGKS1U1QW+TmcnDAZjhmHIfrEgjAeEoUc86BNEEfeP94Shh21ZzJc78rrA2LJbwO8TGi2IR0O0Adfz+PLLn+CHAVg2JyczxoMYP3SRtsC2IcsKpIGyLHFDB8+1yNKU88tLbMthn9WstnvSvDO+q0bhBz6uo9nsElqliXohx2cvkLaP73tEns3q8R4pDZYNUT/i4f4e02qaNGU1f6Afh6xXC9wwotGKt29uyMuGeDhjs92Q5hnDfh/Ps0mSHePpDD8ImUy7H17puCBtVpsN89WaDx9u8OPeweRv2N09EG9WxN98Rf/rv6H69X+A/YKs2GEMxDKkVYrWaALLpTUGcfCHtTQUusDDxREuii6NAAOhCfCES0NLYjJq0+Af8Fm2FLR2w84kNLqmR4BsBT3b+1iYGtN0ez/djbr+84Jk6EaPTzs0Q1fIHEtiH+T7lnz6fOrc+NjpQVfE7IPP7um4T8VVG4E62BS0PvgBf2hf+Dhi7b4qYRA2aMsQmwipJfs2J7fLDtlED087VG1DbVqUbSjtmtqqMRg8PHwT0DaCxzLnQ10x+JM/5eX/9f/J+E/+Iac//RmT0zOUbgGF4zoMRyMGw5j5/IG6rFFKc/PhhnS3IQp8hGkoipymUpyfnnN8fIyuUrSGKOqRJyl1kaPrhu36EaVqjGpQRc7N22t8z6epulSEIk2omprjszMksF4+Yrkuw/EJWWl4XGTYUvLs6qqDbCuN6/mgNYN+j9H0qPvd8Vx8z2XxcMfd9VuEZXF0csLx+XNsxyFP1lTZnqoscF2LRik2uwTLsvjm998wnc1INmvCKGR6PKM1XSJ7kebYnkMjBViGOA5xPRvPtaiKGst2CYIOrGAJycXFOScnMyaTMZ4tQNWdgrqseHx4pG0qfNcjK1uk7dGLe2w3W8K4h8RQ550FIc8ydrsdliPYlwmr5ZrpZIJrGabjEdJIJBbbbcJisabIW1StycoKfJdkt+OnX/4EJwyoDbStxnEkURx3Nok4wHYsqirvUH91jdEtVVOTZgVR3CMKI3abLWEY8OlnzwnCAKU0m33OzXzZTUpsm9D1OTs94erFcwbjmHS/JYh6DMdjPvvic2azMYNhj7/3p38fC8nlxQVZknTTDtfGdQUvXj6nbX/cxPM/+IK3mN/TaIFxAjbbXTfWqWqW2x1JnqN1A0YgpcXs5Jij02PuPtziOQHToynStinLGt02FFnGYHxEkuWUZY1le/T6fU7OTikbRau6gM3ddkOW5kwnU4IgIPBDPMenynOyMuft+xuqomF+e0NRlGw3G5QRZPuMNMvo9brsvDj0SVZz+v2QcNQnyQuMqqnzgvFgTD/u8+bb35Nke6oi5cuf/YzA87Bth7OzEzAVdZ3x1a9/xXDY4/zqGUYI2tbQ1Jqj2RTVlHhRyOXzF2R5QV2WNFVBz7ep0i2e75KmWyI/4HQ6Zb1eI+0IVRvyosGyLapsj3Q8Prx9y3Q8xnNteoGDEFA8rnDXC+p//xcE/+4/cfqwxKxWhMImdlwKalJTkqkCiSQQHrVusKWFJWR3wkYTihBf+ux0SkWFMgrHONjCppUNlalxtM3I6iOkobTKbmSpPRxjY1uSRBfde41F1pZEwkehyE2JEBL5lMNz2Md97PZMN9Z0LPlRnQlQNuqjMfxph1c3XQf4tNd74lE+2QzED1SPBtCHKCAOnjchBNLqhC9w6A5lZ3lQB7RYq1p2KkdZmlq29EyIrSSVqjGuIrNKfDxiHWI0lG1FrRu0hESUvGuWfCt2rC6mRH/633L53/33/Nk/+X8QDiZoLcAoAr+LivFDjzzLKfKS+XzJYDTFsV0sBEeTMcZo6rbh4tkVCLifz7Gdzuf34W7Ow2JJNB4hLUE07NNoCKKOjh/2IibHR3zx05cIS6KBftiNvGzbYrdbE/f7new9jtknW6QjcF3wPZ8oitjvSxSS2/sHwriPIxyEUfQHPXa7NUXd8OKTF1w8fwnYVEVFHHtgFEWR0B8PcBxB2zQ0RdGN4vf7j2pSJKS7lOsPcxaPS86fXQGC5WJFk+dcXV6wT/fUrSaOR92u1JZoA7YbYITg+vYDb97dkOz3FE1LUTfs9wm90Yjp0RHH5xd4rqAqMk5mU+q8om4VUkA8GCIsj6qqybICoxSe65CuN/QHA/ZJRlU1OHYISjDs93Bti+F4SlHl3N7fUZYlRhnSpCBNMhwpUdqw3qVUdcPV82d4QYAyUNQF0rGIh322uz04LgjB6eU5yW6PUYpkv2WzT9gkKWeXp/TGQ8Io4OTkjNUmI626He1mm7Beb/n6q68xwtBWJbe3t7x5957Xb95yfHREW2QEnt0VdqVRbff/XVYt290Ox3F/1HrwBy9a6ccxTV2R5RlB4HNycsxms2G/T9nvcuJex3qb3wkGwzFXV6eczGZsFzeEgyF5sgckRVZ3ajkcotAjjvssVht6/ZA8L8mSAqEbnl2+4P2b1/SGA7793ddcPb/oksT9gPlyxfTkFB1KLGkzm43I9rvOuFw1WJbFdvHIbDambRvKosDzXK7v5liuj28J+r2IoqwxGjbrDWeXz0j3W7786U+4vbnneDLh26+/pjWGoB+CNhyfXfLdq7dMjk/Ik5TTo2Oka1NVJa0x1E2DMDAcDNFxyPFswjdff00c93EknJyfMb+55vbA5FMGmqohLxKqIsMG4sGAnJbdZovYp9jbjODta/ympMq35KpG49KXPULpU5qKwPY7Wnudk5kcoQSh9KlMx1UMbZddkyNETasVPRHREz0yMixLkqui61bwaGWHy9JGExORmILaahAtBATkphsDtqalNQ0S62C0rvGFg6JGaXWQ7nd5ct2eTnzculWtPuzzuj5QmK7Q6cMjLCFQytBa3V6uVh0zVMhDcTPmo/gEOji0PuwJ5eH5H0HRdF2hEIfRqRBYdPU4MiG2bsnaksByyI0i0gG1aSjbhsjxyEWBp136ukdpahb1nr1WEIa4n3zGyfPP6U2m7LY7jG753//6N1i2TRz5VGWD5wUMx53sPNtf0yiLyWhIKyHZZbRVhS0FQtgUecWb1+/oD0cMRiP2+zVhEDIJ+ly/ecfR8YQPb95wenFJ22hKx6XIOll6qxR1q9iudrgHbuR4MqVp646v2G878oYjEdhdAr0bYvkeZasRQtMPfYqiQhhBVuS8f/0to+MjZtMRk1lMWyuEEBxNIh6WS1TbYFuSk/Nz/DAEBLo1hHEPVAsCPv30C1brNaoF2zJYWjGajrg/UEvieEC+Tzg/P+P6boGUmjQvCA5Q+TRJcVoDqmYQd/tty7apleb0/JLVwwPCcXi4f2A4HOEHHoNej1//5V+BhJE7JU8zhBQcn51RlwXHJzOyvCAIfC4vLrh+/5a6LbF9l81+gaLB8/ucP7vED3w838EAj/d39KIQx5JoBGWWcPXiOVlW8Lhc8jif49g2RZIjLFB1S6/XI/SDzloiLFbzJaPRkKZs+Pkf/xFf/e53NE2ftjU8Pj5guy62lAz6Q5qmYLVeYbDw/IDJyRmea3H7+hXPXrzsooSikF//zW+6nMzjIxqtkY5DulwwmhyRJekBbfcDJdePcPuD7/BOzi+wHY/tdk+rW07PZpyfTfj8s08ZjqbY0uKzL3+GERYPd7cUWUYYBrhBj7JsGIwnSMtg2RZnFxeczEZcXp52KQLakG1T6qIl2a6ZHU/57rtXzE7P2Owzev2O1BL1RyilmZ2ekacZ28dHsnRPU1fMjmYYrcmylKIsOT2/IE1yHh/mCNtjl+R4nke2W4OQLB6X2L5DEFk40hD0+2jX49W7a6qq4vb+luefPme3WuJIl9n0mMFwwvnlFWiBH8TMl0swkv1mz9XlFfv1hjxND1QZze9//4o0SdFSUjcdvWR6dEpT1ixvP2BpRbJb83B/T6sV/cGQQNWImw9k//F/g1/9J6q//iuCbQ6FIrA8YiugFYqN3tOomkB70Apc6TF2ewghSU1OZWoiEdC2gBB4lt0xKdFkJqPQOa6xaVqNLzyENCQ6Ay1wjAVSsTcpPUI84VKJltZ0qQQWFrWpu5BJ4VObGkc4KKNpje6UdcL9oTYT+MEeD+AgSnkikGhjUAeByxP/Er73ulmiG31aUvxgH8jBm9ehx57mpIZu7NkJXsRHW4N12P+Jpy7SbrCFTaxDyrZFW1BZLZ5x8bTLrs7RwlDIipt2y2uTsuv3Gfw3f8az//5/5OXf/VPOXjynqktOz8+I4j6249MUeWdbCTyKZM/89o6761uOZ0ccTQbsd2vQHdDXdhzW2y1ZmdEbDjEIZrPuJB1FA/K8oK66icRsMCAKQob9mOXjI54tcSzBaDylLCo8x2N2MmN8POXZi0/px31GvZB+FHbIKt9Da4VWLWmWs09yNqsly/WWrKyYHh+jgX2SkiUJVy8/Z9gfYrSmqUqqPCP0fTbbhDxNGU4mWJbbxfu8eYcWDp7jMhlNODo5xfU9bu/vyHZbPvv8C1zPww97SAnJfsdgECOEwfZ83r79QBi4XDw7JckS8jzj3c0tTdswHcZ4roNlC/bbPY7lMB0NUU2DG0YEYUAQuh2Mepdw8eyC84tTXj5/hgaSLKVuWtbrzie83+2RorPAFFlOfzBhNBzhuj5GSAwW7z/Mub27Z7Va8fjwgKoaHCnZbXdkWUVjBMbyuL6+ZbveMRyN0AIaY7Adw2QUM+jH0Go2D0viMMbBMJ7MmC82lG2LJSWnZ+dcnh+jqorJ9JThaEqe5dRNxWKxJO6P6PVidNuSJQmL+ztefvYZ46MZwukAH0HU46d/9FO0ZVGrDvjhR32UalB1y2cvP6FM0x+1HvzBF7wqz4g8l7osebyb8+67t4xHI+7v7nm8v2UwHvJwfw/Swo56/P6bb7i6OmFx90CVF9zf3nJ++Zymarj/cI2Qkt12T7/fY7tZAAbXDzm/ukJj4dke71+95WQ2xfZdLMdl87hks5iT5wlCaCbjEY5tcT9f8N3rd9heD9dyiQIfpRtOLp/hRX0mkwkXZ8d8+uKSq/MzkvWa2dGs2y/iICyL1cMdg35Mst1ieQ5ZknJzfc/J+RlHswmbzZb7+wWLhwVS1axuPzAeDVBNQRj55GWG5UiMMCijsYUm6kWE0YAqLVguVqi2xQtDjk6PiXo9sqLEsmxGrkN4u8T5m9+x+Z/+Z+Tvv2FYVEijSE3BXqdorQmUhy88+k6IEIKtSUh0htBWdwUtHXpOt1PLdNGpMkUXvtmzfaSwMAYC4SOlpKCioqZUNa5xCS2P1moQRuIaFy00pS4RSqK0RtFi09kbKmpcYdOIFhubhhYMVKb5uD97qncfy9chQ84cGJdPezxzsCXYh/y6p67MsuTHPDv43nrwtBuEA7vzMMY0B0KLOOwNuwL/PX5MPylEZXeyq3VNZVU40mZARKtaGlGjnLbbaTXwNtmy6IU0Lz9l9g/+B4Z/9F8jgwF5o2i1JAh7BH5EkiT4gctkMuDs4pzhuM/pxTmuFzA7OSMvSt6+fY9lC1wvwPMjbNtFWJJWKWazY3xbMB4NkJZEtYp0k6AOAamabsSvgO1uz+hohjZghMAgGI4mBL5Pst0xv/7Aarlgt9/jBj3S3ZZsv6MqSxw3oG1bMIaiqIkHQ3xbIIViudmimhY/dOj1Q+oyZzqb8bhL2eYZSZZQ1hXj8QDTKLJ9xnQ2Iwgijo5OOD46pqwVb9+8I0tzHMtmFPfw/YBvv/odeVbQasP9fE2RF13MmC3wg24/PugNWD3MUWWGJQz73Q4jJI+LJaNJVwgmxzM+eXnJIAqIo/CQqacRwkcYxcXFEXf3D7x69R3rtNuhxcMxYX+IH8ZdogmSFocwGiBsC2k77HYpEslPXr7k9OyU05NjhnGPuuxS7pVusWyPZLtDSMF0GOM6DuPhAD8MiKJet0s1ioeHB+bLFca22O721Kpmvpiz2e2wXYnrWRih+Q+//CXbomC52dNow36/5/H+AWUkm33KYDYjryt22xW2bVHnKZ4fU7eGx8UWabmkaYnRhrysWa/2FFmBsCyyLGOfZGhpyIr0Rzee/8EXvO9evcKyLZ6/uEIYRV43vP7uDefnlwT9AdfXNwjZ+W6U1vSnR/zNb78lnkzAlpydnyPRvPzsE8bTCcvFHCUkNw8PCMci2W9xPYmwBU3T4PkuP//FH5EmCdPhEIni+GhErx8xmY3Y7/dUdYuuKkLXZTqe4PqS4ajHbrMlDiPub2464sP795QtrBZrfN8jjAM2mw3DwZAi29DUFUZ0eCxpubx78440LxgfHSFdnw8Pc67fvyOMAsbjPsNRj8FkTFnVLB4fSfYJlpCMj6bs8oz7+3v2ZYXXjzh7foXtB3h+iMYiTfZIW6CyAv3+LeLXv8T85b9Df/Mb0tev8StBoD0c05FOPNuhlV1Hl+oCxzhIJYntgMD2SE1BohMsY2EpByMkoeOihSJRGcooPBOQNTWR7aOEpjAljrEYiJieCHAcSWFKhJbYxqKgRGmDbRxKUyPMx9LUobEwSCNoUEglUCiMNrS0SCQlFYr/4y/YUycG3xek7n4+2hUwnS/vafryw1Hk02j0cICP3dwTX1McjttRV7oHSrpYoFrpj+Dpp9eino6pDa1dg4SB6ZHVDR+KPa9MQv3Zp1z8X/4xo1/8A0Y/+QXx7Awv7NHvBYSex8P9A9vtDs8WCGVYLda8e33NbpNgDKxWS+q6QitFW1c4fsjd4xrHk8yGEclmi1Eazw2YTI+4fvOWzXLJ4nGJ69v0ej7JfkOa7Pnsyy+xXJ/JZEpbKfLthv6gjxME1HVJWxTc317j+DbHJ1OOj48RluTm4ZG6FUynx0RhRNs2hHHExYuXGCmIen2GccSnn3yKbbqdqWfb1Bq8Xp/VYkm+WYOGsm7wopCH+zmD8YReFNALfYo8Y/6w5Pb9NbrOoSnwPZe4H9HrBUhHYvsOSjeUZQlC89Nf/IK2VujGsN9sMUZjex69XsxoOqHRBsuyOTo5QWNzd7+kbTSqUWx3Kb/79g3X93O2+w2uJVFNSZqVGASeIxmNYnzXxXEsrl5coVRDXRakux0nxzPaJmO52WCETeDblHmGbTv8zd/8hvnjkqpRuEHEaNpZjyzLJeyPCIYjev0ejw8PBJ7Der1jtZizmt8yGfW4ODni7OSUttFUacHp2Qmj2THT6ZTj8xO2uz26UWRJjhQWvShkvV5Sty22LZmOh1jCoOuKKAjQBqZHJ8znD0xmJxwdzajKkn2Sst9ssC2ryx7Mi478tN9RVDVSwng8oD8Zst3v8eP4R60Hf/A7PKTDcjHn6OSIzz7/BGUE9w9L8lZhuxZf/PRTlosNl7Mpb9+8pylremFIfzAiyxL2ec7mZsUgGhAPxuz3KXVeMugNybOM4XTGuzfXjIcxTVMjLYt3H+6Rjk1Z5gS9PnVREPf73L+/4ehohuP5eN6A7WZHVeRkaUUv6mFJwcPdHMd1kRIcx2e5WHI8G7N4XCBslyRJSd+85/hozPLxEccJiE98HAGbzY62NQgh6Y+mpMmG4WjAfrfh4uKE+WKNwPBwd0cc9/npT3/Kbrchy3KmkyN025Du9xS+T6q6FIJkn2FXNbNW0X71e+yHG2LVUOqaRrUkRlGLBttYhCbAlS49bCrToZeUpUmaglYrIhHgaZtGWAhHkrU5td7QNz1843Yp245P1pSkOqMve/QIaExF3wnYVjlapgQmIBIhhSpRsqUyJaEOUMJ8VGgWlECXVG5+UDUaFMJ0eXDSCBwsClPhCbeLunnCfn18RqepfFJW6kOBs6X8GND6JHQxB+UbhgMOrLtPt+ogduFwrO8JKgZASox+Sif4QQHt2juElB9fizm8koiIXZOS65x905LbFi/+/j8g9kJaIXH6QwaDPrvt9iCtl6RpyunpFMt12Cc7Hm7ec3H5grPzU3brbkSd5jknRzMmkxnLzYa2rfE8j7wquV/sMHaAsQR+GKKNIstyfv4nv6CsKhbzOUZErJKCYDhmcfeBwXhE09bMJlOqesNkMsJ3HLIsZTYZ0Y8647J0BJZl8+b1KzzXpxdHZK3CdWyiyMWolt1ux3Tmkm431EXOaDxGmYLxoIewJXlVIjUEvku63+C6HdTcsW3yJGO92xH3BpxenPPm+g4tYL164JPPvyAOXHpxyPJxSVkXFHlOWdScXz1ntZxTVhVpkmEHIcoSnFycs3xYsFpt6bVgVMvZ+RFF1fDZZ58xGQwwCvb7hLKoKKsc2++UnFo1RL5H3HMwysX1+/zmV7/F8xyOzi6wLI+qatmtd9RVRRyEGNsi7IXYW0kUutR5Qm264mBJl8l0hnAssiwh8Dy2qx1IB0vaeF5AHHhU+R7PC4jCiLIq6Q/PWD3cMZ0csd+nSMdFiBqMZLOYIy3J/GGLF4TUbYWQgrrMOTs7J08SXrx4we3tA02VIwKPQT/EsWxu310T9fukaU4Q9kjzPZvtHseS9HoBwo0oyorXrx84Oz2maVqePX/J9d0DxgiKPCOM+yyXK/rD/7Pg/RfdJpMJ0rFwPY9vv33Ns5fPWT/OsW2bfhyz3aa0qmH58MDR8YzNcoHle6yWC7bbNTg2qqxZVyuM7FhwYajI0oyj2Qmu5xKPBsyXa05nI/IsJa8T6tZwfnnRXfV6HuvVCmk71G2LtCs2yx1GONihj60cnCBm6vkgIM0yBqMxZZYzGfR5XC75yU8+4zd//StOry7ZLVc0SjOZHvPu1Wu0kDiuzWQ4oNWK5WqJ5wdsV+uD50kxv5tjMJRFwdnZGbvNhmS3Bxy0lqgmw7Qtti3YzecUScZPry7QN99Qzh9ZaomPRyBdtJCdDcBuqUxNoRoSXVDREGiPUASd2tK0tJT4tkOlKmpdE4uIQHhd/pojSFXFSu2JjE9PhhSyou8GbOuUvU6JZQ9LObSyJXBcyrbCUHRWAtEh1jzpkosSRzs4stvT9WVEY1p6IiA1Bb5wUUbTkz6N1hg0AkmN6pSeoiXUHqWouq7xB92c+cEST9IVPecQ0GpL2QlNDgIXxKETNAdLwkGoIsWBW2lMp8CUgrJWPyiYh29wKHpadeDmQ/3j+37QkOuKh/KRxvdRYUT/+U84Pb/A9ztFZbZe4boR/YuYKs+olSbPtjRVTVOPCT2fZL9FaEVRlWzeLpgeT/nTf/inbDd7truUsmmYTCcM4oDADahVzW6XgdaMx0OmkzECeJg/8rBp2Dw8cvHsBVmWotuai+NnJOsNUkqasmUxX1DkKXIw4P5xjmoV923DaDQA26bf7/Nwd49tScbTCbbrYjkObaNZzpdcXl2ilCZPM45mM7QAjCLbJ0hp0ZadMOxhfk+S5bRVydFsyv3dPaPBkBefPmc+f6TRhjev3zE5OmIw7KPKgqaueL+Yc355QVlvu5XH/T3T2RGnszGqKvDCHu/f32AbSNOM9XrLZrsjjGLKNMWWMIpj3n33GtUqFo8LgijixSef8PrVd4SBS11qHK9HkScMJjNCP0Tj0O/HtO0lQmgWiyVHJ6dMpyMeVysc4bBabggDnzov0E1DmRfYtksUBORpQi0KNtstVVnQi2O0JymLkumsjxuGCCnYLNc0WcZWZ5xdevi9GIwgHgwZDYesXr8jiHsUWYL2PcKexzCOUcqAaWmrCmUsHD+mMVBXNf1ewNyWjCbn7Hc7kII8KwjCAGFZbFYrxqM+vudwdHTCh5tbtusVg+EYV0o+//wzdllOo2u++f3vsVwXsChLgx9K/DAkS/Y/aj34gx9pbpZLFvdzVss9QjjcXd+D5SCNIIpiqqqmLGqyouTr3/wWy3KoqhbHdvBth0BaXFxeEk+GJPs1w9GY3XqDakv2+z37ZIeqa0InwHEi/uhnf8yz588Zj0dk6Z7Q92gbhR9G9OKYy8tTmqZlvtjghgFxv0dRFOx2a/q9ANqGMO6RZTnSC9FoXMfi/YcHeqMRQRBwcnJEVeYIR/Dis5cMx0OM0lhIaBWe49AUJfpQwL786edIy8LyAqLRkKJtyOqKm/s7tNHUVcGXX3zK0Hd57vnYv/0NR6++Yvc//0/4yxWW0WSmYGG2rPWeXFUYBYHycYxLbAWM3RghJRkle5OSqE5cEpkAoyQ9p4tq2ZuMnc6QxsJR3f4tsF0KSjJdEJkArSB2QrTQJDrFMhJb2dhY9Ozu/0QgUEYhEOSqRCpBLSqU1l1xo+36MmEIpYcWGnPgVwo0tjgQUehqjI2NkB1j8qn6CPNDkma3p2s/JhqIj9gwDU8zTrQ2HRzZfG9O14euUR5ELkXbxRCFgUvg2gel5hM8upOMV436GA/09O2eCGR7IdDPXvLyf/x/8cmf/d9xBiNc1yEvSoTt8kc//xm+L/nqq7/Fdmw8W2IZw3gwYNjvkaR7+uMpzz75HFfC0ek5da1ZLDe8fvOOII7YbTpSSdso0qJksVii25rAcynLiizZcnv3wG67ItvvKfKczWZF03SioIf7m071WyuiXo+gPyBvNAaJbhuqvEtC2K4TqqLi8XFJqw294YCqriiLlDLbUVcFvfEUhSQIY6Tj4ocenu/huC6jyRRXSoyR9Id9xsM+k+mA6SjG9T2OTk9Isoy//NXf0huMOTmeIoEiz1ivNkjL7VIUspQqz/F9l/V2y2A0wqiWV9+9wXEDfC9AYAhDD9exqNOE5e17/MDj+OSIKAj429/8LVopNss1abJDNQWGFlXXCKPZLu9xbEGWZFRVyzffviFLEm7ev6HIU1otsCwXx7Z59eo7bMfm+HjKcBBxejrl8XFBPBhRFR2P1LIsqrrBdmw+/fQZL14+Jwo81o9zmqomz0vKvKItKzAwmk4YDmPKPGc5f2R+f4fjutzPH3mcP1CWOfGwz9npCW1VU9aazTZBWB4WFp88O8UyFWW+pzcc8vtv3hAEPrvNkjzL0S1oYeGHIaqsGI0mWNJGt7Bc7miUoT8cs1wuCeMYgcFxbWbHM8LQ48WLK3qhzYsXF9RVRV3VXRbpj3j7g+/wwjAgDEIso7Etm15/ADhsNiscR+K7Pk2jSPcbpkczRqMRdd2wWC2xbIvz02Pu7h4wlostLFzX5o9/8TPevLllv9swsge4QpCVKe+vc/Js2/0Suh6e75DsE1RjmE6G3NzcsdvtuHrxkvUqQWtFWVRcPL/i7vaOcBCTlTWqblBNTdM0jCcdaFoLiR/0sIzg7nFJ1YKVZJRlSdiLMarG7cXkZU6apFiWRRDFuI7km29fo7RElxlBL+w8Ub0+RZbxzW9+Tb+pWV1f03zzllLDmQKFS0tLjSayXLBcCl1j0Ox0ys4YQuPTEyECBy10F7xJQ6FqclXSqIZQBAxFRK3qblRoS7K2RCtFLHu4ysESEimhNjVpC6EMaEzDwI0o25qdShmIHigbbE0jJY1qCPDxZEgjW1rTYmsHBDSmRQpJoSukkAeVo0CLrqszRiCFpNXqwLfsonMk4rDre6pn4ofKFQAarVHaYB3SzLXpipgt5ceE8CdAmdEayxJoJWiNIataAtfmZBSBNnS2bpDa4Ngdp/NjN/nkBxTdELR73V0BPfr8S9TsBUJY9OKAvMhotaFpGtomZz4HIbvCvVxtOZ5NCaMQy/E4v7qibGpc32G/XTEYDNjuso760zREfsT8foXnB91JU8PJ2YQ8y6jKks1mS54mlOUYx5KcnZ4zv7thOp5wdX7Om+t32J7b+f/KlKpIsbwAIQ39OKIqFVL6fPnzzyjzjF2S0eYJYRAhhUSZjjU6HMZkrsv1uw/EozGD8YDlojOs90If33EptCbPc3w/Qto2dVEgLI+6agniGFdKdnVJ2I84ms5YbbakSY7r2PiOS56ljIZDFo9zorjP82eX/P7rVwjLodEG6Tms1mtKrRg0Db7nMh4OqIucXjygzHZdca4bBr0+231KFA8JewLLtri//UBaaKSw8D2f4XTK0fkRadEJxaRlcXZ+SpomJMke13VwRj1OjiZ8ePM1tmMzX847S8ouoT8YEEY90iTl/uYazw+oq4o03XF/0zI7OgHLwo18LMfpOsnRmDzPAcV6vaLXi5geTdikO2anM1a397z45BP6cch4MiFP9txcfyDqxVRFymjYBwHb3Rr30eZ4MmQ0mfDhYYFqWoRwibweo6HP3c2HDgAeuEihEKYm2edcPXvOh3fvmMwmZEXJydkJSres1hlaSqqy5PjsnDxLGEwn1Lqhqksur65Q5f+p0vwvugW9ED+MELaF4zlkaYIUsFlvWW52bHYbgtAn7vfp93pgBGVZ8OmnLwiiiM1uz3g6JAo9bNclyXIWqx1VU6F0S13UxP0BV599hlZdjlia5xRVSaN0l7cnDWlR8MnLc45HPao85bMvXjKKPFwh2S23XJ2dUuY5/SigTEqisM/0+Ijb97fskwKtGpq64uH+jvOTGZNxjHAdUIamqkBKiqphenoKtsHyLFA1n16edmR62yaajEizhGqzxd1u6N9e4//tX2F+9ytuf/1X5NWWVb1hp1OUaXGwiYnwtY+nPXoiwBcufSvEt9xOlMKendlT6BLRSkIVMBIxsR1gWZKdSUl1hqNtQhPiaZehE9JKTWISCt0Zxj08ItsnEyV7nXSVoJWEtodr2Wx158uxWwtfuFiWJCWn1CW+dvFwKESFNgoXm0o3eDgIA43uwk/R4qPXTmuNheh2Z0gQHcFEiqc4n+9vTyPKp0oof0BdeTKYK7pOTxu+9w4dOj6MwbMtZnGAb0vqRnUmW60/7gGfLA3dU384yuSjGf2JvtI0DZYlMbpFqwrbcZACekHI6ekZtdJUZclnn36KH/lskh2NEIAmq0rqpqHn+bS15uFxiec7zI6mnBwdY1TLZBCBEfQGI/Zpzrs33+HaDmHUw3F9tGpRqkPJCcvCi/u4oQ+mpc7KDtRuSWbHJ3zy2ScYZcjzTpUnTcN2teTXv/4d+2SP53uEQUQvHmAJGIQBGMHDw4rtesOXf/wziiTpgpejiPHRMVlVE49H+I7X9eO6palLXN9jt1kRBBHJJsEPAuqipKpaFosFdVEipCDPU2zbIdnvydJO9OEFETc3d7R1hWlaRKOJfJ/j6QTHsri7/cBiseC7V28x0mGTpGA5HB1PqcqCJNl3o85NghLduPsnX/4US8L05Ih+3Ofl1RVlWlHnZbffNrDbp9xdf8APus5qOIi5vbvj/Pyc52fHvLi4wrEc7u8f2G43PN7fYrTmk08/Q+umQ6YNx3heyGa34f7+FmkkRyenSGmx26z55PIYx7JwPBdheTwsNtiWTVNWGEuQZiVu1KdpW3ZpwtnFGZfnZ4BGCs385oaf/dGXNLVms89YpwV5XvLis0/ZbJckRcHdzQe8wGM8jnm8vcXzQhzbZjDsk+YlQX9EUSuSrKBWqtvhHs1INhuifp+kLNnsMxzL4f2rV1jSsHx8ZHJ69qPWgz/4Dm+92WOZjMlszGjcZz1fMh5PKfJu1xCNTqAtaauMwfSS7779jvMXz7m/u8FoSWsgDCzysiRL9/SiiLY1TGYzUDX9QY+0bJhEMa7r8vjwwLNPX7JYbGiaGsfxOil9mvFQFjx/fsHt3ePB36po24rZ6Rm/+eVfMpxOCYMYvxezWG0Qm0fifoTWAscSnJ3M+PXffo232xN4AVlT4Mc9hLSxbYnWoNqan37xKa++e4slZXfl3xqK3R77cUn/7hY73UNVonVLH4G0fIw0HdVEdynZ5Q/CUh1h4UsP33g8neZbo6hEQytatNSUpiLXFY6xiERAgE8gwbEqFIqNSnC0RYCPbCWhMBjbkLY5ta4JhI9rXHpSI6QmbTICFeAbF1c6GBu2bUZfRDjawUgDFmSqojGdB81CUIsGZTSOsbCFpNaHFHMDWmgsI9FoWloEXYDQUy6CweBiI/l+5/a0YzN0hBQhBK5ro56EKAgUhsP6jkZ3ZmrLkthCYIRASNmFnDYNShuE0tiWACNQSmNb1mF8aWi0+ShmeVJudrl1nTITQJiuoF09e8F2n9FWNdvHFb7ndbaXYcw+3VNUNVXZ0OgW13PZJzmvv32H1oq75ZrBcECRpGS7hOnZKZYnkZ5D1IvZ7BLSdEcQeJ0952GB5VgcHR8xOT4hDH3WyzUawWQ0QAvDcr3DsgVXV8cslzv2aUZV1ziuTWNs9vs9p7NjTi7O0bJTODtlN8J/XCxxHQfHc8hXKy6fXzK/fkdgG0bjPr3Ap01TLA3DuBvhx5ELTUTbSjw/RmOhmob1ckVTpuzTAVVV8sknL8iLgrI1ZJs9jhew3W0YTmbEgx7r9SO2LdjvEv7OH33O+/slWa1phGC9XhP6HXLQ9QO0NiRpQjToM5rOuDw94uH2gaIocWyYHk0oik48Y4Qh8D2Mabi+3eDaFlJqnl1dcX/3wGA4wPI8lIBkv6VtK1TbYoSF1AbVNqy2Wxxb8Pzlc1aLNWWZ0+sNUF0ECHXV0qqGqNcHBJ7tEQQebdPQH4wR0mK+zUjKgjAKyYqUXhBSZyk/++Iz5o5N3dScH8+4WyxpmxZtO9w8LvB9n/FowOtXb1jst+yTDZ9++pKHxSPD8ZDdZofruAeRneT89ISHxyXjkxMeHx+xXQ/PcxCyxrJc2rrqUl0+vOfZZ5/zsFjRVCXL23taYzi7Omez2jCdHuGHHRN2vdz8qPXgD77gxVFIv9djv9tR1Z3J048CpOPgBz5pkjA7njE9Oebx7gZjW8RRj8BxqfIUpS3KqpOc+2GI9AKyLGV9f8NP/+6f8Ld/8zf0RhPKpmB2PKaph9zeLZkdn1JXDbaQHJ0cM188UFQNr6/viYKgm8M7ks0uIRo1jE5OaeuK9XrJ88sL4t4R33z9DcfTI3RbcXFxyrv3tyA83n+Y8/L5MyaDmFWSYQm4fX/DxbMLVg83WGVOvi+wJbz961+RfPU1J62N35quqzEC8GmNpkF15BGri9UxNmij0UaTtBWgqalJdI6k41q6OIAgxEMIn9a0VDRUskaj2egEB4u+DvFwMcLg2jYVDanKsI2Nb9zObC1BCUWqMkId4AkPRUvgWKR1jtYKR7u4loWwIWlTIgI87eGIhlZqSt1gDFhIWrq9no192KNpbGHRaIWFoPlBoYPupISBxhw6vx8KSA6dljxEAHU7uU6F2RW7Aynl0I4Z8T0hxT4oK5/GnE9fjOlwYsYSH5Fl0AlcLLoiWfPkwesKorY0Qnyv1AzDkFVZsdts2a7XOI6DFJLp8RlFUZDmBUWWMzs6oz8YoVuF1prR6YjpbMrXv/81IrNwHQ/PdRgPeviOw25fUDXw+tUbwjBgcjRmv90RugPqtiHNM9q2xXU8fM+lVAVlXpDsaybHR7RNTeBH5HlFluVYjstquWI4nnA+O2KzeECpmrKB2fEpVVlye/ue5y+e0TQFWZqQZznGGKqiZrPP+Tzs4fs++11CVWv6liYvS/aJ4vrNawaTIyQuVdWQZSleFDCeDCgSQeQ7XJ6fsdzsMXVJfzQhtyVOEGBZNlnaxXxNxiMmwwG/++3XbHYJtm2xuL4livsYYTOednlzwSDCk5CmBcv7FXWeEXk+035E2Sg2TUm/H2OahtOzI3abLaezKevVgvG4y59rlCHJcxqtUGkKGMaTCXEQ8OHmjt5wSD/qcXZ6xPvrLh/zzas7qlaT7ndcXl1SN4b3b95g+R493+VpdO04Nrrt7CRa7bGcLp1kv1vjeAG+6zLoD9GtYnZ8wt18SZ5XDAc9kqKgbirOL5/x3Ve/ZzKbYRBkSYrl2CzmjxyfnvHh5h6lGs4vn7OYLwiCkN12zXA45vEQ+hv4MUVRczY+Ik1W9CczlotHhoMRwkik0RR5gbQsPv/ZH7NcLAgtm2S9JU0zhJH0jKTXj6ir4ketB3/wI01hFFVVIYQmS1MkhsX9HcNeRJ2lhFHA62++RloOtuPx4vkzbt+/ZT5/OIw6fcJ+QJGnncx4s0VIi9nZJYvFgmcvnpPuNiTr1UFgIPE8n+2u++WtqxaM5uzkhGS9I7Akpq2JQ4/H+RxjNLfXH7g4OeK//a/+Dienx2RlQdM2XJwfYwkNjs96n1EqgXAF46MZ2gii4QSMw+L+hrjn4EgIXYdQN/jvvqH5j/8Lm//4vxGmG8pqS9KmJCqjMjWtUWg0DoeOzPiE2sdVDp52sIxFZPmM3YjYCfAtFyksatGSUrAxCWu27HXa4a4IGDMgIiCyPKQUbElZ6C2lrrCVQ2h8AukjLEgpaIzCVS6udghsl0zm7HSCVBJXOcR2QGu15CaHVhAaj9D2aEVLrktQFj3h40qbBoUjbPr0sKVNIw/J6tgIOuKJwRyEKF0hRIAyiqeP1rQ8BcIefno+msWfjOFl03WMUoqPVgIhvqei2BKE+L5w/tCH9zTpFMJgHf7wVF+1MbRKozAHMv3BxiA6U9+THQIEdVMzOzojLyqkbaFUxac//Smz42MmkxFZskWplrouqfOUbL/D91z22w13tzf4ns/p8QnpPiEvaiZHp9w/PJKnKWW25+hkxng0YP24IEtS0mzP2fkJSmmqqqEsa5wwxusPOTk/Zb1a4zgegR8wGfXRdcNsdkyv38VSKQG73Z6bN6+JhyOqsuCr3/6Gqqk4v7oEHOoK4tEQv9fDsl36/SEnFxe8f3hkvlx3HbJWlGXFerXGj2KC4RF+FPE4/8B4FPDs/JgwCNkuV7SNoW0V48mEZF8yX6cUZcvRbMJgEFKWOWWWc39zQ5kX3Lx+g43F+7sVj/MFqsgxTYfwWy7mZMmeOqt4vH/E9wPOL855/vIlr797y+39AmnbnF6e07Ql6X7L2/c3bPd7Fosl8+WO3mCC7bjYngu2JM8SVFOzWy3wvYB1kmAsi6zMeZg/8Ne//i1l3VBWJcfnF9RVjbQkrZQI10IDo9GQvFSkWYXtWPT7Pao8Ie71GE8mjGfH2I7D6ekxp0dHlEVFVubcfPjAeDyiVS11U7Pdp2zWa4q0IEtzxtMZvV7Met7ZLiaTKT/9yRcYNOPpjP5oxnK5xbIs2jJnOhuT7Ddslgtc1+fx7pZw0KduGuJ4hOdYBL5H21QsHu+4uLqCtkLVNd9++y2r9Z64PyDyfELPpypSXNflw5s3KFX/qPXgD77gZWVD0TTs0hw/6iHdECkMSbLFDyO26x3Sdnn11e/44rOXLOePnJ2fY9k226xgX5RsHh8ZxDG2MPR8lzjysVwbbTST0ZCr8zNevLzi5HiGMTVoQ7FPmJycoIwiTXOu339AWJJKdzsY01b4QYQwgtlkRJbnfHd9w2a/YTGfMxyNsLyIwHdo64Jvv3mFqksuT2akmy33d/f87ld/y2QyJvZcRrXB//1rhn/5NYv/9/8H5+GBnjI40qIwLZmp2JOxNnsWesOj2rDSO9Z61wGZdUOrDZaxcI1LZEL6JsRubXzlE5qAngzoWxGB7dJzfFo0GQVLvWWh1ux12j1XhcSmR4CPY1kUsmJtthSqOuzyfPp2gLJaMpFjlMZtPWICpC3ZklDpGl959HSAlJJM5NSq6SwcloO2DQk5KIGrbULboZYNtak/xt/UtBSU1KZFIHGwDzzUjlf5kYmJwMY6RPh0AOvuZj4WJHNAqxhjsAS4lnUYX+qPSk0hOxVnexCfHOoTmKf7OkHG057vqZF8KojygBzrINPio3ldCD4mMkghyMuaII4Rjs3JxRVIH4Hk+t07vKhHfzxlMBxTNzV1U6N0TVVmOJakzDOKJCFLU1zPI8+ybo8X+IynY4IwZLtaURQZUlpYwtA0NevFgjj0OrFOXZAkKe9evQbp8sVPPseWolNd7vaMRj1sq6XfD1F1Q7rZsVo8Mrt43uUtOi6ffPqSKktY3D9QlAW9XkyVt+x3CXVbcXt73wk9ej0sI1k/PhL6LrpV+K7D9ds3VFnKMAr4B//gT+n1I1abNcM4Igw9vvjJS2plWO1T+uMhQRzRCtglBa4bYIzEsgXJ9hHXdhF+wBc/+xzLFdhhwOnFKf/wv/kFw35IXTe8/Pwl56fHxP1+14mme5I0wev5nJ4dU1Utyb6ibVoG0zGOYyFdr8vWizv7QJpl9KM+rmXxJ3/yc2zHRTgBjmNjtCD0Q9JdlztpS0noOSzvHri/viXZbPBchyYvqKucIHTwLYmqC+JRjO151K1iOD7GIFkt1yznj9xd37LdpSzm97i2R1nUOEGPQmk2qwVH0zFVkTObjDG6oSwzmrokClwsx8LyPXa7hIe7B7arFWEU0rYti7s7iiynrCrOjo9whObZ1QVlmTGaTWjKlEY1CNdjudzQiyKm4yGfPLuiaTXD/oAoDDg9nuJKg2oVQdQDozk/WK/OL57zd37+8x+1HvzBF7zQdzvmZNTrlGPplsurC7x+jNIGx/XAEmRlwYcPHzi/esbb6wfKGvb7DMcJmM2muLbFi2fn2JbD+nGBUIr9cn2ID5qx3xfUVcX5+RlR6DKbjnAsm91mxfx+ju3YnJ8fM7+7xvEdWmETjyZg+5R1i+M4rO4f+OKzT4h6IUle8P7tWx63OWmyZzQcEPX7eK7PdDqmTnd42Y7yf/9fiH/9G8Qv/wr1zSustGCiY0Ll4SmXvgwZORE9OyCQHg4urnCwpUWLIjMliclZ6i1rs2WlNux0QqJTSlN9jKdxjUNgfALtE6qQQPuMZUzfjghtryvmomaht2xNQqlLPOMwND0iE+BKh1LU7EjJdIFoJbEO6VkByjZsdYJRECq/A0jLmrXZ02rFwEREVkgha3JdIhpBjI+UgpQcy1h42sOTNtrugmENBtfYeDg4WCihyKgwwuDjYmHRCvV9/JDRXS6ekU8CyY8KTXOwwIlDN9e2XZF7Skh46iC70NbuefLQoT11f0+A6VY/MTa/N54/2Rc4WA8c+YPuTxzS0Q+EFSFExzwtcnbzB/qhj6oKkJIyz6nKiqasOD89Y/W4RlgWdVXStjWWZdGfjIkn3bjq8uKc8aiHa0O6T6jLmijwWa/WbLcZVaMRtktRlSjLpdUG1zY4rkOR5tSN5rtXr0l2e6RRDPox/V7Ecpty/zAn2SXEvZBhHHI0nWAJiHshoGlVw/F0yuX5GecXx/T7Pp4jMW2Lalus0Odx/kiVV1iWoDbQ6G5m7EjR2XAkaCSPqzVZUVCpmrv7O47PzlludthCY7Rit1rQ8zzGcbeO+O7337JfLrl8/pLBZMKuKGiQpEWO41iUWcY2Lfj11+8Ai9Ew5uFhztdf/45hHNCPQ/wgQNUVF5cX1MYQ90OUMOy3BdIOsSzJxemMqq6xXIebt2/IsgxlDPv1hof7JY4tsSzJm/f3JEnKaDhAKE2WZrhBiBGdcTwMInSjmR6f4fk+pm1Ik5z1KuH0pOPzCiEpqoqqLlFtjcbg+T6qqZiM+jiOQ1pm5HlKFIfsVgmWHbJYd8ixPN2j6oaiKLFsG2lbjCZjpGqJegFxHBF4LvvtlmK/IR5EhIFLURQsViuE67Nc7WjKCqnBEYLT6YhkvSTqDSjqlqJRCNdGC4PtukRByHQ8w5IWcRiw3GwRnktR1riBD1Ly7nb+o9aDP/gd3nab4vs2lmXh+CHLdcbjcosnbVIapqcz1IPCsyKauuHVq99x+uw5TVGB8bibPzDp9/D8gKysqFRLqQxDLyDuD3n3+nVH6B+O+e7rr5kdnyCEpNaG5eMcLwjpT4ZMxjG79Q7Pdnh4WHJ5cYktJdGgR5ImSLuDJWbblBcvPuX+8ZHxeEpVlfQGfaajEx7md/z6P/4FF67L6O4aspyN0UghkQgKJB4ernBwpE2I0/nOfqD4M7IDMVc0eMJFCEODoTUtGo2NRaFrtNEfuxtHWEhjIRFY4iBkwUYaiSs8BNDSkMsSLEFrFIkq2JucvglwhENM1KUgWC3qgA+TWhJoj54M8ByHVOWgoaci+jIisQp2OqcwNbEK6RFQ2U3n12v8zl/nGEpdo1qNrx20BcoyZLrAMfbBP6dwjYtPR2BprBaMINAuRhoq0xAKD4OhEbqzJhywZNp0FoSPCQfie7yX/GG4qwD18fLxiaVyEJ1YBxEM3cgTvgdNqwNCLLDlIdFcHLyCXWFUWn+v/jSdinQ0HHNyekKZpyTbLUEYUtZVl8idprSm5cPdNRdXx2z3OUb1CPtj0JqmrPBcG8/1eHf9HlWXBPGAftxDa0VaFEyOZjy/umKz2WA7Nm1TdhaaPOf55RmtWCFsuxOZuD7zzZKiqfg7f/zH/O73rxG2S1UqXMdHhIbAd6mqing2pswr8u0Oz3FJk4Q/+vJLPtze0mrFaDRkMIh5nD9iG4Xne1y/fYvjeZxfnFHmBdfX73j+4gXR0KWoGuaLNbqpOD87JpWSz37xM+7u5yhhsbqfMz0+xpK6M0PbHtPZjNVige3YJPstQRQjBVRpRmJJkIIXn77k9voaz3d5/ftv+PLLz0mSlDAMePPuA0ibq+eXDE+OeZivyPYpg9GQ3WbFcDQmyzMWtx+YTCb4nsvpxSnvbIcyL7pcuDCiMZowDDjqRTwu12hjY7kuLz/7jM1uQ92UNFVJNBgymw558BySXYZlQ384YvnwQOEGNKsa1/eQjoPnDVBNzXqxYjgcMTk6pioL0qKgwkIb8P0I1dT0h0M2q47qNBgMWC/mnJ6d4YY+WksW8yV1lfL86orbh0dubm75+//Vn/DmzQeyZE+SpUy+/BlOWlCUgu2+6CAXloWF4bPPPqVSmtFoQNQL+PBhTc8Lef3dW+JRn9XqkU+fXfL1N68YjfpUVU6Vp1Ta0LQNFhKlFH7U+1HrwR98wXM9j8FoRF3ssGzZJTQrw269otYS1Ihh3CcMu46haT9gew63H94zHc3whE3b2ixXjwRhRF0XCDRGCtzAp1q3RL2Q8WTEsN9nv93x7NMX3Hz40Kkz24bHhznL+zum4xF+0Mcg+Ob3X/GLv/dznNrghxH3Hz7QGw14+/4WLwjZJXuMNniWxEoz3vzqN3jrJafJDmU0AWA5HsYYaq0odYOm2wGlpsDTDi42lpBYSBzRCU04jO9sbD4i+gGFRtH50TxLUx+idqQQNEbRHj6V0bjC+rib8vHwhIsnXGLjUJsa21KEjkep60PxK7GRBMYjVD5KKLSlqERLojNc7eIbl54IULZmr1JcYxNoF0841FbNWu1xjUMPHykEicjxtI3XeHjSpZQViW4I226nZ0lBc1CdSiAzFSE+Pi5SSSpZU1kNKPCMTS0UUoJnHCzz/eDjaYf39F/VjSm73Z1tdbs6V0KruksKpbperht9WiihUUp/v+v7AbSMw/GsQwxfq7rMuy5SSHxMVVBad+xNIUAYqiLl8eEeBNRKUVclflkgpSQII6qmYfU4RzcCKTvVab7bYjmCMk8JvIDH23v6wzGbIme1WFOVBZ7roJCMpkcstilZkiEtB9VKVJUTRgG38yVllnF80iN1XKZHM6Qt0Urx+6+/xZKSqsw5OjlCIkmLit1+w+nJKVleoLWhMgLHC7HLmu9eveHh7prh9Ii2adiv11w8f0me5YRxn+1mg3QcAt9HVRVRFHN3d08UDxgNh9iew+NDStZqtrsM1RikFlw9v6TKchqlCHsRcdzDEhbLxQNhGPDy00/55quv2Oz3nF894+Tqkl4QcHd3R5LmKG3x7PIS37a4ODuhqFpG4yGvvvmWl598znK5wu1ZeK6LMxlxenpK5HsI0yAdh+XcYbHsEGjT6Zjlwy2n5xdI0V0MZfuKk8tzVssVvt1hCD+8f0fYj6jrkvHxMdffvOL88ooiyxlNx7StwQs8PMfh9OyCNEtpleLTZ59SliXrzQ4/CgmiCCMlv//b33BydsZoPGT35hqt4PxiwnqfoJu2o8OMJ1hS0BsfEY9GB2tUyCJNmIzHvLu9x4siqvWWu4cNwnY5f/4JyX5DnhUgJKPRgIeHe3qDuFMc2xbL9Zr1asPk5IzHxZIwDiiKlMnRMZYF7169QjUNvu9xenbE7cOa3mBAsVhwdHxMWxbEUcRq++OSVv7gC97J8YCqLKirhnX6iO34bIoln7y4Yrnesd/s2W/XNKrB7cUMJ1PS7ZZWNzwsbrl69imN1vQGfXStGPfHDOKAfZHTmobeYAi2RV4VDIMxi2ZDWWRMpmOOpyOStOD337xGG0nVNpyeH6FbTRTaNK3h6vSU1XpL/Pwlb199QxTHZLsNY8Bb7/EfVlhFiWkaABQhpampTEMtuqgOR1p4to1Wmlqr7lN0ZHmJwDbyY+xNZ6wWuKIzfD9tsQwGVzgHGT4EHMQdh2ieViga2aLpUhVa3WJER2ApTY1tJC4OFhauchBKHE74Cte2qY2i0BWpLhmYAN/4OMKhFjWVbNnrDFfb+NrHkpJSNOx0RmA8AtV1rZlVkqqCQHsMZI9SluxVSqS6/aJyFHlb4B9CX6WUZLLqon+EpDY1BWU3YlUOEomSitZW0Bo841HQ5ePteIJFm+9N4HSFLK9afMdGGw4Fzjq8N10nZslObdnduu7Pd2xUqzFCoHXX4QkByhiaVmM78qNYRWn90fvXat2NM+X3GDNpFMLxqHSG5fsMR2OS7YbxYMBmscRg8+UvfkGy2dHUJa0SuGHIdDRgtZjTNg3D8ZQw6iMtwbOXn/B4/8BwPOLN22uyzR7pWCAg360ZTY9wXQfdpCgkbhShkAgaPrx+zfTkBCkkYehhjObd6zf4vZAy2dDkOUhB01qsNzvifp94EHP9/i3nl5eopsFy3K7AS8nVi5cYpfFdC2kUbdNgC7h+94F0v+Pk5IT9bkeRNRT5A4N+wNn5Ebv9Hs/3eXt7S1VUFN+9IclydJKhVQN2gGO7BPEAoxoeH9YMBxPG0xl3dw/kWc7x2Ql11WIag5Q2f/2rX9NWecfJPOlUqMpoLN+irHKUNGzXO6ZHR+x3G+q2xnMdvDDA8z2Ggx6LpuH1uzuEdOgPhqxWa4JeQJY9st2uSYsMo0UHicCibipsJyDdZ5xcXiBch/VuRz/qU9ddMvp89ch6vefo9IS8LPju9XsCu/OWNkKiVUPWNBhhkMJw8+EGz7MYjabc3d6SFwXm8P4P4h6Pj4+4jsvt9XssqzuPJEnC9GhGlS9xbA/XCExjWN3f4YU+p1dX7HZ7LAG79RJhui45ngxoVMtwMuNxvmSzXqGamigIuLy8YptmbDdbXn72RzRNwU8+e85vv/oGLJssKwhcj3K/I9mnvLh6zrs3b37UevAHX/Aelwm2JXjxyQt2Wc384RF/OKBsFMcnx7x59YbBZERVV1jCIggC0v2GwA2o6pr5fI5uG4IgwnVdwrjHriwoypomTwnDmKJqCPyItMxIkpTNasfp+Yy//OWv+PKPf47E0DY1+0SzTW6YzmZg+3z3+6/ZHB/TiyJC1+W836eZP2Bdz4krg1Tfd2CdOZqDL84hFlCZmlSVlKbCkRZIgWvbeMb92LG1RqG0IaHCOhQ7CyhM55nj4EIzQiN1F4pqHcJR5UdJRzfC9MwhfVgYStEgZFf8lNAUukJhQBukAYzEEw6esOkR0tBiJLR2Q65qCl0TmM4w7piu8OXUVDT4yiESHpHVGdGTtiAwLgMdUlgNicnxldd1sNKioMbSXQfpCZdGdmpLXzlE0qWVmko3SMAxFpWoyXRFXwQ4yulSu2VDKWpo6C4OxFMaAh/llT9MPXiqZ63qaCtPI84u7kejjQSlQXZ+vo692fWIH5+rDbYtca2DReLwZhvzva/v4zzT6naLytCBFAzQGqqipUXTi3t4foTOcnbrDddvS7L9lrPzM6oyp2oqLBT9/pAgDLh7WLBcPpLstxjHA62QuzU0KVleE/YnuJHP8DjE91xC12K3hWy/p9Kaqm7Z7xO++PzTDqiuJQ8312Bb2H5AXdYY3ZA3GabVlNWIwWTSFfJ9wsnRKSeTEcvtlsnJMapRlI1CC4PrBizv75gc2Xz+k884PZ4yny+5l4LtPsW2LJ5/8oxks2W7WRNPZjw76wOQZAXvX3/HrioxSGaTEZbtogHTloimJM0KtIKT8xM03XsT+B43b9/Rti11mvGTn/2csipQKubtm2vSWUbUCzk9OeVxuWGzWXHknmEbQVPVbNYJg+GIxeOcIPER2tAZY2uMFAjLYbVYk+edeEgYTZaXZFmOG0QEYcTx0Yz3b99x/f4ds4tLpGexXT/i2C7b3Za6rHA9ByEh6MU8Pt4z6I+4OD2lF3gstvsu2SHPGM1OsGS31wOB7YW0QhPEAVmyoyor4n6P9XpFW5f4bmfif/bsgs1mw+nZMfvdht5gyGw84NnVKcvlmrDnUtU1m9WaNEk4PT1jtVjRG8Uk+x1JXlPlFVWpsWyXIOrRVAVNq2iahvX8AT+KaNqKolW8/rAgz2ouns2YV3OaxpCmKb24R16WNE37o9aDP/iC1zQtl5fP0VqQJzuapsSxQ5KkAEtSFinjoyOSfYJtO+TZkv5wxLOXY4wWCKFZb/cURU1VVGx2SYfA6UfIIMayHUSR49gWWVIwGo9BOHz36h3YDtfvPxD3AgJ/zHafMTmacPvhnvOrS+p6htklFLfX7K7fwq5bHDtGssXCFTYg0IcOxZVdV2IJiUDiCochNkZGtEZR65paN2ihUELjShtbSIzddQetMmit0Wi0MVQcOjZtcDosMpXp5PyWsbAO1nMLC1tY2FiYw9/5uGhlCIXsonyE2x3X0hgMNQ25rshNgYWFY2x87RFIH0+4FFZFYSoSnXddnPEYCpdCdKPGQjcErdvt1izT5d+1NaHxcYRFadXkqqWvQ3r4FNRkosTVNgOrRyJyElPiG/fQIdrkoqKixcFCiE7l6WITaL/zBTqC3KmodIt58qsfipk5VCkhBJYlPzIunx7UpZ13o8tWaRzBITrFOowz4Sk9ocXgApZ8sks85THIj12kPNyvtO6O51oHEDUIYbFeLtBKsVzM2SdbLs/PSPOMfhwxGvUxRvP1bkdaKvywx2AyYbtcoWpYLNd4ns3V5SnLdUg/jvlwc02aGmZHZ7QPc7zAxTJdBJCRFg/LHU2t6MURF+MJVWtQVUFW1Tiex2QwYLddMJ7NaOqm+3dJQRREZMme1WqBQXYnHCFxA5/lLqFzeUhUkzM5OmW56uDNfhjy7s0tP/niJR9u79guV5yfP+P9u7ck+4RX370jyxKevXzJar7kJk/wo4jhYMDZ5TP6gctyt+Xk+IT9JusCYvdroijsqB7bNUHoY3seeV6CMESejz/oEz27IB6E3H/1jqvnV6yXNueXZ+zzDCk05C3Tk0ssxyIe9Tg7P+H9dUNrWuL+kCzJ8P2A9XqHlDaDXkBZZOyKmrpSOFVLLx4wnU1wA5fFfM3t+7c8uzzH7/WQtoMAijTj5fMXJGmKJR3CMOD6w3ss12a7XtPr99mslhwfH/Huwy1VXdMbDzFCcn4y4z/9+9cMj45wvZDlfMnR6RTVtly+eIGFJCsKAt+j1+uR5Snj6ZQ0SZiMhyxXG1bzB5QWbBYLTp9dkaUps9MLtosVx7MZ68WCpmmwHRfLwPFkwmgw4Pr9DV7oIYMpZV5RlTWu71O0BtsJsbBZPT4SDAZs1ktOL87YbnccHc+6f1ccUFYNmpYg9H/UevAHX/CEaXjzzddYtk1RFYcwV8XD/J6qSGiqBqEVV8+ekWc5RZGzT/ZUZUHci9G6IUkzsn1GPBhhW4LRbIgvbXrjgMVqxWg8ZLFe0Yv7JOmGcTSkIaYqM/wgwJKC/W7PaDxms1hQ3N6gsw3tm29QmxUYfXitnfikEQZh1Ec4MkBtoFQ11mEv5woHR9gfezBPSHw6EYYRhoYWZbrdXmZKGtnxI+0Ol9wZnUVXPLWhAzIfdlW1bqi1QtHwNPR0jNUJKQ7CXhsLYQS+dD/+vcQB6HaMwvtIYalEQ64qStN1YhEeoehCYWvZUomajUqwjaRnQiLhkVs1uSlBVwRtt98rrIrMFDjaJsKnkg0FNSiIRIhBk4sSpRWe6bx9qSnJVXmgvHj4siuqXdgrtCh2JicyLk7tIKXEWAbTPu3snrq874UrT7gwODRghz+LJ5A0BwWnZf1wTQocdnaHYtZ1bBpLdmNOaZmPD3oKlNWmK3rmYETvIogUZVlycnzE2eUZ796+J+4PUHXFatNdZR+fzPjs05c8Pq7J0oyyarGEIRwfs5/f4Tg2WVmTpRlVrYjCHq0qqeuSo9MTWqNY3tzwcvQ576/fU5UtQlpMp5c4jotja1Rbk+cpTdlgewGOa3cM2KrCOF4X3Oo4TM8u+eTFOe/e3fHs2Snfvb4mK3JU0wUL77dbTo6PEQYcaZPtd8xOTsjzitvbR3qDPptdghtuQStevHhGXbdEgYvv2Tx82PLJT7/g4e6BNKkYT0ZoG6Ts1ND7LEVoQ1WWxHFM6PlEQcj1q3dMjk/pD8ccH8868Hfbcj9foWwPpMX9/ZLjk2Oifo8PHz4wPZpx8+GWpmlp25ow8BiPhpRZTj8c4joeaZJw9fwFTV132W+OhyUlqi04Oz1CKUVtFDfXN3iBj9A1p+cXfPWbv2E8OyLwA1ANVZoSei53NyuMsaibIUZb2FZAkec8+/RTVg+3RIHktsgRlsvifo6qK968u2Zycsrx6REP93OOTye4nsPDhyXLxwVhNGTY73NyPKXV8OHDNf3RhCoveHycMzk6IeiPCIMeZZGzfXwk6EUUeU2apDibLW4UUdYlYeiweHxkNpnQGs1oNsTxQ6q6ZvnwyGQ6oyxLjG4RaEbDGCkN8WjIZjGnbUqMabsJjGMjLYskzSmygu1y8aPWgz/4gue5LtK3KYqKZy8+xxKKPM+JhzGz4yMmsxm9uMfD/YKqKvF9n8tnz3i4+cBumxD0fKQliMcjXM/BtA29eMJqtaHIS/J9ysnlOVEv4uZ+zt/7uz9nGHn8u7/8iv0mwXP7CFUT1BXVr/6K5t07RlXOwjR0vZDuruqFQaNAyAM1pBM4PBUYyRPfsct8a01ntA4sD0lXKDmgrowwSOMihCC0DCN6NKY90EQEmqcRn/w4+jQH5/RHL5pld2gyo5/4WpSqwTl0dBUtUoguSoencR3dHs9YuMbGFnaXNC48fFF3xc0odqboTm7awsdjKCIq0VBbLQklVgtu6zAQIbVou46vrempDlady5K9zuiZAM/YnV1BFjitTSh8tNQkFHitQ4RPKxWVqTFG4WkXFxtbWlQ03agLTU6FYxSB9tFG41oO2jRorQ9DX3kQnRjqVuFYPs0h9aBDuCksaXWJCPpJeNJ1a1qbbjdn/o/qzrbzK3QXEk9RCByeA3j2kzioGxWbbmqNawuOzy4pkoSqrNDKUBYV2/WC06vnlO/e83Bzx+nFBa3SeL7PaDgmiBwe7m/pD/q0TU2eZRijmEyHGCOpqwIBfHjziqtPPsd2PLbrNaJtmJ7MKIqauq753a+/YzAYUJclx6entI5hs1hSlTWq2eDYLrODWboocnabLV+3LVWas4witssVnh9S5AX9wZDhZMjkeMr6YcmLq1Pu53OSZEc0DKjKgqLMOT6/om7rjmYjXSxbYqoWx7JJdzuSxzVtUZBUe+aPd3i9jtjfKsiKlMvLK1go9klGlZZcffIcjOxINM1TR6oRts1uu2M8GWNJm09fPmO1WHJ/+8Dt9R2OFx0INR6uNyQMQ6TscHOnR8e8eXuNQpDmOXVZEgQ+d7cPOH5A6DmotqaqK4LQp1EtddXwsz/6ktlszN3tHYv1HtuycKXA7kVsNp3/ULgRdVlhSYvdZstwNKLIOmuI1obZbEpWNtiuizc54sO7N0yOT1CtBtPSj8d4fsjFs5coIVjc3aKait/8+itefPEZQRQS92P22y2OtDpMX9lydNTrbDY6pR/6PC7XfPHTL9jsdrjSYrNYEw8H+L2YsjWoLCcIfG7evcVxbCw0/V5Aut2SbfdMZ2OU0ZRVTnpfYIsOh7h4fCTuhUymE7755luiKOLu5o6j86sftR78/92H98//+T9HCMGf//mff7zPGMM/+2f/jLOzM4Ig4M/+7M/43e9+9394XlVV/NN/+k+ZTqdEUcQ/+Sf/hJubm//yFyAtqrbF7/eZL9cYKQgjj8l0wn6TgHD5cPNI0ypmkylGKeqiIAh8ynJP3O8T+T1E06Cringw4M2rV6Rlzu3DnEa1jOMA37ZY3N+zvJ/zy199xfL2miPXxv/mG6J//5f4/+tf4n17jXfg7Akjceh8X52YpPvqaAfXOAeAl40w4kC0lB9bBYuOB1mbhlTlFLrqsucO9JTvgfudJUEaC094RCLAFx49ETKRA0ZWzFDGTGS/Az4T4moHV9tIJZCtwFESqcEyEl86WFIQ2B6+4+HanU9IWgItoaRlT05CxlrsWZkdO5NR6Apb2cQqZKhDIjwCy0Hagp3MWJsEdOfBi7SH6zgkMmdnchxt0VcBrrRIZUFhKiLtMxARSipKUXfjUtN1ixkFKElMhBGQiYLqkKwgRecVVGhC7RLhf/TYAVSi4VHvmNcZ+tB5ffyZ/cGPVKPUISmh41sK2fEypXxiXz7dniwL4uP7cbj3kOd2OPJhN6cP8E4DH0emyhha1X0+Fb9dkrDbL8mrBMtxaduGx/mczWbDYrlASsFkMma7WBBFPsPJiKYtQbfUZUE/6mFJh/u7eQfL1pq2LMiTDMso4rDXofTiHmFvRBDGxFGI0F3Uz+T4BMv1iKIBju1h2zAaxcTDAeOTE0bHE2xHkuc5eVFgW5LBcIgyiuXjGj8IiOIA23Mo2hLbSNpSU9WK5XrPbrXDFpJR3MO2bU5OjviTn33CKO6xTwo2u5x9VmEkFFnKZDzCCzySLGN8PGY47NMkKWVZ0ijFxcUlFpo8TdFKMzs7Zb9ZM56M0VUORnN7fctmucYVhpOTE7J9StCLEI6L7XsEUcQnX3zOdpvguC7TyYjL8xMe53MqpQijCFqDlF1MUVWV7HY74vGUpm7wXRdbdiG3tu2x2WwI+32kFJSV4s3be/rDEbYFo0mfpi7AKHarLbPJCevHDYvHR6Rs+OSzqw5Iv99wfH7Kh5s5RkjyZE+dpaimYnp0RN3UpEXBcHzEdpPSlDXpfk+dF/T7AwbTMV4vYJcl2J6LVg39XkQY9iiKHNu1effuA/skBddFBhF5kbNPO8O5tCwsy+Lq8pKmLNFNxeOHGx6u77GlxXA45Oj8AjfwsWxJVmRUTcNvfvVX2I7Ps2eXNKpFOj5FmnD/sGCx2qCVxvEDhNGcnZ3+l5/z/3+Vgx/1aP/Z7Ze//CX/+l//a37+n7nl/8W/+Bf8y3/5L/lX/+pf8ctf/pKTkxP+0T/6RyRJ8vExf/7nf86//bf/ln/zb/4Nf/EXf0Gapvzjf/yPUUr9F72Gcb/H0WxMVRU4jsW7N+85Ho15/HDLfr0l3W1xrU7ZFPVC8nRPmW6xLUEvitg8LpFCULUtSkjev79Gei5BGDLoh4Rxn3fXH/jwuOLs9IT1u3fo777F//o3VP/hf6X67rdU20eatu5wXSLAPZihpZFYCKSROIfsuIHsMbOGDGSPUAR4wiUQHZIrkB0BxPzwwxhq3ZDpkkTl5Lqm1p2lwNDJ3LXRT6iQw/P5OFKTiK4jwyESPkMRMbH6jP6/3P1JjGVbmteJ/tbum9M31pt579ev3ybiRmTPq5f1KlNIJVRvwCAHMELMYAACBEJMkkkikBBIyQwhgYQQ0zcrZaIqEiozIzOavHEbv967m1t7+mb33VpvsI+Z+40IikoyXkMsl8ntbNunMTv77G9//+/faC1awqdFgx4tOjToqSaNysUsNfRCQCkxlVaLt4VBS3fpWA08y8UxLTR9w7YkYqnWhCpBKYUjbbzSwa0cmsLF1HWWImKhAoQEIzfoiSa6obEQIbHKcKRFQ9YJDEsREqscSxrYwiTTarNrR5mYGGR6RqhiTGXgUSczhCqBClws0GBFrfnzpY0mdBZVxnkWM9Ilye4OyngLflzP8dTbsldWdWdebQqcLjbgshDX267+1pWU1zpIbcO0vKqzaiNK1/TNdlHvowvQjTrip1KKtCg30Cb0uh36wz5Kytqw2XLRTZtWd4hvO9w4OMRxLDTTYjZdsFosWS3W2E4X0Hn29BmXZ6fsHx5guA5vXh+zWszJ84wwSbEbHnmZs5rNSLOQ/vYQy7JqTV5VESUZpm2DBusoYrYMcP1abO17LnGUEaxSwjBG1w26nS5ZmLCzs4thQp6neF6TXqeDjFPyLEMpyWw6YbJYkSnF5fkFvmVwa2+bp0+f8PL5MUWaoGSJoqSoKrK8xGn4mI0WmmUBGnkmuTw5odftsruzzcHeDqtVxOXlhFa3R6vb5eL8nLyUbG33SYuc3qCHEhpS6kRJhpQVQkjC1ZrlfFWTjiwDy/WoSkkYBczmS8bTBUpKgihiMZ8QBqva87WSLCdjPNdiPJkglaTtWWz12kRRTFko8ijHswwEGvNFyGwy4+TknO1hn9u3b2I3WqQSDMem2/Xp9du0Ol003aZIMnaGPXrtJjIvmFxekGQpjU4Lz/dZLWZUeYLn2FR5VjvgLJZMpjOk0Gm0WriOzWIdkBWK9SJASR3TMGg1/TplvdnEsQ0838Z2DCxbJ0tj0jhACkUUBCxmM9BNFkFEs92mrCp6wz7aJprMa7Yoy4qz16/Y29smCha4lk6r3ycI1wRByIP37iHTlO29A+JwzTqMabWa7Az7SARh+N9JPFAYhvzlv/yX+Zf/8l/S7Xavtyul+Of//J/zD/7BP+Av/sW/yIcffsi/+Tf/hjiO+Xf/7t8BsFqt+Ff/6l/xT//pP+XXf/3X+eSTT/i3//bf8vnnn/Mf/sN/+FO9jvFkwmK+ptducbC3TVmVPH55QndrB6UKXFPDUAXDfhulKkxTJ45jyqKsM+1ck5OTY/qDDpaQ3Lh5hC5gMb5A10yiMKVMJOrTr+D3/w+SP/hPJI8/w8wTNCXRDW0zo1pTqgoDHU84NIWPI2xcHHxc2qJBT29hC2vDkjRwNYum7uFrDq6wsDULR3M2BBJjA3duugg2zv2qIlMFqaxd8q86wVJVG9cUda2nK2WF2gSUXtloXVXDq8dj49avq5qp6WLTFg0GosVQdOjQpKsatCsPpzJRhaQq65OzoWv4lo1v2miGTkTCipAZK9ZECKXwKouG9GhpLrqhsRYRARGyknQqj5bwqHRFIBJyUWBWBh18ClGyFgmVVPjKwdYsEi2npMKVtYxhLWICYlxp1u4tekGqChxp0jQ8FsSc5GtepyFRuw+33mP3V36dg09+Gc32v6abU7AhrrwTHSS+DlmKjf3Xlb1YtZEfaNfElLfwpbwuirXw/KqA6rqGodXFMy/r1IVrL83NPTzXYafXAyUYXV6yXozY2uoiy5yLi0umywWrKMS0NNqdFv1eB12vQfH9gyM+/OgjTNumlBWjk5c4ro3SLIZ7+1TUfqHbgyG+61AVObPpDMOshdNxGGAaJpZpcXSwg23pFGXBeDwnmC/p+j6L0YjFdIypa5iGwWw+p91ucPb6OYYGrWaTaL0ijWI832cdxUxXS6QAx7Fx/Qa277JYBZyeXdDqDVjHKUoIbN+nzDNkFtXw68k5SRKRpgmDQYdeu4nrd2h1Bpi6yfnpCdPxiDhJGV2OEJoClWPognC1JMtiNEvQalnsDBqkSYBpm0wnM5SsvXNXy4iTkwnPnz5HlgWGbmK7LlIJ2t0+Ms3odfuswwjfc3FMnd2dbVbrCKFp3Lp9i+k84Pj4gigM8Tydo5uHNAyDm/vbuLZia7+P6Zi8fP2GV89fI0uBKWxGk5Dvffqcy7MztgddovWa09dvOHn5CtuxCZZzbty6haogjUvQDBrtDlleIUtBr92h2lwsISVlVjCfLjAti2A6xjYN+t0euqZzOZkzmQYkSQHCpKokd2/fosxL4kxydnJOWUJVlJhGHUtEVZGFK24dHeB5DYqixHJ0Gu0ml+cjDAHBOuD87AKv1SZMMvIs5fDoEM/3ePbkOReXIzRZsNXvYRQRrYbP62fPQSiEeBdb+bOv/48VvL/+1/86f+Ev/AV+/dd//WvbX716xeXlJX/+z//56222bfOrv/qr/MEf/AEA3//+9ymK4mv77O3t8eGHH17v86Mry7I6gfydL6idVoI4IcoSClnQ7XeZXJ7g+Ta37twiSmIKYRLGObpQmLZFWYBpOAz6AzrdDvfev8/lyRsQRh0PsgrwhM76iz/BefEF1X/+33Bfv6a9lrSUh6ssdCnIqoxCVfimgxKKtQopKAGBKQx84dLSGjiaTUHBuqpdMko2BsUb0fhb8XhdBBuahytqh5KrL1fY+JqDo1lYQt8QKGoHlUJVRDIj3bA4C1mSyxoCrahQSgK1Q0qJ3LisyE1SgMZVZyg3XeWVp6SGhoGOpUxsLFrCZ0iboerQqByqQhIUcc16BGzDQjcMhKYRi4Ipa1ZEpDLDqSyapVvH/xg6Kz0moCaotKVPU9QdRKwnxCqjoRxcVRNXAhmjKkVLuuiihj5LWdFSLpYwiEROKSscaSNRnBYrXuYr5paB881vM/il/4mDX/ofEa7L1t4emmHg9Ha4lhAI8bVjrf67cO3FqZQiLyV5VaHp2uZnapOacDVbrS3KpFLXHaCAjWUYb4XlXMn+BGlebsyqN/FEAkARhAnzeUApK9DAcW2yJKbf73Pr5iG6MIjXK/I4r+dkrQaNhsfpyRuefPknjEZnGIbAMHS8Rp/t3QM6nTbhaolQCqEUZ6MxmtPA6wyohMFsssQxDGReYFgGtmuwXge1x6Omc7C/S3cw4PGLVxi2Q6vbocpiXE1hqArXd+j1+6yXCyzLYrVc0Gj5hOEay9Rp+zZbgy7tpk8ahZiGzcXFjCgFTWks5iuCIMJzbA72d2k1fWSRIsqUb338AZZRxxr1hwN6232yss7A8zyH4bCD49QawWAVUlaCIIx48fQFg+6APC5YBxFxUYAs2d8d4LjmJqK+xDVBliVKQn/Yp9tp4foecRKR5ClRnNDqtAmjhCBKGF2OiOKU4dYQVRQMOi1+4Zv38V2TdqPBcrYgjGMuJmN29gcs5xNkkZMEAa5psr0zwNA1dvZ26HY73L1zA8t2EJv57WA4wPEbnLw5xXO9Wkt3cYqSObPJBWmeE0UBXsNhNl9z48YN2u02umEx6Pfo9XsYlonXaJHEIWkc4JoC37GwfAvd0lgHSzTD5GI8wbRNijyn0Wrx/ocPydIM07TJ8xxN00nTkulkjG3ZLOYLotWaKk1oeC5lkWFZNt3ugGAdMZvPGQy2WK/WjMZTVsGa7f19vE4f02lSKY12t0sJ9Ic7VOV/B7KEf//v/z0/+MEP+O53v/tjP7u8vARge3v7a9u3t7c5Pj6+3seyrK91hlf7XN3/R9c/+kf/iH/4D//hj213vSZZlmIIH61SZGnO/o2bzMYzjo4OaDYbdLpdTs/OWIUJltNgNj9jEa45vzxnuDMkSVIG23uUQcL05Us6Fyf4SU4VZYQiwtEMCt2gqMDCoikaeFSsVEBYRugmWKaOlIpVFeBrdWxOpSoSlW4cUiRKQKZKhKrJH46wasgRHVMY116KmtCwNfNrsJnaXAkZaAihX3cUdZJ37aBSympz0q2lCVd31tAwhH6dHABiI1S/mifVPaAp6izviiumobrOa7s6gUtVv4YmHhYGU7lEaiVZJSlQDOwGuibwsSllSVilGBTkqsDBwq42yfKaRWrkrGSMLgWetPFU3bllRsH6Ss4g6yDaVGQUUsOsDBzdJdVyQpXW3Z4ymamIdZGR6Rqy0eQX/uf/JyU6x+cXWLZRB5buHTIZX9Lb3qVoN4hOvk4kufr75xvt3ZVJtJQSWQv3MHQNVal6JqcUhtA2spLaa7PaQM1Xfzdt46oiZYXSaucWKSW6riPLqi5AG0VkbbepSLMStYhwLJter8dqtWS1XGN5PkEUcrB/QF7mOF6TF199hlQ3EZqGLEPyJCEvJL2tPbqDHmmUsFrMKLMUv91kvkzqmV+eUuQly+mY+XSKtrVFo1M7CTX8AVJpuI0ur1+f0Wx3efz0Mf1hn91+hz/5znfYv7FPZ9DHsi3KVchoNCNer9nfGXLy4jWd3UO2trbR9Rk7+7uMTk9Ik4xufwvTsphO53Q7DZpNl7RQ+J1urf9cL5jOZ7VLzGpNEsXM5nPOz08RaDURJE8Qhk4cp1i2RxyOEUqxu3tAnCaUWU5pmCBLgihDaRaO51EoWXtqBgl+s4MUgnWSIdKCRquJ3/Q5OX7N7sEepqbQDI0iyXBsl1KpmulsaJiuh99uU5aSOFhyejlmpEmkJigqiW6YoNkswzVvTsfs7OzTbDbrWJx2myiKsByTOAyplCAtSh68/4A0Tbhx+wbtZqP+HFYVru8xny9wvBa67dLfstjd3eWVJur8R8dkOpuwmI0YbO+zWs05unuL50+esr29Q3p2Qa/XxDQcTk4uqGQdKG11OzX8WsF6uWBndwen4bGezWi1uixXAXmRY+kajqFTZTFRnOO4HjKPmM7nbG/vgq6xdXDI6OyMg/09Xh+/5s4v/gLjyxGyknT7fYqqIg4DZpMxN2/f33jUCtI0IE3S/1KZ+W9aP/WCd3Jywt/4G3+D3/md38Fx/ssaCvFjV83qx7b96Po/2+fv//2/z9/6W3/r+vZ6vebw8JCizNgaDjnc3+X45IKiAqesh+inp6cMex2ePnuBaZqsZ1MarTaDfg/PtphVBTKI8edLJi++oBPk+JUgEwma5ZKLkg4+qcxJKaioyLUKR5VYyqIr2ki1IiiS6yJlWAarso4askWdESdUre2ydBOEoJAFicyIyahUiZAavnDwNRdD6dehpZsegWrjqHI1obuitG8aAgyhbyywdGpai0ZBtZnrCXJVUKjymlxRqlrSYFC7bZSq7koLpeFo1ua90DawZw0SvLVR3rxXG6DUUAYZOWg1nV4ogabVrhBSKWSlqHRJKUoCWZubOcrBlTq2NAm1GCxIZE608ct0pIWtWwRaXIebSgNX2lRaRaAlOFgYUscETosFmaZh9Pt424cc7O/jODrf+OQj/vh7X2IInWazRZUn7B3sbfxPHSajyeZ3eed42/zJ5YZFqQmuP5xstHNCE8iyvphQVQ1pozTQ621SKoT21nhabjpEQ6/TGpSmXT9VfbEirg7++r1F0Os2CaoE128gdB2JRV6VFFFCp9OmyCssrXbS39oeUlU5SZJy49ZNHL+JwkBJSRIu8dw6mDMtC7ZbTdbrFbKsWM9WuH4LSlm/z7pOmuUUpWQ2nZN3mqwnE24/eI/lbEkchyzGE3Ye1LE0WZoSTGZ0j/YpJ2+YPPkexWrGCQohDJZCEGQJaRAx2B4QFwXNdofFYonj+7S7XZqNWqBcRAt8r0mn22U+HlE6HsvZlO3tbdI0JYrq4tzr9XBsi+W8JCtq78t1EBHFOTvbBywXC0xLo9n00QwL3fQI45DFcorfbKKkJFqHLHQD0zAolCCJYrxGE9fz6fd6nOsahuOS5BkSRbPTRlOwXAWYtoNlmmwd7fPp9z7j7vvvkwQrer0Wi0XAx9/8kK+ePqfZ6lCkJYcHhyxWEWWZoxkGs/kCw7Z5+vgJfqsNlcRttHj+9OmGRAU/93PfZD1foGRBmRfYgwHnp+c4boP1YoHru5yeX9Sz4VLR67Z5+fQZW4Mhy+mM7f19xhdjikLy5vgEv9nGa7R48fKUXCrSYIlpW5i2za3tbZ4/fc7Nw0OyLKZKss1FRIZQFb12k8Ggy3w+5+btO/zws6/o93scPxtx4/Y9nnzxGf/D//A/8OWTF4RByGAw3Ijzx0RxxN2bN1msAjptj3GZshC13vX0YkKBYDkec/vOnf/TmvCnXT/1gvf973+f8XjMt7/97ettVVXxn/7Tf+Jf/It/wZMnT4C6i9vdfcvAGY/H113fzs4OeZ6zWCy+1uWNx2N+5Vd+5Sc+r23b2Lb9Y9tNA+I04MWxZHt/lzQ7Qzc00jQiCALC5ZztnV3OTk+5cfMWZ29O6TQ8ivMT1MlLRJjgZhp+uaLQFIZy8PFYZDGmrlOUJS4WmjCoqAhlTCIqMMAoDTo0iVRcC6OrBF0amGgoAZaoDZgRikwWpDKrXTx0MHSjDi5VNZkhkhmBTLAwMDGoKDdxN7Wc1xLGtS7uLWRWdxBKUadvK4Upag9NC6P2YlR1IGqp3hJdFJJKgRJXBtJis62ilOWmc6m7vdqZpYZbhXq35IGJQVc0KVTJUkWg1yQPS9UJ4FKALo2acyoATZHLElSGvQmZbUqPZRniWBaFKFgUMa4y6VRNHGGBqUhlSVIW+NLBFQ5rFTPLU/B8ZHvI4YffprG9y/n5OWFWUgL/+Y/+mN2dQ0aTMVEQYxrQaLUQhllT9pMUR7wl90Ad/qpp+vVFl3Gd9VPPPKVU1ynpUtX+l1fxPmJjG1Zu2uYrM2ghBIYmNvfZQMdKoYsrg2mJ0jf5eFdm1Rq0ui1ydIqqwhAlWZHjNpoYukkURzz+8odsHd2EMqfd7bEOUqQwcR0L17Y4vRwRhQJZZNy99x5hkhOEMY7jkaYVg+0+0TokSjPuP/yA1XrNcjZByJLuYIBrG6imS5WnpPGaVqtDES6wsgBx/pLRkz+hXM14/F1BlWcA6AIqBKbQMJ99hv3JL7O1v8N8vabZ7NLwPE6PX2M4LnEAZVZhOSau7fP80SNa3S6oijQKavKTY9Ed9KiyjLt3b3N6PkIzDLa3dkjiiLLKEZqkrHKCeEGWr+n2tnAbu7D5bBQK5tMJnufS8DyazQZFXjA6P+Xe+w/YGfZ5c3LK5fkZ/X6fMisoc8l6vcB2XDqtDgJBFK7rDjPJKG2L/YM9+u0m/v27HL9+jdPsMhrNmF9eopRkPV/xwUcfI8uSQpMslwvyomQ2W7Jz4xa6EIxOXuNYOtvDDs1Oj5OTU7766glxEPDg/j2W64h1GBEES5qdLnESg1Ss5iv8hsd8fMl6uSIpKnYaPsvlgiiJ0XTBgwf3+fQHP8Rycp4/fU5vuIXlWEzGoOlWzXDNU6SCi8sJXtOlzNZYTh2eqxsmjmsxmq/p9bb58tFThFAcHewShwFZkuB4PoN+g17TATFksVjSbLdRVYmlSQqliKOY2WREVlS0On2qMsO2HdqixdHeNmcnx//VmvOnWT/1gvdrv/ZrfP7551/b9lf+yl/hwYMH/L2/9/e4ffs2Ozs7/O7v/i6ffPIJAHme83u/93v843/8jwH49re/jWma/O7v/i6/8Ru/AcDFxQVffPEF/+Sf/JM/1esRwsAyXYo8IV2v0VTBycmI4c4WeZbw8OFDhKxI203Gf/BHuIs5SRFgJiW+1EhFRolOQ/iERGRajiY1msIlqVJSUVGIAhMLD4eG8ghURElJquV40qUpfDwcUgp0pWEIDV3UPiZCq4kmDiWlqsHNqEzIyNHQ6zgbzcTWzTq2VEkKSgolUVpNRClljsEmR00KTDSE0vCEU7uKKLHxTBFvhdCbk7glDExACqM2W0ZSKm0DbdYCdm0DqSlRd21SKCrqbq2gRN9IJowrUfwVoUZQu7QoA1fYG7eUgoQMXdewDQvT1EmqlGIjqahEQUZBoSw84aApnVbVIM7TOt7GcpnnEQKNhnLJ8xLXNJmTMC3m5JqG6nZpP/wmwxu3CMIAo9miKAtu37nN5cUIy/M4fv4VhmFT5AmO5xCulpy+eoPbaNLvt2nvHJG9GKOoJQGGviGeiA2zUimKqu66LFVbhOlKEGYFcuO4or/TrdXFa3MxsLENqxSITWFTeh0ZVMk6oaG2ldt07lcOK9TPXWQ509EYy2+znE25d/tGLWyWgjiMqWTJ0e17GIbO9vYhvudCVeJZFq9HEyzbRtPBMC0yCcen5yhRG03LNMXxGgyGQ0zLJr0YESUxaRRydOs2aRRgWwZNz+X1F59yY3+PVnBJ+Og7lGnC97+TbzrgjfsMdTdrCLE5KmprO6KQ5NGnNH/1f8Y0LKgklZQ15X/YYz5bkCQhKIv79++hyoyyLEhKiW2bzKYTLsdTDmyPPElZLc7p9AeUeUES1sGmmtDQDROlGRQSkqxgHdfawJrEI9geDgmBOAhYrwI6vQGu36LZHXJxekmZF/idFkVZEYcJbsNBlTG9Vosky0Ep5qMJt+/cJAjWoJt89egx/a0hF6MR924ekcQxeVkwm07ZP7pFUqRoukaRZ0zH49qLc7mm2xtweX5Of3eHLF5z694tWq0Wy0XAdDal22kyncx4+OFDpos1ru9RRBkHt+5gmBrNssWw32dpLgjimN29fZ4/f47X6vLy5SsODw9YzeeEaUGWJui6iee65FlGmmWEwYpud8jF2RhZlVy8OWbn8AY6giiOWAUhe7s7vHz+GL/dw2/skcczXkwnmIbg7v37FFnG7s4Wz5++QJouf/C9R6RRxO7+NkmUMV0s0QTcuHmDslLsHmzznd97yvvf+jZ5uEZDkacZSRKBEMwXqz/V+f6/tn7qBa/ZbPLhhx9+bZvv+/T7/evtf/Nv/k1+67d+i3v37nHv3j1+67d+C8/z+Et/6S8B0G63+at/9a/yt//236bf79Pr9fg7f+fv8NFHH/0YCea/tvrDAZZtM744I1isMEwTZEGWJPSabYqTN6x/8IhkfYlRFLjSISWn0sAStYVWqZVUoqRReYQqIdEz9EqnIVwU1LlxekmhFahC0KHJsghq/0SjJC1LzE0ZKKmoVEmlasWxjYmm6hmdTk1usIVNqjISMgSQVQVGtZGpi9rMue7KamcPS68LjaRmIQkhKKqKuVyDqnV7ljJwMKmJ+zpXhtF1DE7dodRWZvUJuhQ1eUZTteavPl1rG4l6zZ6SqE3CQn1izymvWZ02FoYyMEVtrCyU2Dy3iQ9kZUFVFRRCglYL3QFKJElVz98yWWBjYmPiVXYNfxoVLd2homJeBKhKY5pFxIaGs3dIa+8Au7+DEIpWt8vte/dZRxEvnj4HIdjd36LdbtNyNdrtNo7l4tgmlxsZwGwyxjM1Pvm5n+M7L7+PoDZwNnT9a3ZiUqraIPoK5pSqns/oGlVR+5fqWj3n0zbGmFeyhqukCW3DvnwreaiLniYEauOuUpQSZ+OjKWUtWs9KWZM+NJM8TwjTnDBOcHyfMo9puB6a6eD4Li/fvKFQGsFiztgy6Q+6JEmGqhTtdhff85jOlhRFhu14OO0uZZGRZZIkzjB0ncV4BGlOIQTR8TOC9ZxEF3jjS84e/6CeP3LtFIohNtpR8Rbw1t8FvUVNw7GXM6Y/+H0e/vn/hbyUvDk5x3BcVqsY0zDp9wbMFwtOLy4JozXbO3ss35xTyjreaf/gqJYT6BpFqagqRbvjMx/PsfwW/Z1tsjji3u1bpFlBNFsyubikUpK9/X0uz08p8pJO02cdBGxt77GYz4njhOVySafVotVv4bVaVJogzwuC9RrT0Dk4PCQeLwgWAYv5nBe6hixSjm7dwWu4WI5NuJgRZwmlMLj/3m2+8/t/QF6C7dh0u0NOz87RXRulKdymT7/bZLWwmYxGpFFIf7jDfJ5g+j7RdEmRZrTabTy/SXR8gW3ZXJ4fUxYaQteJV2uGw37twyoLLMvEtjQOD4ZEkU+r3SFOc7a6Nhenbzg4uoVSGkpK0qTW0WlSgJLomsIwdSwDlusVtt/CzCJc36fRbNHwXZ49+pJmq01/aw8pC+Io58vPH7G7v8P2zhZes8HJyQWNRpPPfvg5Dz98iGNI4rTk+ZOntLsD2k2PX/qVX+T18Ru2dg6J13OU6ZHlGSICz/sZiAf6u3/375IkCX/tr/01FosFv/iLv8jv/M7v0Gw2r/f5Z//sn2EYBr/xG79BkiT82q/9Gv/6X/9rdF3/Uz3XfD7n/Q/eZxWsWcwWmLJi3zKxH70gXF1wmkeY0sTHJNEVMxmwp/UIZEwsMro0iCrJQkRsaW2alVd7RJKSypym5uLjEVURUpMIQ2BUBh0a9WxP5QhNu3Y2sbHq7o8CQ2hUop7t1H6VtUGzho4vPFzlUo/C63+G0EhVTik25BIFkookL0EISlGho+HptcuKa9rkskRJRUoJAtZVPQR2qWNwruQN1lVh2pyYrE15coWNFJJUFpuur6qJIypHCEWpFKWoaphVVTWbEEFKhkaBpsT1427Uh2hoOMJAYYCCsqooyhKlSZRQtHQHNEEpJXGVkasCXem4ykYrNHRMxtWKCIXR6XHw0a+wLgX9rR1WqzVZmFKpghfRCYtVzM52n4ODfUbjMWWZEQcBjYaHRLK7v82ffO9TdvZ2mS0Cqkrx6PFTen790RBCUEiFpWpIE+qk+3Wa07JNUIqiqHBsA0PX6lTxpLgmDAmgqtR1mGu1SYhV1DM/HXGdO3jloalpAlkpzGvNnriGNEHRbrdJtB6D7QEjCrI8Q25SpJdBheU3qPKchu/gt7rMF3O6uzvkeYGlaWiaznI8oTfYQtMNNMOg12wQBSHj2YLVYsze7g4yWqMWM/QsJD55yagEZ/NaQ+qCr4B88w6rq99XKXRx1c297WprX1iFgVZ3vUpinh0z+vKHqK2DOvux1aEoJdF6ziff3EbKlDfHL5mPJ5jNLp1hD9v1WNpLlKazXi4pkxjdsskKieN32TposF6tefn8NZ1uF1OkuE2f2w/uoQGji3OE0Gi3u2xtDbm8HDOfLdAth/39PaqiJIvWyLKgLAuQOWWS4DWaXL55zdbePucXIzTNQOgajm/hN12m45hVsEZoEAUrxpfnWA2fYLmuPVHRaPkel6dvaHYGaLrOztaAs5MTXNvi5ctXtNpdzDTF3dlhuVqh6xYKhWkYDLeGrOZTJrMVk43VV6M9JItjDNvC9z0s22A6nXN0Y5c4jjBsj9l0hdANRuNFbSQ/XzIY7iCrgizJMCwTpaA72GI6ueDBg7s8+uIzmp0eulDcunnEqzdngE4QhmimQxxntAdDbMskWC1otFpcXJ7z8OOP2dse8OTpc6bjGYahc/f2Ia4haLgu3t4uAgjilNl0ii4UQSx478EDmo0mf/wHr7hxuweFg2a6TKfTP9X5/r+2/r9S8P7jf/yPX7sthOA3f/M3+c3f/M3/4n0cx+G3f/u3+e3f/u0/03Pv7W/x4ovP8bIS7dFn6PGaRFYgbexKEAqJMBWWMqGCuZyT6jmOtAlkQmBENWNSmoRaglQKDwdPWMQiIyVHAT4e6zxCNwSaLlCloCk8JBWFujLvqvPqPDxMYRKrhFwWKCFIRUnLFERVgqoUjrJqs2al0NGv430sYW26Q3XN+JOizq8rVUkhKpIq38yBNApV0TS8WoQuFLqpb8JIFXmZI1WG2IifTfTNjHDTj270ffrGikuhKNQVTbjW82loGzlDVQeWXneDgpLyazO9QpU1OLohvJjUfqB1AbQRChylqGRFTIbQVG2dJgRRkTEuZqQSKtuhdeMed+5/g/l6Te76+KZDXlV4nkOraSOEYDJdYlkWSRSSxCmyKKk0jdFkTO+DByzmcxaLkDRNUGhMR2e1Fk1AqUvQDTRRvPXQVBuq0EZCcEUOupqTKmr2qlaPZTd2b6o2my6qa/3eVbqC2hSMK8IL1Jo+TYg60mjjf8ks5lAAAQAASURBVHpl+CI3xS9YLnEPDum2O2hKUJUl62qCkiVloTAdh9l0xmo5Qxi1P6hj2UhVEcUFtu2wf7BHr9MgjmLGp2doWUo8v8TOQ8RizOSpQpUlsqqu4UmhBAb1bNkUBrkqsEWNAJQbgk3JW49Soa40olx3wvD2QkBHQFWx/N7vE9x8iGj3abdahNESTTN58+acLK/YP9ip/65ViWbYtLstomBNEceEyyW3797m9OQ1muYwGl0ihGB72CIObdpNj6ePH9PqDTBtB8cyaXS66IZOHEUUpYbtt7k5GGJocH7yhm63i227VLJiNjoHBmzvDGg12pClLIMIS9e5deeISmkgNAbDAXESoYAiK1CmRrvTp+nVCeXReoluGLR9l8Cx6LZcpuMJQgxptlt02x2effWISmkcHOzjOibHpxckaYSha3ieh8xT9vb3GE+XHN2+xfn5Gc1OD0HJ1s4+08mM6WJOZ9DFb7RQYYhtOrQbbdIiJ08idoYDnjx7RoQkDgSWXY895tMLfN8nCGPOzi5RCra2tzh5+YJCwnq1wrJsZBYz6LYIo5hWu8Xo/JxWs0VeFiwWK7568owXT59yeHRIr9dnvlzy+OlLXM/n+M0JN28eoiFoajbPnj7j3oMHvHz9hs+/+IqG5+J3uli2hambrNcrTMP8M53/f3T9zHtpyj/6FPXqKZUmMLIQTWkUWkUswESnoVzCMkE3dExMuprPihBbWHRpEKuUROS0hEcuCxKRsVIBDXzaoslUrtCNEqSiKTxWZYhpKpQuSStZC76FpKSqi5emI1WFoQyaokEhSgpVEKqUME9qca1hksqMXBagBKauocu3yQUaGqbSr0krAlGHpypJoUpSss1MrEIgycq0JrAgqFA1QUQoDGFg6QZC1LBnhSSUGZVMsDb6Ogfr2knlak4nEBiaTqnq36tQJcVGWnAFVwFo6EhRfd0MGYUStc4wIcNQdQqDvgG9zM0JtaV8qqpiVoSMqoBEgbe1zd6Dj8mFgTAtMhQ7ezXBKU4SlKr9LoPVgtt377COU/Ii5dXzl+zvH7F3sIdlm3zv9Qtevzkli0K+8Y2PWS0C5uvVNRwrNEFWCTAdRFp3xFeQ47tMYQXXHpn6poW7IpYopTaMzTqgt5JXc72axXk1B7zy3pTUNnBs0hgoa99TbUNoUbxlKUdRRDge4/gNltMpB4e7dAZdgjCg3e5sxNEVjt8kjmLavQFJFDGdjDENAz2KuLG7xVf/++9i5CnWbITIM9yytl3TN1D5VWht7fcClaiRAmcjZbEwKClxMIjrI3zDFq7JOxkluqiZx9eie/GWYXy1zSwK/JdfYH37V7BMhamB6Tb48tPP8dtNDo8OGO4eUeSKJFizMpeUWUaj3WGtg2HV6MRwq89qNkNIQRjE2LZNq9nixs072L7DfFb//ovZCKFZFHlFGNQhqt22y3h0zv7+IZrQmM8XNNsdotUS23BZzNbISiPJCvxmhypLmVye0+q0CNdzzmROVYCsSpIopN0x6fR6FFnBzs4OZ6eXuLrO5cU5e0dHaErS9H0uz84xTIsojHG9BhUVz168pt1skSYh773/Ps++eozRavLo0WPuv3efLFhxeOs26yAhT3NkVZElCa7jMB2N2Tk44NmLl+zt7pKmMYulJFjN0BE0m21kXtDb2sPUJZWhMTq7oNHpMp/PcDwf3RD0eh3m0ymFrAjjlF/45H0m0xma24EKVJQxPj1Dt10s10alGXdu32IdxYSrdb2vabJeLlFKMZ1c0m61iOKYGzvb/OF3vsve/gHz2Zw8zamqkqgoaZoOWZaxvb3Nq9d/xP6Nn66X5s98wcu/ek1LN4lEime4lGWBUBWxTHB1G7PUaSufRRHiGrUrfySh0EtsZdFQHgsVsNJCqAQt0SDWEgKVYGs2LeUyr9bYuoWuTJr4JEUKok4UuIr4ySmISGvSh65qDZ7M8KmZhZYyKam3VaoCNDQlSCnRlEGpKQxNp6gybM0gVYJCVpuMu3dMmzf5c2x0cldwaKnqE1JOHSSbUSBVSbWBOzU0NE3D1DRM3cTSTZINnCilQlMCFxv7CpZUtejcRMcWJoUyqURFqvI6+07Up2ld1bCtuiq0iI0wou4yM1FQUGKqupCmKkdWEFcl8yohsXQaN99juHtAsz/AdT1ePH5Eo9nBMC1u3rrJy+fP8TyP1bJ2prcsm16vT7AOefHkC5xGk6wsefPiGb3hgI9/7lvcvHGDTz97xFdPX7B7sMd4MuLDb32TaBWxt7/Lq+cvWW3maD9JCHPFxhTUET9XDg7VRkheSYXcpJ8bG4KEvnFYUe+gfFdzwSvIcxOcUTM2NwXH2LA0xaYjNB2Hg8M9lvMpUmikSUYcRjh+m9Pj17h+Cw2F6wjiKMbV5wwbFul6zOryBKMsefnHaQ3TqhqaNJQApZEIeT1bBHWNFNQdfY0SlKrAU9DUbORmxmujk1BuWMNXxx4USl6TnrjSyWww3HrmvDl+qwp/ckb3vQ+4dec+89mKKJxjGDrHb07Z2dvn6OYOz18kBEFIGCYsrTWtdn9jdqyRxillKWm321ycndFut3n+4hWTyzN2Do7I0wTb8YnWIfuHh6iORbPV4MWzlyxmktUswLZXtHst3EYDy7axXZfhcMh8PidJC9arAMQS3bBod3dJ44SGX8clO7bFyZszTLeFEjpJmpFnFbdvHjC+NGh2esynY5IsZT665Nad+zx99ozucIuT12/wmx5bvQ6D4TbHb86wTZOz4zf4zRZFlrFzsE9SlERpzqMvvyROcyp0dCUJggzT0vBaTXQkZRKTpAm7+/tkWUpVpFQSoiyl02vjNR0cHWarENd10dDIi5T+YJvVek276dFq2ewdHvLi6QsMy2N/2+SLZ2eEwQrXdTFtC9drMDof4TYbRFGOUiXbu9tkac58lXJ5OaE/6LCzu8v2cJv/7X/9Xznb30NJyf27t3l9fsFgZ4uXj7/kzsER6+WCWWAyuhxz4+49nj36OgHyz7p+5gteTEpL+TSVR0KG1DX0SsMVJgpFomUYysPFplIlUpe0lM+sXLHUY7rCo6/aRDIhJMXSMjzlUKqImLhuz3EpVEVM8nbuhaSkJKbAVhbuxrg5lXkd3KoymoZTx/hU1XVmnIVJoYrrRPJE5VQbq7BKAkiyKqekFjVnSBzdYi0TTG0zIZMCsSGr2FiYwsASb6EBIcQGaq1ZmTYVOQWlrMiqEoRGVGYgVK0f1G0sTadUFWmZo6TCEgY2Fpaqg2JNUcslLGFRUJKp2uZLbgg2UDuNCNQmGeKtCfZGFk9SlgRFTozC2Tukd+sXydEwbJ+jGzcYXZ4TyoQbt+7QHwz58ssvef3yBbZlsp4tKNOEIk5peBbPXxzTaDbYObxJt9NmNJnjdof43TadTps/+u73ufPePb784ZdUlcJzPPZ3tvnu8fcxHR3Pc2h0+yzD1TvWYGrTrW4KxUaWUEmJJYzavkl7m9mKEJsg17q3ZUNUuUo2r2HQjRBEKaS8foOupRBsCp7QtKscWKIwoCkEDdcmjDIWixW9fu3OsRwVGDKlGF2QnqSo8QVRmRPKCk1KWtR1py7SG0rJpgO3EZRI8uuQo/p9CzcOPEqBpjb3VQJL1drSROXoQsNWOvkVxUkIzE3hy5A4b6d51+jm1bxYUecFxq9fM1/9vzA/+Jjh3gEHRzdIkoRS1Wnmjx49QijJ1tYuWl7geDaL2Qx1KQnWa1zPo9vt0+11SbOMZrtFs1fh+RZpXKd6aEKA0EnSiqJa02jUUoTtQZ9ouYRKMhtN0WybYDJl//CQ0XTObDLDb3oc3DpiOb2kP9zGNm08r8HZ+SWths3Zm1NuHB1wPqpz4g7v3CRYLlkFIUoVRElAkRfYlovrt6ikot3q0Wm1Wc9m7O/vcnl2ye7BDYQm0EyD87NTfu7nv00WxfS2t3hzfkG31+Hi9Iyd7R2i9ZLeYI+8VCRpgqJiNJ5ydPcuy/UKNJM4Tuht75KEa8oi4cMPHvLdP/ouy1WAbVvcf/CA1WJOo9EmzzPiKKqRoSLnyLWxLZPvfPdT7t7Yx7U0LhczTGOI0HS+9fAun/0wwWu2GF+OEIbF9OKU//v/9D/y+ZdfUcZrpqMc1+vyxy/+mDt3bzHc3ePO4Q7f+f4PKdFwEezsH2Ebin6/S14oUsNgOZvT7ryVpf001s9+wdNSpJS0NQ9POUSVQmoSqQqUklRCUWg5duVQVBDKGEdYNPEIZMJShLVzOy00dCKZoOmClvJrfZhpYlYWljSJyUhFSobAVAaSOkZHahDKFGfTIdlYWORkZY4iR9d08g0rstzMuXJRolW1pZiDi4e3ueqXFKqWDJSqDnqtqgoN6sggXRCQYWm19CERJUiJrepkb0fY2MrEEDr6JorI2ATK5tSSgFJW5KIOgs1kSVTFpELDFDq2Zm5MjanF8TJFk9r17E9DbHIedCoqYpXVPaaoT/hS1MzPanO7UJJlkZFUEuW3aN3/kEpWfPgrv0qRFSRxwvjynNOT17iN1gZyhChaIylYhhEP793h4s0bmq0mRV7xzW99xNOXLyllia4bFEWBjsSzLF4+e8FguM1yvuD16zPiMOD09TFCSU4aLQrqxOX1Yo7u1CQqQ9femb/VM7akqDA1DalqZxoE19KBuphJ5JU/plH3MVcRQNq7BY0NpCnVtXvNVWWopMLmbXSQUopSguV56I7HKkzptxrMTl4TXIQ0yhT91TNKBFpVkCuBgaREYKq37MmrgnMtar8mnAgcDFLyuttEkSNJNrmMhqjnbpaoNZSxLDbQukmuCsyNw09BVUOXqt6/vrB5qw29goQ18Y5ERkFUZsTnL8ldB7/d4fj1MbfvPcA0dKoiZXJxxtF7DwjjNbqts7vVI89T2t0eSgnSKCJ1YyajnCSMmEwm7G4P6bbbiF6Xk9evuTy/II1CZLfPYLjN+ckZYRiRxRG273B4Y4/PPv0My/MIFnN6TQ8NWM0mWM5e7X6jmSRhQkLMbLokLzJ0w8D12wwHHRbjc/xmk8VkQrhckcUZnU6LsswAjfVyCZpOGIVE6wXNVgOUoNfpMj4bMRnPyZKU3f1dVosVqyhnOpqR6yaz8YSHH3xAHK64dXufr75KGOxs8eTxC5pNn+PnT+jt7DJbLFkvZuzu7bGYTrBNizCI6fZ7vHlzhtdqYTc7hOuQKE1xPJeDg30+/fRzDF3n+NkTPv72z/PV0xfEcUS7v0WzN2A2fcrB7TukUchwOOQ7f/wDfM/B0hRpluAIQRjFPH/yFFO3+ejjj5nOptimQjc17HYHv9HgfDJncnnBJ9/+Nqen59w8OmAynXP/3m3+8A//iL2DI4QZ0PT3+L2fYj34mS94nm6TaTmTcsVQ6+DjYFQaEQpH2IQqIRMluZbQo8lKhkR6hqPbtKVPoQrWKqYwSlxpkcqMTBWUStEUPqlMKbQCW1o4ytpo2BSmMLHxyCkIZAQI1irCFJsgUmHjYpGrsqYFk8OGsZlToQuF1OsZXkqOpXSUqsXcaiP8roks2ga0rKGmpMwxhai7DVEXThONVNSTk0yrsISBrkTtxSioGZDYGGh4wr6Gn0pVUVCRqJycvKbJy5JC1K4sShOYhoFEEakMWaZ1kCpmndCOiS5qd5erjq9QtawikRWLIqW0LAqngbN/i8GNW9y4fYuTF0+ZT6b0Bj3SXOfg5k3W80WdjRZFHB0dUVWSht8iDWPCtMBrdbBsixu3d9FtB9dx8Xynhl8aDdZxynodYukmQiq2tvdI84qt3X2qUm4iXBxszUCVGqbtoXl+nV4grpIQNgUPjbq5q91itA38p9TVnK0+9rQNDFnKjfTg6qAU4nqfK1bju+tqdiY2269mXWxmgI5poGmKxfFTqpPnkKdIVbFCYGxs4DRR5yLWc99ahHJVmK9CfTca+E3hqfc30fCUQbZJSbSFhrn53XVqaPOKZ1oKSFSJp1noSkMXAltp1x2x2hS069meUpib5yqlJJMlqywjLAuSsg4dVkLjWwcHtDsdDg5KkBkNR2fQ76Jr0Gm1OX3zCt20OT65QNMMiryG3ZMkRk5zykrhug6mLnh9fMzOzi5lVdEcDqgmU2y7S5anrFcrbMfBsgzC9Rqr4VOhaG/1sX0f09KpygLLcdg53GX38IjZ+JJoucDbcSmzlP0bdzh+fYxl6pyOztAsDcdxuXP3Lt//9HO29/YI1wGGZpJnKXfv3uEH3/0j2r0tev0u/a0+eRKAKrgcT/BaTeJwie87rIOAG7ePsAzFds/n8uKcVr/HKqiT4k9PLjAtBykLoGJ70CZeDcmynDCNuX37NpbjMhjG3Ll9g5PTcypZEUYRq2WEblD7kaIxGl1SIeh0+5SyotluEi7nDHf2kEJx9vIVrzXBYrXi4FaPOFzRbvk8+vIzklYHz/O5ebTP8+fHDA6PAEWj4TIdjTi8eYf5YoHneOiazmeff4GmGdhek+ev3qCZJt/5zh/R7vZIk5R2b5v1eo2uGyzny59qPfiZL3hmYWKZOolVMC2WNEVtvFxVEl3oDLQOIXEdY6MifOEiZEIm0lp7pxx8HAIZYwqDlvDJVUqpS0x0TOUTq4S1irA3rEOpchJSCgpcbPqiTaIydKHVbEqtZFFm1wJtV9h1WvlmXpKonFKWpBuiSypKKk0nqQo8THRNI6M+mViqJpPUAvK6e0S99bnMKShUQSFqEoSSklTLN6LxCkc3KShJZYGlNCqlcLAxrqzDlE5H+Eg8yg1IWaiSSpX1QFsUGJqBYxgYlkYpFVEVYiidBg6mqqFUB5uljFlUGStVYG7vINwmB/c/IA4jOoMBi/mMy4tz/Fa3Tp8uErI0BtvEdWy6vR7z1YqLywmDTovbt29zennBaHxJmCU4ssD1bE4vznFcB1EoDM3gxYuXbG3voCmBaTZBQpwHdchlJrBdl3Ad8fLZIzq9AZUEU1YkRVn7V4qNcbOodXUIMDX9eiRVyRqO3ACX1zOwqpJomrYpbm/F41fyvZqIwrVdmb5JSeAdh3ghQKsr1DXb0bRcirQkDFespiOOGs3rWaLaFLVKyc3srdY2GmibYi2ui9zVuuruUHWRcoVOsfFdhXcK/tuySUn9C1fIWmKj1V2soeloG3JNSlWH3gKJLMmqkqwsCfKcrKrIq+qa4HT1cjQB49GE4U24dfsutqXx2WdfYBsa77//PvduHlBEEcsw4vT0jG6nTZZGJFHKg/ffZzw6pygyLNdF13VKCdPljHgd0Gp22NrZI44C1ssl9+/eYrVYsIgKKqXwmx1GkyWmbpEu16Rpiq7Xs3Gn0SEOI4qi5PDGDTqdDsE6IAxWjM7OuHPrBtb7D1kFEfPVirPxjLKUDLeHTGdjVpHJ5PwMScnu/i6NRpOXj59weHQb04H+oM9osqTXHzAdT2i0Gpy+OWZnf5/R+SkHhzfJzyf079zhcjRGM010w8RWii9++Bles814vmKwt89kNMGxbGbjEQc3biCrlOcvX6AbBqZmoKqCqki4cfMus+kYy7FrecbZKUVZgoJ77z1kdPaG9XKFUCWD7R2KIqc32GV6uSAIUiaLJX/uV/8ffPnlI45fveS9hw/YPTgkCEKCquIbH3+DJIk2x13F3Xs3efbsOa12n9HlJYNhD9c0KKXYaEIbFGXJzuGA8cUFlmVydvzyp1kOfvYLXqoyulUDqSscy2RVRhSyxBQ6KSk6Pm0aJOWMyiwJqpieaJKolLkKUbrEli6WojaLFSUN2WBVhYRmTFUqHEws8dYJwxUOoUqJRFYHloqamOLh1KSOqkCKuhhJAanKsTGoUBuvTHCVg0vtRSqVJFYpaIqMCpON+FxodY4aNQmmrOTGWQXExvHEVXXgax0MW7MBC1lLC2JSqk1qd0aJrtmUSGIt28gHaqd6TWkbK2gDCw0PyOqpH4WqSGVOnNeWXT3Lx9JdwipjXoUYyiAvJOMqItEVtDvc/OQXaOzuM7mYkKQF+4d71/Euy+Wa4Z07aMIkCAKSKGJ+ucLQBGWeMhgOkVWBsAzWUYJpO6xWK7xOl8V4zOnpJXmW0mi3WIxH3L59i1dfPeHg4AjdqPPaTl6/4eDwkMl0xjqMyZYpru8xOn0NhksaB2zt7BJq4hr6E+LtRURVSZShk2+kBqKq53iaptVmz+IdO7KNXkFt2ClXMgRdE0h5ZTH2tourrkXpbLxurhw030Kmw0GHZZFjajanSUTLsmhb1nUxupJOXBU6DXHdbdUSA+16Fnm1vS7I9b016qIXbpiX9d/gbVGCGqoslSIV1RX7BHNT9BS1tnJdpCyLjLgsiMtyI+t46w/67uNdlfhKqTpJXpWcX16QZxmG0+CLL5+wv7vFcr1mPDrn27/w83xWFZiWzWI6ptXpkUtJlhcYuk6SFHTa7c2sDAJnSafVwDA0DMPC8TqEcYrbbHC5WrF1sM9itkDXBMFywZ/7c79MEq75/IvndJod1ss1k2CN6Vgc3Dji9as3eL7HjaMdnj81OZ+MiNchnufR7Q9ZB2s8zyVLMpqeD7rAaTXpD4ecnpzhtkwMy2SxmpEXFVtbO+iaYDab1fOzNAGlMEwTp9FhMpuzmk9ZTGa1c8nBHuPzS3qdDo5ts7e/x+PPv6Td75NGS5qNfU6OpxheG1lVeG6DLM84Pz3BbjQxLAupNKLVqpY0LFcMtnY4PX7F0a17jC7P8VuD+piXFb7vEKxymq0GabDk7v33SKKA50+egpR845sfc3E5Ik9yknCF5w64vDzHdy3KovZ0ffb0GegGYbjm1u0bLGZTmv0uZ2cXDLaGrBZLGv0hXz56jGc7ZHnO0d17/OR8nP+29TNf8KQpCaqEZuWSyIyG5ZIUKakCpSQFaxrKoydazKsAgSQiwcelgyQixbHAyR3SIiMWKbYwaIsGSZVSkZGKHB1BpaDQKgxl0sDHVjkxGZkokEKilTWbzBMuhtBqNiOKXBRkqkAJCMgQaFiU2Mq49r9siwag3soNhCCWGZnKr09ilVYnLhhCQ9Y0g5pQoDSErCkKBjXZxEDHw6VQRc2uJKesanF7VVW1NhCJp9uUomJartHQcZSJh12TbDCpkJjSIBMZiJJFHmLrJoVSzPOESEkqp4G//wG37t8nSXPuPnyPl6/e0G73mE0vMT0PwzYwDYvJaEIZx6RZQSUMPMcmWdfu/kVRkZVl7X+6/QEXlxMQkKwCdrZ3MAc7WKZPGIWEUUQQBVxcjugM+oBCsyzmywDd8VksQlaLgO6wQ7Ba0XBt1q5LsJgjVUkcJcTZZvIk6mJwpbWTG/uvtKywDf0agoQNCUW97d5qgTnXyefXHZ18B+Jk425z5csp3kKN7w77rqQJi+Uafe+Q7rDPCxSvwjUfdPuYG32lUGKjibx6vM3MbAMrXskb1DuP+y6hRAJS1Ai7vnmcq2J5ZWhdE0AkxYbgUpWStVKs8pSkLEmqgkoqymsAVPBWsPL13/stuAp+u0tva4eLkxMqJN1uH01o/NIv/TxPnz6lmMwopOTxsxdICfFqzc7eTUCwnC+wPZ/F+JLDG7d5+eoUr+mjoXAch/OTU3TDxPN8tne2OR8vqIBoPufenbuUaU6306bMU47fnFKkCbt7Q7Z3+mBrHBzt8+bFa778/Cta3TaVVJydXpKmKZfnZwx39yjSBMM0aPgN/K1tvvriM0zbo9tpsbuzjxAmjUaLsigxbZ+qAsPQWSynGKaFrCpM3cKybPI0YnJxSqM7wDR0tvcPSMIVqihxDAuE4HI6x3c9Ws0GvWEfy9Bo7OyzXNcF7Fsf3ufzR4pev8fjz76PLgx8t4EsK4IwoNnfokhjWu0G8+kSt9Gm020Th0vKqiLLMm7c2MWwDNarJafnp4SrOXFZ4rse/cGA2XRGWlR4fgPLLImyHMNy+eyr5wx6PS4vLrj3wQdUZcU3P/qQP/yD32dtCBzHQhgWSjNotDrEccp8NkOWJZqnc3Fxzpb47yjx/P8flisdMj1nTYyHg5kb+LpD1/QRmk5KwZyQCoklDQSKXC8JRYIlLDSpkasczYSm8DCVRiJS1iradHM2TeXRpY2FiVCCXCuIRIIhdHqiiS1Nyqoi1XJSLSMWCTm1WbOOTpsGfdGmoVwaykFXkJIzI2AlImasmakVkUpJVFp3d0qnhc9QddihS0f6uNJCSEVaFWRVQSkLckoyraQwK7Ags3JiM2WuB8RagqZpuDh0aNITTQa02RE9GsqjoWzKqiQuU5SoHVViPWdlRMy0OstOorCw8PHQKp2kLHkVrXiZRlR7B7z/v/wGnY9+kb33v0GRFQy7LXzfoygrGp6H77dYLlZcnF3guy5C6OSl4PL8lCxeIqWk0x1w49ZdTMNkPB7jNVtURU671cIyTLZ3jggWazzfw20ZXJ6+YDmd4vkNTMfivQ8/oOG6iEoxny2oioLp6JQH79/DNHT6gz5JHHHr7ns0mi1s16fICxq9nWt2pHzXzxIoNgGviqsZXN35yStZwhX1/qr6wXUb927u3Wbwt5EzbPq5d3R+6orVsZkPKqUIophnz58zuhwBkFYl4zSuS8+ma6uF/RrGFZtSaugb5m5tb3fFxORr/VZtLiDriCqhU2dycw1NCgS5kiRlwTrNuAwjnq7mPFrNeLyaMUoigiKj3GgLr6BbfqzUvbvlHQjXMBnsbrGzu1N7a9oWpqGzWCeUEm7cOqI7GKBkhaZp9LaGbG33WC+nrJYLKiXYPrzBdD7FMBXtVoOL4+fIqqDR6rC7v48SkvPT11Txmk7Tp9luE2cJl5uUAa/RxHJdSgW6qfP4yVO++uxLRuMZQtfRUTiGRVEqsixjsLOD6/lowmA+mzEaLQijDKkJ+oM+D9+/z2oxJY6WvHz5jCxLKfMMzTBI4oiDvX2qLMX3fcJgjWGbxEnCzdt3aoRFM0BKdg/2ySvFvffu8+LpM5bzJcl6iVQan/7gh1RSMplM8TyHMq+JKD/44WdoQrBarWl2t3Adk4O9HaIoYjUd4zkO4XrJraN9NL2OJ3pz/JqtrS08R2Nrb5snX36JZZi4jkun2cL3m6RJhO25rMOIRrvN8fOn2LbNaDzGNA0u37yi6TdZrdcc3r7HbDzCsF1O3xzT6fWYzWZYloVpmfT6PVaLGaZhkMQJu7s7qCrl1q0jgtl/h04r/79cqpK0NI9Yz1hWAQ08zMKhEiUd3SMVJhJJIlOKQqJJQV7lmIZBXOa0VIO4iFkbEaZm0JXNWp9GCWiUUpKLklileBulWlplBCJGigoHC10ZdIRDqJJrgklAjK4JEDm2ZmFUOjYmrrIpNtOyiIRKyDqnS5TX18eJKNBUtiEjCFxlY6DTpVnPjpAgJKnMr703czJKUQuzNU3D0nWUkBSiICsL8qpAyjoSqCm82lpMGehoFBTEKiOnohAVqVbSMFwUinUZo0qNSRYQGQqabfY++CZhXuF2umhuE7+V0d8eMDov2Nk75IvPn9JsNIiTiHanh5QZWrfDaLnm/sMPOD094+D2HeaTS45u3kLTLMo8pT/oMPr8DVsPPyCMI5IgoigqWt02jtvl9as3NGcWn3z7l1kuVozGE4qiprE//uoJjYZLsJiy8/4HuJZJFIY8++ILmt0+ZZHTbNfxOIZpMVteImReFxClrjQVtaRjox94t45ddW6a0NA0ea3BE1cFTr1NPn87tVKbQFg2gv26oFwRX9SGKVlJEHqdiyeVpN/vsljWrLer13EeRzQtG0vXrqklxuZ69mo2fFXUpKrhzqtU+ysIFTa+qxuxebmBwNcqJ61KlmU9g0vKklJKULW85C3k+S5I+SOfQ66IMj9e+N7+HHTDJAgTgiinrCqiJOPs+A3T+QLLgK8eP8P2GlyenFLlGcLQqGZzMHRark+lJKOLMbbl1JAxmxQMJen06tmw7Tbo9nqYho3tOMTrJcvlmqzIsUwdXRPkec5yuUQ3TdK0vrjSEJi2Q7PVYjYeoxsGYZays7vDcHuL8WjKR9/6eYIoYT5dkCU5o7MzBv0+rW4XWZTIIqe1vcfLly9o9euk8SCsRfTtTpv5ZAKy4vz4Fe+9/wCUouFYfPnZpziNFkrCwd6QJ599yt1793n55Esavsd8fFEnL+Q5SVbQ3xrSH/a5ODunYRm8fPIIr9VltVqxX+Q0ux2SIKSSkuVyhW6YtFst8prHRq4E56MxR0c+O/uHPPryMbqAJM1wPY8kDui2HOKsHrlkaQZIbt+5SSUV1XBAlmWIVNLrNJmcv2YdJqyWgvcfvIfCZHdvlyRO61noeo2uCVxT49bhLo+/WmJogla7/X/1VP9/af3MF7xYzxjINr4OiZEzKVYMRAtTmaiy/sBKrUTTTQqrIitzQJFVGY7uUJQlHVpMywW5AYoUXWlYwsTaWCytVUxBQSISbGXTEA4GGpFMKLSSSlOUlBtXERN9k4KQy4KYDKUyNE1HygpLvRV290X9ZiuhNmzJjEqUNcYvKrLNSbQUso4GEia2uipUFrawN0SKK62XJFMFmawZkzE5pZA4monQBIZWRwaFpMiqBqGsjXlzC5NCVeSqIFU5qzIiqSSRrEgFdO8/4N773yCpFH7LZ/T5D7j90Qc03Aaj8YgkT1gvZ8TpHoZtECcRZZLT7QryIsXxPcJ1iG15eM0GluMhDJ8sLVkuZhzdvkGVFzQ7A7a2tnn0xRf4ns86XOHlNuP5jFbLZ3p5RqvdYrGYY9k2eZZydnlJb9hFE+A328ynY4okwjQNbNel3W7x5tUrsiRB5immZZNUBa7vkf7ISfzdPMYrn8uiqpAbdkup5LUVWc2UFNfsTXXNVHkLjb4tgPWSSm0MpbnWaEsUSonr4qgpxa/8uV9m9PoZr3/wn4Ha4PpVsKLf9PE0HQuBI3QktVhcQ13r7QyhgVLkSmKKml357lJSElQVYZmzzDNiWRLLcpO7+Pb1XsFD75JvrkzJQV1Dqlc/e7fUX916K4yovw7vPsCxPYTQCYOQdrNJtbOD55ogK05evEToBpqSNJpNdDTyJMH3HUxN4FkuaRTTGrQRa50kjun0tjEtj+nlCCU04iBAtyyarRa2IWg1m0RlRae3xTrNiZIIZEG/16HTalJmGVGakichaZqxdfMGWcNDGgZplnF5MWI6GaObNo1Oh/HlJXEQIagwLYd202c1vaDdamGbJnGWsLWzzXh0QbPTJ68y0rRgMZng2iYfPbhHuFzQ8DzSVoMqj7j/4D7PHz3i1r37HL8+YffwiDKN6PeHhIsZD95/yO7+Nk8fP6XV8FgsFywmYzrNJnEQ4jc79Ac9DEPniy++4PDWnY07i81w74AgjDFsG1PTGHQbzOZLbt++zasXLzi4eZN2rwsShFjQ7nRoNRsYVoOupzMbXaKZFuenpxzevM2bZ8/p9bcYXVxy795Nnj59gt/qIJVk7/AmL18foxsWRZwymczI8opwvaTR8Dm8dY/lOqRUFZPZHKqfLgj5Mw9pIiEgRqt0XOXSMG0CEbNSASW16bEnPYyyFlErQQ1LypK0zEi1uji0RQNK6m6HhISURNVemi3h06C+ugyJWBIhJXRpY0oDTdYElTkBa6KaLKIkFhYD0cGTDpR1PEokUnKjJNBjJqxYq4hMlSglaOHTVS06qslAtejSwK5J45v5X0IoEpZawFysmYs1gUiISckpMIRBU3h0adGnTZcGbeVhVTqiUhQyJ9sI40tNIkxBZUtiM2NFREZBVknGWcJFnhO222z90q/R/Pj/hn14n0WcYTsOUkqObt9nPZsThWva3R7ROmC4s1N7kbo+w+E2k9E5QZww3NlmtVojS8lqMqbXbCI2V9umZVPkKVmWM724ZG97m+PnxyRxRhInZHGM12igGwbD7S3623vM5ktuHB2x3W/T8CxkWXD88hWqKGj4LtOLEWGYcn45QRg2J8evMGybIC3J84w0CRC6jtAMpG5dSwoUXHdiXDEWBRt2Zf3/lXOIlIqyktcw5xXbU6ma4HLVxV1JF678Na87wh9ZV+QVzWmgNQecXlwyms2+tk9SFIRZjgAcoV/LAeDK1/NtedEQGAhyVVFIyaJIOU9CnqznfLac8ng9400csC4zkqq8zur70bnju3PAd797d7+rp32XVPPj96tf1yquY2oankMaBlycX2A4DobpYBgmlunUonfLYe/wiE6nhalJkjghCDK6rQ6e61BkOVGwJs0SbEvDMHWSLANNJ01jGp7L/t4+l6MRk+UCmSfouiJcBAjhEEQJRVUxHV2QpSnz6ZQkr4/JtMgxXRdZFLTbTbZ2tmsZhGGwmk+psoThdp8iiXEci1UUsHd4yMtXr4nilCSMqYoC37botVu1fZnrs45jGt0e56MJDz78kLKS7B8e4ToOZSVxfZ/OYMD52VlN1goiWv0BFRpBkvL4yXPW67AmcflN3pxccnxyQRAm7N64ydnZKY7vE60XpOsl3/jgIaOLS/xmm88//Yx+r81icsFqtWa9WlIVGYOtLZSC9XKJ1+mSlrC7v0+YZugavHz2jMFwi4+/+QlSCvqtJromiNMYx/WZTBbkSUIcx0RRgmXZmKaNlJLPHz2tHWuaPp/8/M+hkKRpzMtXr9nbP2S1XNPwf7ol6me+w3OwsAyNVRXSrOpcukIviPWCeRVgqZq8oSsNs7oShdc2WYlK0YVBaVbIQtLC20BbkkTkRCpF03QimeJhY4gGsYrr9HOtdlpxlY0nbEpV1Sw8IUlFQYnExazhU2HQEy0qVZGqgqIsMYRGLkoWKqap1SfIWgahUyLxhYutLJqqhhZTlZOJ/Hpukos6nSGjxNJ1SqVYEmEoHVtYNW1F6bSFU1PrN6L3UlW1CF5VRLKsT+ZKZyVTVlVB5Tjo7W3273+I2+ry8IP3+d73P6VSirLMEYaBaZtoKJbrECdJUGWOZpo4nsfxy6f0trbJgoiHn3yL58+ec+PuDZrNFgf7e3z63e9y8+Y+q6Cg2Wlx/PoFjUabN69ecnTzEFvT0F2LVBVolaS3vYfCwG93WazW7OzvIITB8atXVHnK3tEN0jil0WyRVYLR+SWyLDg4PGI8vsT1XIJFjtfqMr14w97+Hr3+gK8eP6asNNh0vai6ywKuO7ZiA21eiamlYmPofXWSrzV7CjZF7oqM8nZGJ6ndS2oGbc2MfXfsVyqFEjo0B5j7D5grH7+zT7GckcXxjx3vSZpj2C6WoZNvLOquyCJqA0FmVUUqS9Z5xrLMkLI2In9LHXlnqR/f9m7h+gm7X3drb7u9zeO8U8d/9P7XFw+WTW9rl1avz/buHq7vEccJYVkRhWtu3L3DYjKmkjrLZYiqyjpr7vKS4c4NLscTFosZrcEQTdNptTtMLi7QxJzdvX26/QHxak6j4eJ4Dl67i+26xFHA7u4uWZhycXlGs91DKsF8OmNnZ4etrSF2q0+8Xtaze8ug6/W4GM+ZTcd8+OED3pxckqUlk9EFve0dHn70Pt//7p9wejJGVWVtw6bphLMx9x7cZ2VqtJs+aRRy42iPH/zgT9B7A54/e4lCIquCTz75EFVmyKLWGnabDZ6mKWEQslyu8RtNhKbTcD2yJICGz8vnL/joG9+k5XkYjs/F8SuUYZMX9Xnl4Ogmtu8ync7xW21sXcN2XS5HU+7ce4/R5QWDXpeXz17gtlrs+T6a0KmSBEMDTRZ4lsVyuaA/7HP8+hWdfp/FdMzTrx5hmSZJFJHnBXGQcP/hA14fn/Lee+/xxQ//BMMwamG5LJnPlzSbTc5OTujv7lFUJcv5nHPDYDjsopk/Hur9Z1k/8wUvJWMgB8RaTqAi3MrBrWxszSI365ieVRGipMITDgY6qcpoi0ZtBValFKogEllNE1Y1yaMrWhgIgirBNxxKckRl0BYtbJWxVhGVDpmWUyodT9kMRIdU5cQqqb0sNYluCFJZ5785WHiiFrArVScTmNThqCWSQlSYmoGmBCsRUVUSGwND6bWLi7KuPSpLSnIKUgpyWTM2tY0QPacklxWW0HCwahNpjGsXGE8pElUwK0POyzWFruNu7fD+z/0yotUjyVKC5RLHdXn2/BUPPnzI6+NjHMsjiiPaTQ+74TCZLVnHMWWZc/vwgNHZCdtbQ5I0Jk0yGu02ju9xdn6Bresslwu8ps9kMmexWtLtDynLit6gz2JpcDmdMz454Vs//y1c06aQEa3ugDBcIYtambic5pyfnuN6LovpGKkEulEH0rx6+iWt3ja+51MqSRLHmKaF5zcp8xLdsBmNRkRJRp4n6KZdi8SvTtbXQvArssqVjEBSSoVhiLfFbAMfllKSlRVhWrw9KMVVYgLvzO7qVcma7KJrtQCvtJpUNz+ie/djhGYSv3rNyxcv8R0Lv9H6seM9rypGUYzfrPWPBRVlpVhWGXlZsSpy8g08KRTX6QbvFuFryFF9/fa76yfBke9+yR/Z97803vua1MEwsTyf+eQSpUo00yDKszr/Lq/YHvbptjzSyCaOMyy7Pnb3ukOW4xF5FlAVIe998AFFVWHqJnfu3oSqQjdM4iRDzRdsHeyB6fHF05ekcUqvNyBaraiqinW4ZHt3D03XaXU6CE2n3evRqEo6bZ+TsiCJQhazMR99/DHp+YjFcoXherTbbWbTKWm0JlwHfHo5Yntnh/5wh8dffUmj2cZzXczhNq1Wi9PTC7Z2LSzHIY7W5FEAUuI3PPYPDzh+9YrzNyfEcczu7i7W4RHPX75BKBiPz9ndPyCJAlq+z3w2IS9zirSg0+nw5Ref4TbbHHV9tgff4tGXXyJ0jclkQn+rz3KxwHE84mBF5Fj1MaAE0/mK+XLN4eFNGkFIa9BjtVhx+/59JqMLDg52+ePvfcov/8ov8+jzz2n3eqRZjuX4bO8d8PDjDzg+OUEsVjS79fOcXszYP7rJOoq4fes2e/u7XI7mXI4WoAQH+9u8Ok7xGh2CZc0OTaOAznCLYLX4yQfOf+P6mS94UoO1TGiLBrmek5CRlTltfOzcwtCNOofNgEimqKpmTq5kREvzaAifQhaAICKhFJJYZCgFDXx0TNZlSK5rtEyPKE9whUMPjUyWxCJD02p3EiHB3zAir5xRYpkigUqU6IYgUBIpJbYyNvKGBqia6pJuJAhSVBRKIjWFptc2T9XmtV/FFzm1iyaeqmd3CSmFqC2iclFibCjshajIRIXSJfMiREnIC8lMZRSGQePmfXbv3OPOg/fRdZ0//u6fsH/zkKosqSqNIFiypwRZEOP3fExDZxUmpOGadreDKhU7wyGTs0t2hjtYliAqSlbrhDjLEQji5YLC0AmCAN9z0HQD23bqIiYVpu2Q5RNQFQc7+5y8OEMpgWkbTC/HtDsNVkGCbdmkYUKz0UU3NPK8olKC0etXOK4PhkkSp2RJiuPY2F6DJKtwbJ80DWj4LkVpsZxOObpxhyzLWCt1jcm9wyXcwI81CQghkEq+bWGUIq8kizgjLyWuodO2TZKiJNlUOSE2xU2B2ATEiutj1kB1t8ntDu7OEZN1yPz5K7a3t9jeGiA1WK1DyiL/CUe8YpYl2Lq+cTOp/VEltQH4legd9fUu63rO9g4TR1zffheAFF8rdLzz/buzuR/77r9QOd81mRFC0PA9krwkTRNMS4eipNPr8fyrp3R6A06OT+kOBgwGFkma1fKcdYRuWDTbLYIwwvc9zk9PyfOM8WhKUZV4jSanr1/Q6fVpdzps7fRYzmY0nAYN10IOtzCEjlaVSFlnR1ZlSRQl+H5GmqQIYRIs5tx/7x5pHDGaLijLklanx+mbEULTaHWHfONbP4/u+hRFRaPToShyqqrC73RJ06R+fecXFHlGGEWMRmNW6wjDMgiiFaZjM5lOiMKIxTTiwcOHREnEcOeQ45MztvYOWcwu8RyTIlF0Bj1Wr14jNA1VlRzevFWzJR2H0+PX3Lx9l62tAcP9A148foqmm5RFzt2H9/nudycUmsk6DOkNtzBNkyxNybKUNC049Bt8+foEYRjEQUCzdZPOoM/Ll68wTAtkLUe4PHnJ7t4BXz56TFGW6CgarsN6IWn4PhqQxQGFYfLs1TGWYbBYLPBbLZ49/gq3O2S9WKKJCtfz2b5xh1sHfR4/Ln/8oPkzrJ/5gucpi8IoKKsCv/QwdI2pEVLINQ1Vd3tNPCqlsEyDQqtIq5xIpqCgpTwsYWFh4WCxJESJWm+3LAN6WhtT6SzLgEimmKZFKCO0UqMhXGxVpw4k5OiaRigSsqrAEw5NPBzh1AQSlVCUFZko8YxaAB7kAfbGSswWVp2CANSEgDpnLykzcrH5gGpgayahTIhVRqHK2oJMmTSEd326qjYFtNrQ0wOVMMozgqqgMi2233+PjtfDH+7SH/SYXp7z/OUrDMPG9nxkpfH+g/eohMFgt0OSxei6iecaJJvZR6c7gCqjpEDJkuViikCSFim3794mjjOefP4573/8Td68fMpw7y7L1Rq/20OWkq7Z4fL0lMPdHV48foLjNji8dUCZ5QSrNVEY4DRaWK5kb3ebIks3MTtguQ5pvOajb/8CaZKzt73NOohYzOdUeYHUBWmmWM8ntHtbVGgYloum1TWrORyyDmPyaEml2VxHDm+gx+uuTLsShNcszKs5V6kUQVYwsF1ankmYFqyymgwFb8ku1w+7IakIx8Po7XMhm1S2j2UYeI0OSSqx3AaXFxfs7g7xOy2iuI6qgR+tI3X/eZlEWFrtYfkudqjeKWjvFpsfX2/hSHVdCX+E3EINll7ZlH2t4P2EAvcTmzzxFv7UDBNhOfQatUdmpiAKE9q9Pr2tIYUsiZKUdgUXZxe02k3COObi7JROb4tms8d0vubFyxMsUWsko3ANUjIe1+4klmMhq5IXT59j2xqd3jbPn3yFZti4jRam3WSwPSQOQgxdQ1OK+XRGUeTISlIUOZejGa7XZDFb0Gm2SNYhSHjz8imtTpubd+4yGl9i6JDHIUUpMUyTKkvp+g4l0N3a5nI05dnjJ/QHA0bnp7z34AFe02cdZ6zmc957+BHrYMnD9x/w3e9+l9OzC+JwTRzW2XST0ZiiKNjd3uHF0+c4jstga0Cr3eT4zRsM00ZWijAKKaXE1TcmFuuI4e4Bl/M1nd6Q+XRKuzfEMnR0IXh49w4HhzcwkMyXCw4Pjzg9P6PZbnP86iXtbp8yTzm6ecQPv/ddvvntn+f3/+P/zt1791kuV2RFwXo6RrNsbM8higPyPCdNchptm9VijefauI7Nwd4OL58+JsoqDMsiXi9wXI88S/nq2es/deD3f239zBc8pTSauIy1BUWlaFU+fdEi1lNClZJUOS08TGkgckGppTRMdyMszpnIFb5y8UXdM7VpsJBrclHgmCbzak0bj65o1nBlkaIbOoYlCKoYU9ZxPR51+nhChhSKQq9YEmJWdaRPS/gAZLIgzXNyCoSoZ3GFlMTkWBiAQlM6beFjbBiUUtYJBDEZUtZhrLqmU2oSXROEVUomizqyRwmc2uWyhr/KmKWWo3cHDO89xGgPuffgAV9+9hm3798hjmI006SSisU6wLItXFun1+/z+//HH7K9v8fl2SmNZp+zszG9QYf1ckUUBlyevKLb7WOaJs1ui0a7ST6TXJzPWM6n9AZDVAnNVgeloIwzVKWTZjFVmtIdblEpies3mFycoemSeL2k2++Bkswml4DANXUM08J2PE5PzqnCmPn4gqSoXSIOD/aYjo4RaISrgP7eTfIyobOzS8tvIKscy3SYT6d1jlqjQZ7klGnI1uEN5o/HGxbm1cm8Nnt+q6dTlLL2idQQ2IbOfscnKyVBknNV3tTXBOp1oawqSeU24OhDug8+Zv/wCOPFG0ajKUVRECcJu/tb9AZbnB8fs16taPaHHGzvcLqavn2sn3js/4SK9g40+27wkRBs8vg2O12P3tTX9ryCK9/eFl/bdlW82CRiXLM3f9L8Tr1jII3C721x8/4DVFny8vkLJqMRna0dkmBNmoY0VJMkiRhdXhKFAfs3D0iLgsHOPnmWEqUxR4cH3D7a5/mzV3SGHZ4/eYymm7heE8e2yfIYITRs06I92MY2dTzPY3Q5Qjcstne2mU2nyLIgSQK6gy4yz/BbOxRFRqt1hKHrFFKn1Wqxv7fFk6+eIWVKHC3ZPtxndDkmjmMODg84PX5NqzegyFNWa8UqAITGapkgq5Kd3QMsSwchGO5s8+zLL2j3t4iDgLwqmU5n/PCr54ync37+W9/kxXHJaDyjbTe4PHvF/fc/4PGTF6Rpxs7BDcZnJ9i2i2WajM7P2N7ZQlUFe4c7xGnCrZv7vDk+x7F1jk+P6feG+JZOt9dhvlwx7HV5+eoF48mMMFzy3vsPSUqN7NkT9g/2WWYpnmtzHoRcTGZ0hzvESYZpm1xeXBAGa1q9Ph89fB80nbOLKXEYounQ7nbY2R4iqoogCtne2UYIncNb79FqmLRabV48f8ntO3d59PgZll1fuP401898wQu1mLb0aAqX3KjndV29QUv6xEaKNCSzPMBRFj4OfuVQyYpSl7RsD6UgKhOKqqCJj4NFnxZzGZCKAte0WRQhTeXSwMXCJChiEpGhaxqVUcf5uKpOSnCERapy8qqgFBWFXpKponZAURtvTRxsVePqBSUGFZWoUEiUEFSiZCyXXLnb1z6IYkO4qUNhC1nP8FSlNoWzrPP0qJjmC4I8pzAMth9+wMcffMIizmkPupy8OubN6SmdwYAsjijThKOjGyRpRlVVnJ6eMJ8vyOKQbq+D67g0m0229vq8eX1KKRVpkuC6NkIohKHRajc5un2D//x736Hd6TGfz3nvvfeIo4TL80t6/R5xEGE5DicnJ1Rlyu6wS6/fI1iteHB3l5sHQ96cjylUzZ4MgzXNXp/VfMFsPKdSFZPLS0zHY3x+SqMzwNB1xtNzKplhmg5C0zF9kKpClRWNXo80z8nWAZpuEIURzaaPNCzKvEQYOnZvC81ykGnyNXqhApKsQDkGEjBEfaqvZM22TcrNjkJ8LeBVbdgbmqajd7Yo3QEL5VEZHR7u7PFH3/kjdnZ2abcbjC7HLJYxmmUxefIMXdPY2r3JyfMX7O5sYxg/6eP7kwDFd76/ppp+vYhdNYLX5Vhc/Vd/83VW5Y+X2Npv82of9bXuUakNHXxTTK/hTfF1xmYSx+RJhmnbOJ6Hbgha3QZpnrF3sI+UgkazxdGNm5y8ecWr49eEqzqYNU9jlvM5H37jE84vJiRZRkszcfwWjqkz2Nriqy8foWRFr7PN6ZuX2H6T89MJnX4fp93BNR3GozEN32Wwvc348gxdScbjEQdHhzx9fIHruTx7/Biv1cV1fNyGRxCtePjRx1ycnNBrN3n16g1JFLFstgjDiGa3x/bOFlVZIHSN09evGLz/CUG4QulwenbK4dENxpMlQZRh+hlpFJKFS9IkwjQttnb2OJ8ssJsdvChFljm37r+H0DWaDRvLMtjqtZGl5PGjz/CbHWzPJ68Uh8MBzVaLT7/3x9y894BwNcOyLTzXZ7C1zXgyI05SJudnADR7A5qOie/bjC5HmG4DXa8T4rf2Dnj9/DGHt+7y4ulXfPCNb7Jcr+gOtlFCo9lqoyrJH/7B77N/8y6X5yN2dvcwDMV0MgZVYDg+R1tb2IbGfLkkKySPH71i7+AQw3BxbYckWGGYJpPR+Ccc4//t62e+4JmazrRc0hIemgaZXbEsI3zp4BYWmV7QsF2iMiUvCzo0MDBwKp2oShAWNE2HQq9IqoSk1GgKlyYucVU7nwihEWgJhSpxpU1XNGvhuEwpN5ZhirojMFSd7t0RTSoq1lVERoUUioSsJg8ocISJhoajLBroNQuSsiYhqJJU5JRIUk2gK3FtFJzJAhMDU+m0sFAKUlkQyJSRDFnJAqPZxr/zHrfuPiQMYjSrSTa/QKBhmTpN32W9XHBysqpthzo9ZCXp9rqossR0G0RJwNb2FnGaUlYK3dBxXQvNMGj1+yTRGttrYvkuk9kYJTSqovbiWy3GrIMVVQFVVTKZjMnTlE63z/7ugJevjklKwYtXr3BMk/FiRa/bQVMFCI3FYs2t9z4gLwqSJAfTIY0iykrxwf37ZHnJ4c2bHL9+TXe4RRKu6fa3SIOITrdTs0YtC13oRKs1uu4QhiG97T36gz5ZVhBaAUGgoTlNGvd+gejln1DE6+vO7EqqIKilBWrjlCI3BUWIq++vIMu6nVEIjP4h2s5d9PYW/V6P+NkrBDonb85ZLQM03cVxPCxT4NguaZiQJDHD/V3SLMVwPE5GE6J3XCje9mzX6YN8HTjl663VjwKhG2hx08h+7cfvoKA/dvtHR39viTj1A111jddd4I9U4Xdvml4LgcS2NIIwQjNd4nUEVcH/m73/epIsPdM8sd/R0o9rGVqlzpKoAtDdaLSYWY7Ynb1YCqMZeUWjGf87Gs245Axndna7gQYaDZROnRGRoTzCtT5a8cIzq7IEegw9cwXrz8wz3MM/P8er7IvznPf9HrF5+y79/gDbWbOZc0A3TJbzBZqhU21UmQ966KrA82enWIbFoHvNbDKmVqsRRyHecsbO7fsEUUQQxiRJTDCfIJUcoiQnFSI2OnUsy2I4GiPIGvVmjeFwiuf7qKaJYRi0Oi0qtTq9myFLP0KzivT6Q8r1JmKa02g0WCyX1Os1yBO85YxSuYplV/C9kFa7g2kpFGwTRZQwdR039CjWahSrVSRRot5skmYpJcfh5uKM5uY2abRiq9GkqEt4vs904ZKEAX7PRdYduv0RtVqZrd1dtnd2efHyJXEY8+WXjym32iyDlPnCY2N7B1nVyPMCr05fYlgOw/ECp1Zm3OvS6HSQFYViqcDp6QVJ7lOt1dlob7JYuhRKZexCgUKxynQ8Y+l5CFnKfqPBfOmxWEx558F9wjhBl2G1WqAbGov5EkmQqVRMlosluWWxWgW4rstyvsBrpORxxKdffo6sq4h5TK1W+z1X9n/a+KPX4dm5iahKeEKIlmsYqYIki8zFtZ2YkWoYsYwta2iazITFGsQAK9cxYx0i1tE5mo6gwjRfkOYpSi4jpxJiBnEesyLAlXxcIUBEpIRNKXdQM5Usz0lIiaSUTM1ZCR5ZnlPAooKNnRtorzP0YjElkGJiJWElB6yEgIAQERErNyjlBUpZgUKmo6YCcR4TZiGJkCLIArmaEyoJw3xJN5nxLBjQNwTS9gZ5Z4/dv/g3/Px//J9Ic4HW5hbjwQ2GoeHN55imRYZIe2OTH73/DqZpEccxQh7jODr1VhNDEQi9FZIkMZ/NqTaanL3qUirXmNxcIssysm5SKpXx5yuKlRqj0YRSwUCVBNpbu5imyc7uJrfv3iHPBKrVCnv7W+xsb7C3u8NPPn6PjU4bWTOZz128KKe9ucPO5gaTwYCrixuOHz9CkyTyNGU+7hGFISenZ9xcvOLlk2e4iyWappOnCXmSYNgWgiQym4yxDJXZ6IbF6IbAX5GmEYIgslqsiHyX4c05oe8y7l0TCxrGzjtr37/XsoM3ovEky16nJaxNj5PXpc3XAnJeC8cVg/K9n2A8+Cu0O3/GyE8RJIHZbIZVdJAUjSDMMZ0ymZgRJxFFp8jt27dwbJ1Wq0GzXuH67BXVSoVOu03sha9X+Xcg6Qdokd9mVH47nugNYOU/CHbfb4u+HS305nz565lfH/e7aPj62MJbqPma7/P1744ePuD8+Bn9ywsqRYeSY6GQYqoqYeBxdX7CajFlNp2Sv3ZzTZO1ibpp21iOg2PrKIqKalksl0uKxRLXV1cMxwuqrU2Kjs1iNuDe/VtomoygaJydXXB1cU4UpyymMxr1Gu1Wk/l0yvHpBWma8vzRYyzDYLlaEYYpmuGQCxn9iwsE1oxf3/WYLpZEWY4fRlycnRP7PpPRGBGBwPfQDA2rUMaQVdI04eLsmFqtvvYinS3oX12wv9NAJsXQTerVCqqU41gavctLhsMxr05OCYKI1XxGySkxGQyxtJwkCfni8y8YDIacvTohTVNqtQrFYpnRTY9yvYG3mnN464B+7xrd1FBlCdO2EQWZZq1JmiQouoG3WlFvVAmTEEWFJA64vDijVHTwPY/ry0uSOGK5XKFI67DqR89fMvN8XC9gEQi4Xkij0WQ2Wv9tlhyb+/dukYQBWZzgegFRELDVavCXf/nnKKS8+959VsslhmYR+iEbnY3/0iX+Dxp/9IAXJwliBigC88xDzzTEREBTVEb5Ym0Rloqo0dqlxDFMFqK/BjVhHfuiZzpKpOIGIaIgYpoGgZIQka4vEimIyToM1MsjchlWcsASHwEBCwMLAzWTCZMIPw3IJPCUkKXkE4kJMhIONuXcwchUyMFPIuI8JZTjr8XoS8HFJ0IRFIqCTYkCxcxCy9d+nV4SMg5WXHozrvIAr1VB3D1i+8/+NaW7P+Lwwz9BknT6/TFLzyWREzTHpL3VIkoSBFSiMMZxHL784gmKauMuFkRRzMnLM1aLBd3La0rVFsPegEa9RhqF7GxvUHIsWu02SeixXM5pd1oYukm1VCUKAza2d4hDF0mA3s2Ey8srJuMBzc4G5DJhEPLi2QmLxYrf/OofGA76tDotZCFlOhwwW/hMZgt0y6boOGzs7CDrOoPBFZ3dXWRVI4oiKvUm24e72E4RXdHRVAsBge6rY2yrgCQprJYrsiikXG8gayr11gbL2YTu+Qmz6YTAc6nUGtiFMrpusQxijJ2HCK91QV/vj+XfgNubkcM3Qm3FRGzfITv8GGHvIWKhwsHuFs1mHdu2SNKQcqNCJkTM5hN03UJWTKaTIbKqM52viOIUTTeJo4TA8whWHsFqSRK/Ia0Ir39+c/4fGl+D2XcIK28TMd8A3zfvC9+a96aS/Abs8m+xPoW3vs0b0BO++8XeYri8OY8gwO7uFp3NTbwwYbXyWI5GlCplVu4SVV6Tyja3tkgjD0NTuT4/RZYk8ixlMp7i+2uZiWGYyIqMZRcw7AqSpOG6Hk65SpbkpGlCtVZFJOfg6Ba3HjykVq+QJetq47MvvmI0neIUS3Q2tvCDAKPg4Hk+aSZQLJUpWCaGYVE0dRJvRRLF7B/t4vkeIjmr6ZhCqcjcXbF1eMjVTQ9NMXBXHr1+n2fHJwyHfW7dvc1sscBdBThlh/2jI1wvYrFymczmXF5d0d7a5vPf/Q694NBoVKg0msxmU2x7rV/r7Bzg+yGmKrO9tcWPfvwR3tLFtmwWqxVHh9s4RQfLdphMZpwcn6FpGnmWUqhUyZKEgmUwn83Y3D9iMXdxY4nf/OYTNra2ePHkGbZTxjINlospt2/f4sP3HiDmMYalsrnZ4Gc/+ylZElAr2exsNBh0z+j1+qSiwsMH9+jUKwRBxCeff8HNcMR4MsGyLATgqjtg4cYMbq74/NPP14tDlFBNk8tXx79nNf/Txh894AVCiJ5qGLlCrmbMchcbEyvTKOoWE2GJR4icyyixTBbnVPUCoZQwZE5AQJKvU7qd1EQKRbI4o6xaKJoE0rpVKfAmmy7DTwMgByVnJXm4uY+EiIWJg4GQCkRJTJwlCJKAoAl4SogvhIBACZtiZmFmKkomrvf78pRUzEERCJWEmejiCgEZOZZgomUGQZRx7a0YZCnS3iGbP/srfvJ//L9y/+f/EsWxmYyHZJlAliasXJ9as81iMqNaqTAc9Bn0rgijgBw4Pz9nsZxRsAU67SrlUpkkTnGcOuLrhPTFfEYYhIRBQKVYWLc8FZPr83NIEo5fvGA2m/Hy6QsURScTNcyCg20q5AikmcDZxTlRGjBfjlF1ndl0gqFrTKYzgiRhMB6hqDKtegN3MUNRRHYOdpHlHFnKyZKAYrHE/u4eUZQy7N2gaTrj3gBD1wk8D9uykQGnWCSOI4rVOgWnhCgqVGs1wuUcTdOxbIdSuYquWZSq7fUcKQMhxSoUsFs7lO/+FFHR1lXd6xbmNy4pry/ygoBklVkWd4ju/Bxx710Uu4KMShJnXF/3CDwPb+WSJymCCEmScPfuEe/c38fQNMIwxQsyZnOfXFLQdZXexSWOUyAMA26ub9Ct1+D7HYgTBL5tF/Z2xZbzLTLLd/f53mZbCt95/c2h3ia7CF9HB+VvVXpfn+MNsL1dSr4+WZ6/dfwc5gsPQzdAgDB0UVR5rRWMQ2RJR5JM+jcjri+vcFdTNvZ2kGSRPItpt1uUyg263R6LxYIoCMmiCEWG9tYmSRoiazK5KFKtNgn9iPFgtM7DG47QdAPbcSjVqsRZjiirmKbBcj7FKRRwCkUW8yVpGDGfzXn27CVJnCFbBQRZZTqZ4DgOtWZ77SYiy7SbTUzdJHR9iHyePn5E9/KKyPMwNZl2u0OlVKFScqgWLQIv4Prqiq8++4xWZ4tGvUoQJWSCjKQqzCZTrm96KJKMu1phFBzEPKVaKxGHIdc3PUI/wNQtTNtBljTGwwHPXp6Spjk3lxcEQUwmyURxShzFFEvrv4mjo0PCIEDRbQLfx3YKKIpOo1ZnZ3cbu2AQxwFJEtHrD5kuPbZ297FNm8lwyPPjEzY2t3E9Dy8RKJYrvPfBh4x6N3z56DlpKlBwyiyXHsVyFds2URWNOEmpNGv0x32O7t1l2L9hf3eHPImxbRPF+Gfh+R80FEUiTEMqqUMkx8RySpTGqKlMnkWUNZtF5JElGY5oYaU6URhTUExCEhaJj5xGGKhrZVsuISQyURojyxKKun4epzHkIgoySb7eZ8uEHE1WQBCYJkscTAwMdHSiPCZMI5I8JkgCVFFBVGWSLCZLM6RMpCDY5HmGksuEQkSSZXhCgCRI601kQobhkmUU45KSGSal2x9y54MPiUQZw7TpXg8Q8pRJr0/RcUhCH0kWqTVKPHtxTLlaZT6bEXkhB3tHSKqOqkqcn5xgFWtcXvZodhqIkk7BqRBFIeQpdsVB0gR0o0D3+VPcMCbyXd597z2Wm5sUyxVOXzzHdMokuYChaHQvr8nJWa3mqJpO/+KEaqvO+OYK2ylh2QVk3eSqe40iCTRrdUBka2ub05MzZEUljQMy6sR+QL3Z5NXpF2RxyheffAp5hqxqr4XKCaok4LsrKuUi0/EIu1pjOOhRb7Tw3BX1jQ6u51GoVEjTNeVdyBNkZU3nH40m5ElIs7PBdD5DECV0e5s0hcGjX5CkGVGaokoSkJOLMqFaIC5tYm7fRRyOsItVBtdXbG5t4bsuaZYz90OSfG39vbmxhePYXLw8xlu5GLJE4K+QZYk8T0BSiAIf1VAQFZnbBw9YLF2GozFZ+sNr/nvkzLdAZo053+zzfQ/UvtWr/AZMv7sj+J1pX9/0vXnvzfd40+b8ul369mde/5MDoqys43pkg42NJq2NNqNBj1Xo0WjW2GxVefRVRpqD6dR598P3mY7HrGYzVvMVy+WC/s0Ftn1EuVYiT1KmswmmpRN6K+qNGqP+AEMzWC1miALohRJhEKBqGpoqI6gmrjvD8zxUXSf2XBr1KpGpIUoSjUaN0WgMJBQdhSROqdbLTEcDVF3nk999yWq1QJZEJN1kMpthFxwGN13qrQ2uu1cUCg5bmx0EcZ2uMRlPkIWci4tXbIsihXKVfvecKMuwxJy9nQ163S5pmuG5LtNlQOjNqTebSJJIGMUkWY5pF5nOpgRxxMXVFUmWcfHkM+7evctoPKZcriEJNlMvZDoeYTpFViufKMkpODZbGy3q5QKffXXM+PoCy7JIo5Cz0xOiKGU+c9nY3MGyDK66fc66A7IsIlwtqbeaDLrX7B4ecnl2Rq3Z5vnJCYIsrvcxBTAdG2Xl0ajVuLW/zWg8xV+OMTSV+WTEe++9w69/9Q84lSa+F1CtlLGLDt7S/eFF/k8cf/QVnpbJ5EpOlKcIiYQqKwyyGWEeYeUGaZRhKAqeHDLPV0COmimokbwGHcUEFSbCkikLYlKyPEfJZMxYJ40zVElCUxRicZ1oIOZrEoOQgReHpHm6ttuRYubCeu/wjQ7PynT0XCVOU5ZJQCLkZErOXPLwpIBMWCeQF3KbQm6i5ypRknDjLXi1mNHLM8SDQzb/4l9R//hn3P7xT5Ech3G/z/DmmjSO2Nps097aZP/wkM2tDqPxiDiD3YMjPG/F5mYLQVEYTEbcXJziOA7FUhlJzNAtC90soRo6VqWArClUmi3GNwOO9g+Zj3okkc9yMcXQddzVilK1gmLqOJUyhaKDbuhYdoE8h1KxhCpLaHLO5s4mO/t7VGoNUkHh2fEZtXqDSrVGpbnJaDQlJycMA0rVytpZRJAIXY8kjGjUmlTKNYqVCqvlnM72Lk6pQBQGDPoDwjgjjGMG4xl6oYBtGESrBQVTJ01Tmp0N3MWCUqWGqsqoikK90SCJPDRdQ1YVFKPAeDzC0FRUSWI1nlFq7VO99zO0SmfNuFQ1PKVAuP0h0c6HzDCQZBXLtMmjmHDlIqkag+GQ+WJGFEUsl3Muuzf4qwWGIiDLEk8fPWE+mRD4IfPxkCyH6aBHksRMpwuiFMbT2Vo3VS4jSz98v/o2r/J7IPSdn98b+Tc13NsMyu+CHayruDexQd869ltShK/nfqfK/Hr+m0JQkhBUGatcwrFMkjCm3x0ymayYuzG/+fQrdMtgc6PJajnl+eNnvHz8iA8/eECr08DSFDRVx3VDLKuIrGjcvneH45fPCMIUEQnHMvAWUyRFIwpjVFUDUaZRr3F1+pLuxRmrxQxdtxCQKToVNM1mMp6S5zmWaVCvFOls7BInUC5VGdz06V1fs7O3w917dynaFs1mC1USkWUJ07IwTZtS0cEwDIxCgYvuNXGccXHV49njRySIlEsVDva28RZr0/NSqchyFdBptcnjCNuyKJYcgtWcJAi5t7+NNx6imQaR5xH4HhIZjlMgDiMsQ0fSDFZRRBT72LbJbL4gixLmoyFJ6JPEPmQJvrvif/73/4Ff/uZ3TBczHn70Y2QJiuUiz588wrTtNThPVjx5/BLX8+hdX7GcTuldXTKbzPGimDhOOLp1wIsXz0jTiMlwTJKmWJbF9fUN/e4Ztm3z/MUpYZzRGwxpddpMJiMeP31BmiQsZnP6vRsECa7OTzGU37dQ/2njjx7wpGydGtDLZsiZhBhDwTDwxIAszzEyDTmR1xIEBeaCu45OyUWsRCeJEnRRoaTbhGLCWJjjvzZ/FnMBOzORYwUxF1EllUyCTMjJBV63QiFLU5I0WTtqyAIryWPBikzIMQWDAhZ2rqNkEsvYw018JFEkVyBSEnxx7bAyTyOuwiWXSUBc71C49yGlD/+UvR//DKPSoFxpQJ7z/LMvqBbLGJpKoVLk5fkVoiIgSAIrN6Da2WTmhyxWPgWnTJTlxHHIYjpla3efKAqp1KpcnZ8hCCJpmtO/7pKmMYNej53tLRaLJc+fHSMpJg8//AjLcShUKoxGPXr9HoPBkGqjgbt0mS8WnJ2d4JRsEDOSKEASRcrFAs2yw6DXI00TXn75W5LYJQ2WZJGHt1yCojBdrciyFIGYO7cPEIScervFxeUZzXaH+/fuoVsWcRoyGd7Qbrep1Fts7OyxvX+AqimotoNTqbJ/++5r0kmGLIuYho6QC0zHQxqbO8RJyjvvvUej1cT3FhRLDlEQUS2VsVQNdzllPhtR29ymeu9PiGp7NH7+f4DDn+JJJoVSmWK5ynQ0BEFYSxuKDkvPI/A8StUqlmVTLFfYP9zHjVJ++/kTyo0Oe7dvcXJ+iV50qDTbVCtFVFVCUzU8z4M8JUtT8jxlc6uDIPwwbP0w0eTbhJLvUlq+BrfvsFa+vW/3Js4o/zofUBG+sVP7Fusy/6bC+1YmIN8+9xvQ00yTjc4Gz5485e9++WvG4ykbW9uIaY7nxVx0x5wen5CmCUWniK7rTKdLPvnkMSvXZzZbsL27QxjF9K5vmI4nxElOpVqjWCnjez6FQglFtcjTFMc2uDw+xl+5TCZzCk4JQ1Nxig6bGy3SOKDbu+Hk+IQkA0kSmc5nBFFCq1NlPp0znM45Oz0lS1MmvR6z8XB9o6toDPoDhDzBtkxkTePk4gq7aLPRqqOpKquVSxz4FKsNzl+dolo2p+ddwjihvbFJpVyi3+vx5OlLhuMp9+/cYnNjk7Kt8d577/C//K+/YO6FHB4ecHb6gkqtQrPZxHNXXJy+QDM0mhubyLpDJuq4/pL9W0c0m01+9JOfYGgG1WoLyzJob2ww6HaZzleMbm6oVCqIkrRmZu4dMJvNSLOMcskiyzMURaPsFHGKRcrVCocHO9TrbS4vr+lNfGr1Jvu376EZJpZTJIpD7hztoRsGmSgzXyyZjIcEYYQgydy/fYtBr0cuKVi2xcP33qF7dcVgOKE3nP2XLvF/0PijBzwvC1FTCV2TWeGhZSpqpqw1HtmMlAwr08miDFPViMSUOSt81k4rVmYghAJCKlDWHCzVZIrHQvCIX2dBv6n2lERGEWQEWSQTMhDWXotpniPlIkma4KchsiSBIrAUfZZ4CAhrf868QCm3kDIBPw1ZxB5uGnEVz3gU97mQAwoffkzn5/+G/b/4VwSSiGGaVKtlPD8gQWQ8W9HodAiyhOveNdPFAkVXsW2bVy+fIyoK88kEdz5nNuqxu9VhNhiznEwpFUvEcYqQC3SadRqNBg/euc+4v/a67F9eUSiY9G5uKFdLXF1fYBUdfDdAFhT619cIqka11kTIRfJcJs+hYFk0m21My+T68pJWZxfdsFi4IY8fv0Q1TOI4YmtvF0WSKBTL3Lt3m0qtRhSEzPt9hExiuVghqwqmYaz3Oy5fcX11ysXFKwqlwjoQtNahVGnQ3twkCn0Cb0WpVEKRJW5uelilKoJqUCjXuO72EDLWBASzgOMo6KrIaDBkPp5Qq9TZ2t5ie2+Hi26XZRCxsXeEXbAgibFtC7V9hFFrYRVssixlMZ+RZSlRGCHKAlfnr5AFqDgFKuUi7XYLdz4lCtcJEJPRFN0us5qvGF73MUyLPAqpVco0ahW85QJFAjlPuX/3LqqiYDtFTLuAJL9xofi+huDtFuL3yCz5t19/q635GoG+IVi+Abj1e6IgoAriOlaIb6KPvsbJ7wDbd9uYb4+3GZpmqcKg36NeLHH37t11W1AS2drfo1J2uHVnH1EUSUKfNA6IvAXNdp3ZdLSWu1gFAOajPgXbIE1DJpMZk9EMIU+JorXTUbNVxzBMpvMV2/u7bG1vYxgqllOl171CVxVm4xGGqWKbOrouo+sKi/mCKAwRVY1ef4IoK6iKQqVW58/+4s+JgVUUkok5QhZhGGt28Ww2QZAllrMp09GM68sLysUSq/mUXBBpNFpsbh8w6PWI45hCoUjgBzx/frJeu5UyB3dusfQjhsMZKy9i6YVUmw3anQ6j0YRmaxshF9na3ScXFdI8Z7lcsLe3A+GK0POYjOfIWc7NzRVRkjCdTFB1hdFwhO8HbO3scLC/h+OsRfiGXeDFi5cousXmZotyqcTNzQBBhOVsTGejRa97hWoWePboMbvbTTRZYDIeMx1PqNdrFAoWVxfHeIsFT5++pNnokAY+m9ubtFotHNthPp9RanXY3Nrhz376I3Rd4/jVJZ7rIuY5wQ8YpP/XjD96wPPFgDQFS9CQVAmfECkWybMcRVNYCO7afzLVyMMcQ9FQNJkJK3z8td4n19BiBTHNMRSVomaSSBlTlsTE5ORIiDi5gZ7ImKKKoWqkAqjiWkye5TlixjoxPQkJsghZlkjVnJmwIhAjBEFYpyBkOn6ccu0teenPEbZ3+cv/2/+D/b/+d+TltZeiQE59YxvLthhPZty5d4RT0NlsVtbane4VqqpTLJRYTCZcdXso6jo5ot2qUXRs4iTGj1Nq9QaN9ibv3r9Fs2oTJglffvmIPMt5/ugpcZyQ5Snz+YRGs467XFAuFKg5Di8fPWbY71MrlwhcnxSR6WSM7y1QNZXO1gaz2ZirVyfMFjOcSolCscx8GaIoBZZLj0qxyGazjiRIzGZLMlHk6dMXVColsiTm8P4D4ixauzUUSyiqzHR0zeDqAs0wSQWJo/v3STOo1hu4yxlJuCAKVqRpTKlept2prd1SyIlCn+VsQsFxaGx0GNx0qdTqBH7MO+9/QJSJjAYDkjTl+MVTRFVmY2+Xm+4rytUiu/u72I7NfLGgUG1xfXWDIsts7uwQBQnFUpUPP/qYg4MDju7fY2t3m+6rYyRZQlU1dEPHcz2W8xmylGHb1jqbzbIRdRPfc5nNpnR7QzTTZDoeQJ4zm03p33RxVyv6vRt8//sXg/ytCi3/7uM7hV/OW4AkvP3bb7BLREARxG8qudcA93Vm37c/9r0X/xhjNH+rZxpGCQ8e3Kezs4Vh2xiWwbA/YDKeYFo22502BweHlCtlao0KD99/h2KxzEZnm/39fVx3gShK1FotRFWn2W6zf7BDY6NFLkiUylWWnsd8OkRVJSRZIvRd2p0avasrRClHVTVycizbwjYsyAUU3UQQBXTT5ObmGtePePH4CQWnSKPq4FgGQRBiqArefMp0NKJ3fY1lahQNgdOnjykUCgiCQHujwXg6w7QsrFKFaq3O1dU5vu+RRgFBFHF0dLAmQYkSpWqNVRDhux5ffv45smFQLldo1CsEYYwowXA4RJAkhsMhaRbjz4YossyrF89ZTBc4ToGPPv6I0HORNQUBGPX7KLqG54Zoms5195pu9wZJFNk8PGT2momNIOAUbObLgCSLmQy7tBo1dE0ljKJ1DkcOVrHEfLlCVhQCd4mqW5y/OsXSNIq2xc9//mdYloFesLg8P2HY7zEc3FAqF/E9j8FwznLp8ctf/Iow8PCXc3SjQJZnfPzTn/yeFfRPG3/0gKdJMqvMQ00UdEkhECNERORIwpF0JFVgnC/WIu9MJY8zNEmlpBeYCR4eAQBSLqInGmG0rtAK2lrfNxVcPCH8uhWk5xp6rJGkKY5mIEoiori+fCjIaNk61Zwsx49D4jRGVRVSJaObTTiOhjwKeswKFs0Pf0r54fv87H/6PzHxM+arkNAPaHVaeMvZmlpMjqKpLFY+g5sBl5ddZguX7e1dqvUmoe/jmAbzwYBas81ysaCzvc1iMcculnj58hmyDPVKkYvLa47PrgmiEL1gcu/dh3i+h6LrhOk67Xnpuoiygh9GbG5v8/C9B+hOgRQ4uHXETruJIonUWi2ury8A8P0Ap1giCSI03URUBEQpZ7mYIgiwsbnJcDRHUAy63S5uEJIJIoqmo0jrvRmyhMCd8/TFCUmcUXAcDu9/gKLYSJKBhECl7GAaCr3uBbphUHAs8jxl0Ovx/PELVFkhXC45e/aMLAlJopDJZMjGzg5pluIHIZ9/+gjf9Ti6/wGCrJCJEmmaUTBN7ILNYjHj4vycze09JEVBkiVWizlWsUyUQpymjCcTvnr6hF//8u8Z9XoEUcJ8uUIQJIIwJElTWhsdbt+/z/6tI9IkYjzo02w1cedz8lyitb2NqslYhRKKbmNaBVYrjywHwzLJyfAW37dd+rqqE/iaPfndx9tjjTk53+k6fn2sDL5mo76Z+92Rv1aWC6ytwoTv90zfzPrh7wqYloMfZTx99ITHTx8TBAHbe2tpyU2vz9/96u8ZDfuMx1NURSX0XHzPI4t8EETiKCKMYibDEYa2ZvYtFyvSNMMsGCi6RP/mmtlixfnpKZapE0YhJyevmM2mSJKMU6rTaTZJ0/Va8KOQ1WrOcrGgUS3x3jsPqJdMNrY2WExHLL2Ai/Mzzi8ucL2ISrnGxtYO9+7eoWDpHBwdoZsFCqZFsJwj5Tn1aoXHX3zKXqdBnmeEQYBpmrQ2trBsm8FkTJ5nFLT1/8N6xSaOYyaj/trPU5A5PrkgjkIGNzc02w36N5cUy0WePnrE/YcP6WxuUdvYw7FV3NWcRBDIRZFer48sK8RJjlUo8er4OeVSYS3s39ri2aPHvHj2ksV0QrFo4y+nyLKIt1riuUve//gjkjTF9z2m4zFOsUSpVMQo1Tk9v6HR2UAUoVq22dzcxnVDlkufi8suQeAjkbF7eIvt/X1SUeHy/BU/++mPSPwF3mLI8Pocu1jCMA1u3b1Lud5mOJ1+b73914w/esArYBFJKUmWQpRjqBpzVmvn+EhAQiJRsnXcTp5ipwZxmCAIoEkqKyHAxSclXxuwxiZxmAAZpqJhazorPFZrnuTrfDORQmJCAoqioGgKqZQTkSAKIhoapbxAITeIkpRLd8qpO2Vm65gfvEfrT/+a2od/jt7e5v0f/4iCpVGwLQq2QaVaw9RNbt89Ymu7g2lbeJ7Hs08/YX/vgCTJWCzmxDlUS0UUUeThg4eoqsJkNkczNTRdJY5iavUGCBmTxYzziwuCVGTh+oRJgu+6XF1e0treIgo8ZGR2dw4wdJ2iY5NJAqsoIE4SFpMp5+fnyAosV4t13z6KsAyTcqVIwSlSLBcR84TpqM/15Snv3DtEk8EuFumPxkRxRJYJWE4FU9XYbG8wn87xvRXdq3N0Q+HHf/JjIneFbZvUmk3KVYflckapbHJx9pI4cDF1HVHRMIplBv0B9VaberXORruJkK/F4Rt7e2wf3UFUNAI/4eqyz/D6BsMwcFdztg92GQ66xEFA4no0ihZilqFqNuQSaZAymc6RJInNZpVmvUqUxCxnc+4+eIAk5ghijm7qZHmG666otDrIisxwMEQzbXTT4abbYzxdkKQRiixQKlqI5KRJwrg/pH95xc52h82dbRarFX4QkMQpoigReD6mXfz9C//1htw/1lJ84xaznvl7wPDt3mj+fdB662TrdPb825XbN+SZH/7kGxmHaNpMx0PaW5tcn10wncz47d/9LavJkCzyicKQOAfT1Dna2+LT335ClGTEucB0NltT7r2QKIo4fvGMbvca13PXFbWiUSoWCYIV77//AFHIEQUZSdVR1HUE1Hg6IxdSLMNkNJwyn68Il0vcxYK7Dx4QJDFJLvHV558haxqSmFOrlag1m9y+94BGq4HnB0SBj2YYNFptogSKlSqSJFIql5kvVswXKzRdJRdEet0uORLuysV2iniLKdPRGEHIKVbqOE6N0PcQ8oT923ewbBtZ19dBro6DpMho0poYUy6Xcb2AF8cXxFHEgzuHLF2f5XzB+atzFEVhMZuwvbvNfDIkjVxEcsazBZKsYxaLlOs17h7tsr21xeHuFqVyjcXSo9luEoc+i6XPZDyh0Wxw8fIphu2wmEwwZIGCbfL40SM0RUUUBWRZYLZcIEgqxydnhDEkUUilsv7vbFRLzKdjfvu7T4kT6Gxu0WzVUWQJz/Xxw5CD/W363at/ZAX/4eOPHvCiJMaSNWIxJk9YC0/lHE8MEDIBKRKoKDaxFDPLl+SAlWoI0dpSrKAZzAUPT/AQAAkBO9XJA4jTBFVS0WSdQIxZCR7paxanlEuYqU6erFmclmKBLBILKRkpqzTiKlpynYbE9Tragw/Y/ot/Q/XOe6jlGnEUIckax+d9/v7zR+iWwXIxI4piXjx7wWLlk+YS7c0tJoMBhVoby7bZOdxjY2ebIIg5OX3FarXkF3/zt1TqHbIkZbnwePboJfu37rBcLuhs7SAgc3B0mzxNqZYdZElgtViSJjmdepNypY5u6qxcl+V0znK2IA4DJqMJjz57jGU4RN6K3vWIyXBKGoXEYYTnB3R7fXzXQxYFTMvi6OgIdzphMpsj2xZWpYKsKNSrDnnsU7IL5GmGF4W8OnnG+fkpURSRximibFCsVilV6ywWK/a22jiWwmQyZjaespiNkRSJew/vkyUxtmWRxBnj+RI/Ckljj5yMnd09kjBmMhziLSbcur1LuWRSsXVUWSAJfGR5nYdmFxzMQonZysUolPD9gPrGJmnOOo09zTk/v8T1QgbXl6zmc8gF6sUS7UZtnbdnFNhsb7KYTsmzmOH1FUkY4S1datUGiR/Tu7zk13/zKzx3ScmxIU/xwxA/ivH9gFq1SrPVwCoWkWWZaqVGo9n4Pat+rfb+7h+38J05b0sJfqj1+LVs4AdMqN+uzt4Wnq+fvqG5fOc7/dA3fa3dMwsOl1dr4kJnd4+t7R0EoFJ2qNerfPSjD1AkiX/41a/45PMnyIrCTz56Fy8K0UwTUZJQNJVisUirvYEsa/iejyCIfPr3v+bT331Ohsr5xQ2ybjCeTknTlJ2NBrs7m8ymE/I04atHj9nZ3WRjq83m/j6GU8CPYmajEWWniKqaKEJCoVzm6YtTojil172m1+vTaLWoNhpcDyZM5i5/94u/Q1ZkbNtg5+AIRTPXRA5L585Bh2ajyuZOZy0TMC1s22Znu40qiyRJwtnzrxiPZ/hhgucGZEkCaUKns8mDu/cxVBkv8MmzhFsHuxiGQeAuCKOIwWjM8ckp09kSb+WiWyWMQo0oiKg1WoiyQaHcJIoy2lvbZElOoVwhFTT29nZ4/PTFOsMxSbALJSrNTTJBZrnyKRZs7j54hySOaLZavHz+hDCK2dnZptqoMZlMkTQNgYxysYhISpJlzGZz8iyjXqngzmd0tg+Q8pxWq4a7XPGTP/1zDMOkvrHJcDAgzdat5P+W448f8IjIo4xYSgnFCD1RsEUVVZWJhAgj1xEi0GUVV4hxWQuvzUxfC0tFkZJmEUgxS8EDIVsbPGcqciSQpDG2qmMr1lq3J3ivBcgCYi6iJQphkpAKKaqkMEhcngQDTtSQaHebnb/+t2z/9K+Q7CJJnqFbBjt7exScEkgqq6VHHAacn71ClkUkIcPQNRaTGavFEtu0MVSFjWaV48ef0L/u0utesJyM0BWVJIqYLxaMFh7jyboquX33Nt1ud+2BKckMegOSOMdfLdnebFO1TCxV5fBon9/8+jfMx31sQ2I2HlKs1pnMF9h2EcNyuP3uAwzboFytY9tFxv0ei9mcPM6wTIuzJ49pNytIQoaqqrjLBY3OJkvXZzQeMx5NefrllzhOkThcywFAYjqaUGt1aDVblGyLn//Fn0GeIuU5eRxxfX7GZ188ZeF5aJqMKCkU622ePn3O0ls7skwnU/IoYqNdZ2N7G7PggCyzWCxI45CNrU12jm6TCzmtToub7hV+ELC1uUG13qBQLDAe3XB13WM0GrNzsI2syERxQMUxGQ8HPH/2FFkAWcgxrQK245BECYvl6rWGLiIKI+bzOWkO7U4H23HI84QwdNE0iXa7weHRAYahYDoVJE0jDEMQRebzOYqqMZ5MePHkCaVKmfl0Qu/qksVixQ/SQoQ3vMv1ix+WIgg/2J783shftyh/gGb53RbnG83d16zNb33gu3D7zRFlWUE3TOIoxF95iGmObSh89Gc/ptFuc93ts1gusS0Np1hkZ2cL1S5yNZhQsGySJGNjZxvbMtF1jUa9ikSO7/k4joOsKpSqFbIoxFu5OE4JdzpicNPjy0fPGI3nKLKIZZu43orFZMagu9aiKbLBcrHk+PlLrq77a/cew2Y8nJHGKZqq8erkBdPpjMXSx12uGHTPuTo7QzcUas0GAjkF22Bwfc14umLuZfz7//W3TMYTtjstDF2lPxyyXAVIskG51sYpFZAUlZXr8d7772KZGrIkslwsiEKfs7Nz/DDBD0Ik1eS3n35JHMW0NlqIosB4NKTV2aCzu8/ewT7z0YA8E7i4usZzPe7c2qXTqWBYOmkas3xt2TYervf7B71rBHL6N9e8Oj0jDDOm4zGVUolu94bG7gErd8l86aOoOuVSYb03qKpU623CMGN7e5ubq3NK5TKz0Zg4k5Bkg+NX55y8eIEgyZxfXGDbBrVamVyQCIIIhZSiqXJ9fbW+gfxvOP7oAU/TVARBWMfwKAoRKVqiAwK+lOATkycCUZxS0Qt4UsACd82cTHWycC0xsFWLUEoYsfhaU2RkBlIsEWYxsiSjyyqZmL1ugWbrvZFMZOXHXCynPF4M8CsV9DsPaf35v6J0513qnQ6HR0f8y3/9r0lTiMKIxWxKo1Fib6fNzkaT/Z0dNN3k7u0jKiVnfWfnrpiOx6S+x3sffMh8NqNQbVBrNKjXW3S2t0jFjDBL2Ll1m93dDo5jUW9WuO52qdca7O3uIAgS29sbdK9eoWsikqwwHE3Zv3OHx0+fo2o69XoDUVJ4+N4HiKKIUyyhyDJZFH2drffjn35MqWTxr/71v2BnawNBEYizlMb2HmEqMF+uCOOYp0+e4Ho+r148J0kFxsM+7e1dvDBBNot4cUgQrhCSCE0z1o7rN12ePD/h5ZPnJFHIeDRgc28XSRSxDJNKrUFnY5NqtYEoSLhLjzROObh9D7tgI6AyuB6wXMyZT6ecPn+OqZkQJyzmC8bjOdVKjcl0Trle59nLZywXE0RAVizyDEzLwFBlFFlguZjzm99+Qq3TQVQkdg8PeHj/DuVahW73kjSOiD2PNI55/8MPSKIIQZYxig6LxYpGo06tXsc0CwRBxFX3ku29beq1tQXbaDwiDkO2trfJEZFVmTCMiKMEx9ZxCiaOU0LXfo8LRb7eMcvIvwU139/LW1d44g80HN8ms3zLNOUtMBNeH+Frhxm+r837fpv0+yBbKFf48E9+iiQJzGcTbq67jCczZhMPQVGwKmWGg7Vzzr33P6DVbqBICsuly2w64uzlcxZLn6+++ILeYIium1i2SeIvqFTKmJpGyVI5vH2AbaxzG9/56ANq9SpX56cUiiVqjQ5Fp4SqaUiqQpyu29+L6ZQkiFA0A1GVyYWc+dJF0hQKBZNSpUK5XOLBw3ucPH3EbDqnubFNqV6j1uhwczXgP//H/4XuzQ237t6m0y6TJgnLIGI6m3Jydk6tWaNkqmSIdK+uWS5d3MWSDz/6gNmox/MXJ+iaSrlUIoxixuMpSeAiSgpXF1fMpjOeP3mMrJvUag0atRpBEFCvFhHyfK07jH3qVYuqo5KnCSkCw9GY1XLOaDgk8EMsTcddzYnSiGqtQatZZXN3h97FCXHk0zs/pXdzSZTm3HRvCFwPXUq4dXREwbJpb25wdfaKOA65PDthPJ2TAfV2h3qjimUZjKcTCk4RzTCJApfm1ha6InN0sMOjL7+kWS8RBy4Fu8Bk0Kfe7PzwGv8njj96wJMzmVhJkTMFFY2V4EMmQCKgSBIrwScjxUw05EzEVgxcMWSJR5almKlGGqWIQFkr4AsJC8ElFdaApmUKYghRGlHQDGzVIBBiRtmSi3jK42TA0FZJW1vUPvo5xfsfIZXbBN7aFmyy9JnOV/RHk/Ud3cpltpixf+sAQRKoNKtUaiWKToHr/ozRaEpzex8/TMgQ+PR3n6BqyuvWkEx/MCHLRZbLBYHnoUgyiiSShhFbW20ss0AYRszGE148fkq/O+D6asBiMqNQLBFGPvPFAklWKJYrIApIsshiscQPQubzBQeHe8xGYwRBoH9+waB7yVePnjKbzRhOXU6PT4h8n5vLVxRtE8vUmc9mDK6vMUyHSqNDsdak1aohiSmCBOPRGCFL1zRwQ0KSRUxDI85TShvbzFdLBEXGKFi4vs/u7haDmyvGwxGjmz62XWA5X9De3KJer+M4DvOVx6vzcyxLRxREavUW7737HqVyhavLM/r9PpppgSjxN7/8e5azOXm+Tknf2d0lz1Oa7SbVcp35aMzjTz5FiGMMVSYJfUb9IUmc0e8PGY2nZElGmua8++MPefj+O+zubqGpKpqmEHkBaZQTRznD/gCnYCBK6/2nwU2Pk4sbusPJWqCfgl2tIakGoigzHU1JkSi3NgiCDFnR8AKPlefxw41DgXUug/C1tu7t1mX+vU/x9ae+PS9/y/7rtYbgLX3d1+d8Kzniu7t132KCfus7fvN73/f58rMvmY8GFAo2zU6baq1GmmWv9WwgiBIvnr+gVi7x9Pkps+mE7e0OgqSgKCK6oZNlOfuHh1x2u/R7I/YPj5iMhqBojEdT0lxCcyrMZ0uePj1BtRwevPs+rVaTNIm57o/IBYnhZEoUJ2i6RtExcAoqpqVTKZrcunWIqEiUSg5JkrAKYpZLj5vrPoap0mjUEZGRXkcNlSoOD99/j3u3b9O/uaFZr2OZKnf3Nmk228SeS6tZpXt5TsWWGV2fM7w+56svvmS+9PnLf/EvOTrcQ1IM+t1LGq0azXYTWbcIwxhFUdnd2+fg8GhNYsshyVKqlQrFYgl3OWPS66LIKjc3N9Q7m+RCznKxJA4DIs9jY6uDU7QpV2x2djtcnZ5SrlSJMwGjUGT78A4//vh9tvb2+fGPP2Jre5s4CNjY3iXKBG76Y05PThiMxrjLOUkUMJ9OQRZA0Vi6HtVGk0H/hpXvc3VxRbnWprO1iW5YPHv6jKUbYOoapZKDomiM5zMUw6R38897eH/QCF67qS/wkFIBSZJwRQ8tk7FTDVvTCOUYIQc1lojShLJu44nhazAEJ7UgWqcSNAyHTM6Z4iIIAlmeY+U6eZSzTAJmccBNuOIi81g06+z8i3/Ln/5f/u+0PvgZG0f3kWSDVmeLNApRULg8PWcxX6IK0K5XEDKBwA/49d/+mieffEqpWOHl82M0TSUKFjx8eB/X9VBUlTjJSCSVzz/7nJ//+cfkYcC012c8HuN5AffeeY9avcH5y2MW8zXV9/TlKdVyGVHMSZKISrVMKshsHxxSKJWZzuaQZvzd3/yCWqmIaShESYIkyfS610S+x9npKUvPYzzs4y6mHNy6s95HW654+vQFVrGGhEqp2CDNIEoS3vvRj7GcIls7O9iGimOoNKolbE0n8kNWsxnb2zt4syV2sY4XZRRsi8RzaTebRH6AIMlIisZ0OOTqskcURdSaTRrNOpIkEMYpSZLizhcMrs559fgrksAnSSLGg2vSOGSxXOC7S0rlIpqmYdsWupSjSTKm5WCoNkKS8+zpc05evKDebDKejbj38CHVep0wSTCKZVRdwS5YqIZFe2Ob1cJFM0zKpRIF0+LmesDf//3v+O0nn9Hv9xEUhTgOyQRoddqUqxVKJZPB5THeYo4iK9ilEru39tBsE0XVmM8nkGeYqoxAiiCJRGmKbpdptLfIkpjfp3R7s4v2Rlv3XZD5R/VxP/Aif4N0fBs033Zd+b37gN8c4XvHF4BckNBNi3c+/Gid0p3nHB+fsFgskEQJVZapNlr8+Cc/4YuvnjKarphOx5xe9pANizgV1nE29SqN15E8BUtma2uT6XSKu1xSb28QxRGTyZxGextRlJgMhqQpPH/6hDxZax+zLKHZ2kAUBGbDIZpuM53OMcwCq/kCyLm+uGA0muC7wdq2rFlH1gxk3WLhuZy/eo4miwRhRJymCJKCaqikGQwGU7wgRdR0fvzxh5TKVeq1Gts7uxwe3ka3i2zv7tJqt5jNZ1xcdinbBkVr3eaWk5DR1SmtRhXfW2LaDu7KY3tvmyjwSdOU2dxl4YU8/uopGQL7BztU6nXGkxmyrNJqtlDylKNbt7GcMldnXXzPR5YU0ihn/+iIdrsBcYK7XDLp3/D08RNkTUc1rNddjhG+HzIZzzALNoZpELlzgihjunCptVospnPK5SqnT75cy3yikDxJKTo2tUaV7sUVpmEgGQWOz2+otDf4u1/+PUaxxHw64datA7zlP7c0/6AROhpaLCNKOUEWIiUigiysK7gEkihdu58IIWkGVqKjZiIF1SCSE3whJAP0VEWOJNIsR5c1IjHBFf313VIWMo4CTpYTrrIE8+ge9/7d/5nOxz+nN1ny+NkxmmkQRDG2paEpOYe3DwgCl83dXQzLZDwakiQZq+WMUqVG6IfsHN7FMHREUebyqocfJAymSx5//jusgk2ap9Q7beaLKZfX11x1r9jY3kURBbIkIvIDpqMZoigQxQGvjp9TrJdI0hinaJPlCePhgK3tNoomE3g+gRuytb1Lqejgej5WoURrcwOrYFMuOEhZynI+Zu9gk7sP7vHeRx9j6SqGoaMoOlEUU2u3cN0FmxttFtM+miax8nwUw2K+8hiOp9RaHSRRZnNzk2rRJo59prMxyAqKqpCkCde9Po8++4TxYMh8PKZUKjMYdCnWqhimweGdO7SaVUpOgd7NgP5Nj163z9nJKT/56ce0Ok1u3b1HksTcvX+Pzd0tPN9FLxbQSw7j6ZgwSpjNF7zz0btsHuwQRBFJGNCsVXFKDmm63ruI4ohipbLOont1Sr3Vodlu4y9djk9OeXV2zmyxZDabsZgvGY5HGE6JxWyKbhhoMhTMdTtpPJxweXFDlks0W022Dw4RyZDISOKEQsGm7JSYDYYEgY9uF4h8FyGLmY0GDPs3pMmKVqv6+xd+/kaL923rr+8+//bvcr5d/X2/WnsDot/dlftuU/SbOb8PYr8BT6tcYziekAoyW+0G7WYLTTdZzpes5gsEBM5PXqIaOqIocXTrANO2CN0pmirRrFWoViuossSzx49QFI1ivUlvOEY2Cuwd3CKJUkRBIvWX1KpF5uMhimZyfd3FdIpkooTrhUwHfbI8IUpyFiufDAlVVdnc2qB7ecX5RZc4jrAsC8syuH20S4bA7laTcrlIpWBTazQJwpjxeMLpySuefPWI3/79J7z3wbuUSw7lks0Xn3/J51895eb6itOLS2zbxLENNN1gsZjTaLVYLJZMJjP+t1/+mrkf09naQDNsckHh/OwKTVU5OtihWq3w7PkrFEVmNplRKNg4tkq5WsJ3PQaDCUkUY5omX376W7I85Xe//Q2vXp2hqxL7+ztUqjXiFAoFkzCOieIUSVEY9Pssl0v6wylhGPGbv/8NC9fH8z10WycMVvi+i2qaVMpF3v/oYxRZ5vBwH12CUrHI7tFtkAQMw4AspdZskQQenc4m3mrFdqeJv1oSxRl2sYSQS5i6AUlEo9n8/Wv8nzD+6AEvatYBcHKLWErRkVASEUkV8fIQPdNQchnDUPDEADmTkCKFII0pajYr0SMQQgTAyDSyKEVGwFFNhonL46DH03hEstNm46d/Se1HP0PfvcUyjAh8j/vvPiQOXPIsYzwc4vkRw/4NiiKjWiaaoXF2dsKrs1ckScz7H33ARmudW9UbDvhP/7//zObGJiXHoVSrc3ZyTLnWJAgjdNNgPp+zuX+byTxAVBRkXSUhY+/gCG/l8uGHD7j//gfomkIchWi6xUW3R38yJRdFJqM+AGES0trZpNpsEsUB77//LiXbZD4asJrOWEwGbGw2kDWFWrOFosp8+fnnXF1ec3Z6hqWqiGmMpRsULJX2VoM0jVjOPerVOovJmKuTYyLf5fLVKVEGL4/PiJMEZInGRpvZZEKr1WI5myLkAbZtUG122NjsUK03mU1njIcTViuX7lWXnYMjTs+v+ezxMy4uL0iTkM3dDfaP9tZpFEmKXXC4urzmxbPnfP6b3zIfTzjY28d1VyR5yuX5OUs/5uyyS5znbOxsUu1soBkWkqQxW7ikaY5qaPQGAyrlEltb2xxt71FyitRaTQJvhSTJyKLIajknzhLSNKRULlKplCnYFoG3Yj6ZoCoSg+suLx4/JgpDKo0tavUOfpii6xreYkXguuRZgioKlEoFlssZxWqVza0NdFWENMZ1PYJoHQ/0ZgPt7QpL/MdKuB+Eu+++m3/d0nz72G/apG8/xN9DSMnh633EtwHuTQP0TYWYCaCoMqcvnvPs5Sn9Xo9atUijVSWJE2RFYrlYkGYiibdCFkSqtQZZnjOfTBAkGdcNUGWFOMlQDZPxcIIhgzu5YdS/4vz0OcOrE3xvQfdmiKrpFCwLIQkxDJnlYo4fLCg3Wwx6PWRRQFVFBGKSJGE2mzIcj9je2eTBrR00TcIoFhlPlkiKwYsnz5jPFsSAkCfUygX29nap1RogKPhhyNzzWK7mLFYB3nKG5/uYhQKGpvHxB+/xi7/9G0RZJvACPM9nOui93k8EUVEJfZ/trQ0EQUCSc3RN5vmjr7BMjel4wIvHXzGbDJnPV8znHgW7gOOYvDo5xvViTMfmvQ9+RLtZp9pssrnZpvvqlCzPkDQFWRZJs4z+1QXnZ684PX1JpWDw53/2E4Q05N6dIxQhZz6doWkWtZKDUygQej6yKKGoJnEU4DgFLs4vqdXrqDIcHR5gSALVeh3PXWAVCvhhgmrbZKLE2fkFq+UMb7FgOhwQeAu29w44eXXO/v72P7aQ/+DxR5+WkNeajC8u2YglNElhkXtUMocsFVhI3tpaKrGYy0syJWMeuZTzAk5iEosZlmISZjFZnGHnJlkqchnNmaUBarWBYDk45SqH7/2IV6evmE8GbFcbqJrG4eEO4/GUar2OLIs0O22m4z57h0e0W3WuLrtcPP+SKM3Y3L9DFAVM+j0W8xk/+ugDFN3glShwdn5Js9NGCFY0NpvYuoPruuSCyIsnj4k9H0kS2djeWTPCCiaT6Ri9YPLs9BhTL9DZ3GY2nXN1doGuW+imTO/mmlZni273BiFLmAwG9G/6rFZLFFVhOpqysbOLIuY0OxtImgqkVKs1pDQj8FzsTZXxZE6pWsILhtQqDZ4/ek6xbCHLOVGw9iocXN+wvbuDIIpsb3VYLFdkSUy9VuHp8xcUay1m03OWixWu51Gt1FBllTzLcOdLWvUKqqpxfn5GoVhlNhwymy3RjAKVepnEX1Es1VAVFUWVmS9cut0bEBSW7pRms02x3l6Lx+cLDNWgtNPm8tUZmqwwvLpGt21M02I4mrBaLCFNsWwHu2DTbjT5/Fe/ovLO+0RxyvVgyHy5YGt7jzzLmIz6ZGlEY2OT4WSx9mjMuzjFIh++94Cln+DYBU7OukxGg3U6QK9PKshstOsoqsRF9xppFTIbjmgUq1QaTZxikevzCwqlMt3LLrIgkMRrYpM/nb1Z5V+vdwGB/Dsem29XZN/2UfnhyuzNs+/FDr318+1KcT3zTSjsG2B7A2ffBuPv4bAgIMgqhwcHnB6fIYgy8+WS1WKK45S4ub6m2e6wnIy4uh6wChKePHnGdDojR0DM1/625YqELMmIooC/WnJz9hLd0jGcIkWnwMXZFZVKkTzPkTWFJA7Y3evQ+uCQ33zymEq5Suh7SIqBKkuouoUsC2RphFOw2djaZD536bRaNG5v8bsvnnN6dk2pVCbyPEJvRXtjj27vilKtxk1/QB6nlOsV9vZ3uby8YDCYMR+PELKEuw8eYlk2vZshf/uf/5az0wt8z+dnf/lX/P0//A4vDFB1HVHIqVUqeIsluqHzxZePaWxu8uyrL9g7ukuhJDLs99jb2+InP/mIhRcy7A1ZTMYo2rsEybpqclcu8+EQ8/CIz16estHp4Dgltg6OSLMUIcu5eHWKbhaoNZpsbO2g6CZpmmCX62TpMYvZDEk1ABHTshgOhrQ6HcIwxHLKPPnyM+7fvw9IXJyd4jsl5qMBqvERKBpCltBs1Hn26EsEQWTYu6JUrXF+fEKl2eDmpsutO3eYDAe4fsRivuCLL776fZf2f9L4o6/wVl6Acuc+vhwhJOs9N1cIkVMRU1IIlZicFC1R0SQVQRHwCZFzCSla6+5USaWbzHka9TmVfaa2Sb6xT/W9P+POX/zvKHa2QJYpVasUSzV8L8A0DObTBb3uNb7ncv7yOaN+n+HlJUkKj5+eUKlUiaOQW7du47pLTk+OGU7G7Nw6QLUt/DhAyHMWXohuFcjjjMPt7XUlZakcHW5z952HbG52sG2L7Y0O1XKVZq1NngpIgsTlyQXLuYsXZtjFMqoMnXaDsl1ke2OLva0OSeCzWvkM+kMMw2Bvf3+9DxgEjGZTTl+9QpFlvnz0hByR2Srkk999yubOPsVanZ39PRrNJk6pQqlSXou2k5zuTZ/21g7D62s2t7ZQNA3PXeGuVvQuTkhFhZenF8Thuo0YxSFLd8liOiMIU05eHLOaLemedZFFCd/3EBCRZBXdNDF0lVazSbVUXh8jjnj0+acsvRXjyZTDO3e4e++ILAXP8ykVbN69e4ChSZiGRuSvqFZLbLRrGJpGs9nk6vySPIfN7S3yLMFfTKmXi8RhiO2U6XVvWM4mzGaTdYioJBL4AQe376HqFrZRgChG1mw2dg/I4pTLqwHHx2cMRwOicMXO7iadTgNN1RBFmX5vwGQyxDYNxDSj4BQZr5aMR2OyNGMxm7CYjIgCj83tbZxSlUqtjmXb60We/1Dj8Ycf8H3Q+S4gfv14rZH7Nli++cwP+668Ib4I3zraN8CavwWJa825gF1psr+9wf37t5ElgUqlzIsnz1AkkUq5TLVcYu/2Xcplh1H/mjj0UMQcVUywnDKGYeF7AWEYIJBTqVZob+/SanSoVhpEQcxHH/2Iq/MzZnMPMUt4+O4DPv/kc/6f/69/j++5GLZFFAQYhk4SJ2Q59Ht9NMMmihO81RJNFvmf/9//Hz77/Ane0iPPYNC/wik7ONUGlWoZS9V5Y0tTbnboXl5hGwr7Bwd4rsfwZsBkNmMwXdG9GbFaLfGXM+xCgfbmFucX1xTKFTzXpdbZRJVEyo6F766YzJa8fP4cP4wQJZHO5gambROGIVG0Noso2Qalgs7WZpuvvvgCb+mT5FCsVZjNV3z59AVCniLIGoNBn35vwOC6j10oomo6hwd7/Oi9B6iSwL2jXa5OX7KcTymVHP7zf/oPxGlKFHk06g1GvWtM0yRJMuaTPtVqmX73AlHICLwlcbRCUCSWyyVekDBZLGlsbNHpdNjbP8DQNGpFB1GU2Gm32Npoc3HyEtO2MXSNVmeTJPsDL/j/hfFHX+FV6zUUWWXx6jmGG1DJC/hyiJ+EOKlJoqUMkyXF3ECPVeTXfpuL2CNKcwbhAp+URNWo3XmHzcM7ZLlAGPiookKlVGQyHHJ9PaBVK/LuO3f5X/7j/8bNdUSz0aBSKXPT67O50SHwYx48uLNmf9oWxYLN7tEdRFGkVq7Qam9RLRsUrQJ/9+vf0uzUqdVqTJ6/pN9fM9hUTac3mtBoVnn66Al7h0c8+eoRhYLF8YvnZLnIdDJCK9jML4aQw6DfRdZVZtMFtXqRq/MT0kxG03TCIKRYLpMKMByOEcWEyXiEt1wRhgFB6FEpV4lTyJIU3SkxHozobG0jiBL9bhdEuL7wMIwCV5eXHNx7B1PXUTWLVqfFyfNnoKksxkOqlTKqYXF4YBLFMYvVkjsP32Hc65LHIY5jshr30UyDcr1JoyXx/Plz3C8jFF3j7oN7eMsV2CbnF5ckScpwKOOUq4iyTMG2iMOYPE2JwpDPv/ySrZ0dhCzl+aOv0BSFNF/rvo5ffkat0aR7dYWiKutQ1vkMuaKwt7NJ4i3WjifccH55hrtYYlc00tCnWK5g2yZZGrNaTHBnOoOrM9I0I4kSRElhMJywnC1Ic5HBzQVCHhGGMeV6k36vT6FUwbJMLs5OcIoFSgWbZqPA8YvHNGrbPOutWaiCqKBoOps7mwRRQg7EWYqoKN+mX7714vd1NH9YJiCQvfX+21AlvK7fvs+2FL4+z3fh9u32J+Skr+s/4WvwW//7Zm4cRXz2xeO1SXWSMB6O1m4mioYiLtneajEYjdA0mXK1hsjaWk7XRCq1FtPpmtgwnUyQJAV/uaDWbnAz7JMnGcv5lFSQ2dk7QC84ePM5Qm5AlhCnMFt61Boimq4hiTJpljGbTZjPpkiKjJgnFFR5be5crjFYRdQKFqYb8er5GapqIMkKlXqF4xNQJIneeIykmiwXC1RNQ5VEVgsBKQ9JQ4HYD7m6Pqbs6PzpX/0Lbh8dEIYev/i7f1h7fzoWoqrhL32a7TqXlxf89ON3+fxLEUkQ6GxsMx2PaNTLaJrOZfeG6dLjojskdGfcfvAuwrCPZVvEcca920fcnLwg8pZohs3xyRmtTptGq4ksrjsihl7gxfOXFIsO/d41re0tWhttDNtC1Cws0+SDD96hP55gWzb333ufm8EIIY2Zzebs3rrN80ePKDc3kBWdjY0dZssloe+RxxGT8YytvYzr6y6KqiOJAk+//Ipivc0Xj15SLleI45ggTshDn49/9CG/9Jb/pUv8HzT+6Cu8ZqVKs9XBuPcurpSQkGPnBig5YR6jJQq6qrISA/IU3CBkEge8DEec5gv0e+9iv/dTWj/9Kz767/57LKOALEpMhkNcf8WLFy+oNVuQxoiywldfPkIxFBSrwNb2Fgo5ie8RhBGmqXF4+za+tyAj4/jlC5xCgeurKzRFZNg95+mzF3zy2WPG/R5ukPPq/ALImfSHeCuPZ8cXaKbKbDbDe23/FQQhjUYT3SpgOUXKtRK6LGGaDu9+/BHlZpXFYp3InMYCqqbRbFSQ5LVG0C6WIRdYTWaUyw103WD38JDd/QOkNMeybK6vupBlqLpGEHogSiRhQK25ZhtGQUi5UiHOYjIh5eryAlVVePH8KTubLcq2SZpnqIUig+GUMF7fpfZurlkEHrP5kr3bt9lst3jnnXcQ8xSzaIIsUrA0Do8OKNgWq9kcb76AHGRRZHdvl9BdIAg5/esryuUipq4RRgmSpiOIEpptMJ6MsatVhpMxmiZh2RZ7+7v85OOHbG1vrENiexfMRtcomspnn36Jbdvce3CPIAxoNdsIooi3Wq2lI9Mpnhdxfd5F13Tmswm1TpuDW7uEwQrL0qkUixQsg539PZxSGcOyOX/1cr2XqihYps64f8Vs1EfTDVx3ztXNOffffbhukW3t0Op0aHQ2WS1WzMYT3MWcLI0YDQb0b26AtyuvHxaS/2AF97W2TvjWnPVRXgPTG4rnd47+Zn/vm6rt25Vb/tbs/FvPvk+DMWwH0y4hyArj0RhNl2i222vgCmMGkyWffvWc02dPiYIYVRb40z/5iIKpIKoWsmHihRmyorOczyjVS7w6O2OxdJn0ugjEGJpCnmYslh6mppPlArJqImkaW7sHkAtohka53mBnu0kYeKiqijcbI2Q5O3v7fPXsOVESoakK+zvbXF1coFs61VaL23eOCDyf3/7uMyrlCp1WHbNUJPAWlKo1/uGXf8N84uK5Me++9y6NVotiUadQtCi2OkiqhiDA7z75CktXeXj3CN8N6HTaFCp1NtptFE3j8ZOn6LpJsVLDcYrM50vmS4/BaAqCxHQ8RlHXyQ4nxycIksxyPiFLPLrdG1SzgKZIlMsOuioxGvRZui4319dMJ32Oj5/S7w94dX6JLMlsdDYRFZ3PPvkERBG7WOLJ4+csJ1N61zf0b3ok/oqtnW0ERBRJplpromsa21ubzCdDhCTm5uKcna02tw73OHv+BMt2EGWNrb097GIBw7JxVzMEIaPRarOcDJnPFvzNL37FcvXPaQl/0Kg16yzmEyhX0OsdUjkhTBMMwWQurJMUsiTDI+F51OfYnzBSFKT9exQ/+FMOf/ZXlBo1jILD6ekrdNsCUWRnbx9VWwvYL89eocoStm3jhwl5JhKuPK5uhixcn1q7jWqYPPzwfS4urnCcEkkcUW3WqTdq2JUaKzchjhLELKfdatHZPiDwAixDR1R14jTj1u27KJKIpdtkqYBuWMynMwJvRe+mx2I6o14us5osiJYuRUMn9gPmkzlGocBiNkLVFAY3Pc5Pj0mzhFGvy9X5MXHk02g28P2IYrnB0dEttnZ3qbeatDdaBP6c7d1tVrMFtl0m8GNMy6ZYLGIX10nQL1+dUyyXaTWbeKs5rrdkOZsiqjrHz19QdIoULBN/NaNQa5BkKXu7W6ymK3SzyGq5otsf4oUh09GIUW9AHEUc3LmP5y1RNZUoiijXGtRrTZbzKXmWomsmcZShGyYHtw7XGWSKimna1OoNkiQDWcYPI1buitl8SffynDiMmM89ri+uaG7uUG9vcvvhByiajmYZzFyfydLHdX00w2Zr74h33n1IuVJnMV/R648IwoBqrUYuiBSrdcbTBYploBgG4+FgLdKXcja2dyDPKFWq5FlKEnncvr2/vllpbyDJCouVS47IYrEiyXM0VYEsZzK8Js0iomhF96rLdDxc111vEUre3lP77nibQPJ1E1L47pwf4GZ+R87wDTh+s1/3Nhvz7Tm/7/t8FxY1ywZFRshTGvUag26XUqWCUzCQs4jJoEcQxhRKZbIkxbAcHj05xi42UGWRLPIRUpeirZGnEbPRhCQKqVbK7BweYhcqtNodbh8drLcZlgt8f8WTJ8+J45R+95xSqchi4XLTu2E696jVm6iqiG6bLEY3ZHFKfXObWnuTyXDIxeUVQZyiGRqFok25sPa57Z4f03udslHQFXzXo9Js0NnbRzcVJv0rMkGhXK6RpQJpnNNqNLnqXvM3v/otgqgyHM+YBjBdzvnkk08Y9nv8f//9f0ZRLaI4RTdNRr0+1UYLb+lRcsp4QUQQpgRBRBzFSIpMrV4l8F3swlp3e3nRpdnpkAoSfhBSKBTpdDZpd7ZBVKhWG+zcukNnZ22AsAoSPv3dpxRK6yzBPI0xLHtt4SbLKBKUy0W8139Tqm6ycn3i0Oem2yXMwA8D9g73MQoWeZbhBQm1Rp3d3W1WszGqpNJsbyClLj/+8UeIJNQbDer1Gvfu32N408X8Z2uxP2x47motwo4S4voGiqgSSRF5khGTcBIPuAiW3CQR4s4+lQ9+inXrXepH9yhUqsTeHNOysU0TQxMgj5BUlXqrhSJKVCs1JEUlzgRmwxHbGy1EEdrbGwx718y9dYr6Bx8+RCDGqZb48N17+NMpKz/gF7/8FUbBIk1DnFKRne1djp88RRIFJr0BW7uHdDpbSJJM9+qM5XiEqmislisU02I+m1CuNVE0nWq9zsmrU1JRQlAUdrY6yEKKKmm4s4DlbI5h6Bzcvs2tu3eZTeZIqkJro42IgGPqvHz6JS9enPCf/uN/4rp7jWKYPHv8BNsp4fkhy9mCe7f22dna4Oqqx29/8zmDwYT3fvonpGGEqMh4QcjDH32EahoYtkWtVaNYLiFJKl9++glmocDsNdX/1p3bXJ28xDA0SqUqxBmKoqJbBdJUQMwzFtMxw34PxymgiAK2ZRAEPmmSspzOWcxmVGsNREFEAvqDESICFyenJGHE5KZHsVCgUCiymC1YrVZ0ry7JBdB1hThJuLq8ZDQeU2w0WExGFAoWs9GY3s0AzSyy8j0m8xkr1yUKPDRDZ6vTZGu7xa1bh+xs71ApVVnMViiqQZZmuMs5mqYyn8+4Oj9FUgz+x3/3P7Cz2SKOQkhTKiWb/f1d9jfbhH5EEMY8+eorxoMRk/GYz//htxRsh4JtMx4O8H2Po1u3qVWqGObrPbzfU9nB20QT4bWjyvcJK29Xa9+MN23Mb1dx3zx/W2H3FqvzbVDl22D89jnfwKMkS+zs7zOfzZhOZ1jFOkmak6Y5+wd7GLpC6C7RrCJeGDKeDNFNk8VyTm9ww9nZKzJSaq0aGzu7SKJCqdom8kIe3ruHH7qEccR0McP3VuiqQZQkFEtFiqUKhaJNa3MTbzUnixNOX53SvTzHW7jsHdwhz1Jc38eQJKqlEmnsMx5OEJBZzlxuLq/4zW8/pdHp4JSqJGnCq7MLqu0NrEKRwAu5ueqx1Wmzd+sO9VYDzwspWCq3DnfWlZio0O/1mC4mdFp1nn75KZZVeB3DA7quc/vefYIgJCen17vk+eOvcJcTjk+OEQRwbI0HDx+SZgk5AqoioGgGCCK2U6FYriJKGvPJFN/zWHkr3NWSIPAQxPV+paXpOLbJnTtHbG20IPJpN5toikrRLlCvVhAUBUHWaDXrGKZJs9Hg2RePcF2f6WjIxvY2k2GfRqNOFsUUbRPTMBlOJrQ3Nuh1r3FXLu2NTb747a/JBRFBUhmNp+hOiSTLuDi7otcbsbl/QKvzz04rf9CYLFZoqo5TKCA2aiTlCn6WchwMuYlC4laL1l/+Nc6Hf0bj3Y9xmpvcf/ddDF0FBEazJWaxgqzqhEnG00fPmI8HfPbrX2LbNqWCSafTRpBFojynUKlRrtVI8oRMkZGtAivPYzpf8vTpC25uBvyH//C3WE6daOVTLFaoFEp0Om329nZYLRe0N1vUaiXsosNFt8t19xrXdTk5Pqa1s8vKd9ne30ORRQxN5ehgm7u39ik4BTRNYefWAValyHi14vmLEzRdR1cl7rzzLlGSoBsm29sbpGmCF0QcP3/FuHdD0bGp1Bpkacz9B7dpNGpomkqt0aRaa1Iu2vjujNOzKy7OL9je2ULMAiolhyyKME2DcLnk1ZPnJHHOdDSnWKpxcnKOVSxSrlRwrBKtRp0kcAmDkM8+f0yl0ULWdCaDPsWiQxyFjAY99ILNdL5EUW1U1eCm26XX7zGaLRiMJxQbDZaeS6XVJMtjZtMJL49fcXX2ijSJKZcr3Lp1SKVaYXd7E8s0EAXIspxJv0suyDx+ekqp2WHY77G1s4Wha2Rp/tpdJyeOPAI/wF1FRH5Erd5ga28fq1RiGfh4bkjvpk+Sxgh5RhYGKHlOq1oBQcaPEj799a8o11qkWcbzl6+YzF0QRV48e45h2RRLJQbDIffu3sYp2NilMpppohsG1UaNVqfDweEtDo4OOTw65KK7NtZNk3gNJvl/WWP3XdiB1xXfa8H41z/fmvU2fH1/ry5/fYx/bPy+evOb6nDp+nRvbsiyBN0ymU1H6IaK53r87vNHJILCxuYWkiQQxTGWVWQ4muJ6LvPxhEK5sjZwHk7IEChXK+RZTvfqiuPjM9zxgN7NDePxBElREEUgy4iCFVubTWb9a+IopFip0W7UmfS7LFczZEWk3arS3tolCAJubm5wXZf9W3dod5psbW+xmq+otndodDYpOg5Fx6FSLhP6PpXi2olFkSSOjo7o1EtoqkC/f0OzYXP84inDyZTQd1FVHUUxKFXqhHFOs1ZHlg2KxTIf/ug9BqMRZ2evKJcK5ElEo7NJe3ODB+//iNF4QpTk3PRuWC0mzIc9CuUKJy9e8OMPHiDmEX7gMRoOmI96FEpF3MWcOIgYz5b0uhfcf3gfRZVZzBYcvzjl/OIK09C4++77+OE6gcJzlwhIrKYzGrUSN91rXp1dkaUZlVqFeq1CHIS061VanQ2mwx6SLPN3v/6Eg6MjAm/FeNRfx6sZFrpR4ME797l9e59Bv4+qafiuR2805Ojdd1itlqwWHnH4zy3NP2jU6jUWizGj/hVxljNsVbmRId3YofbBn/Lwv//fo1fb1GobrJYrSuUCkpAgkVK0dbLQo1iwsR0HSVQpOAUC14U8YzGf4LkuMhnVsoNVsDk5WTuoX7y6QJRlvMUSzw05P71AknUMu4BZKnDraIfBxQXkGSvfxQ1WTGZj0izDKVcZjqcIZMRBQKVSQpEkskyi272hf32FQMZsPGFzd5/L8ytend9weXZOp9OmVS0jCjKrhYdTcqjWChiGhut5zJcunuvx+ZdP0VQRQcyRZYlGe4soF2nvbZNlGS+en/Dy5Smr1YKbmxuCMGLQH/Bnf/Fzwiig0qhxeLCJpctkkc9sOuT2/UP2t9s4BZM0jJHzjFsHu0iCQKteZj7sk0Qp3iqmWKvT2dykd35GluVcX5yznE1Y+QGvTl/x8MFdippApVFm5c9RJBHTMGl1NiDPqFbrlMtl5osRkipxdX7GrVu3+eDuEbfv3KZUr2NXy5ze3NC9uebzTz5jNp7Q2txCliR2Du+R5ylR4mMVC2zv7XF0dIiIhCSJvHr5gsB36WxtYdkmkKLICSt3gSCLCEmIKonMFkuuLm949sXnpKHPxlaH1crjpjegubmBIgsohkWSxmiaxGg04uqqy8bWDsPRmFq1iqJInL58gWHoVJwCpm6iazrdi0uSHJYrl6++/IIvPvuM0XhBHEWYhQK6oa8X+Q8wVL7rZgLfAFj2NhC9McF86wP5d8Nd+W6L8pv67ofO891q8dsXmW/2DHNymrtH3Lp1i8VkjKVpJHGMquoUSiVURWRyc8Hp8UsWkxGObWJXyti2zcbmFntHh1TKVaIw5OLsnOuzY0aDLq43R1Z1bgYjdNPi7r2HyKJEwbZ5/uQZGSKyrDEczqg2O9iWxc3VBSEypWKFrc09VNXg099+ShjnBF7A5uYGWeyzWszxVz7uYoam5Ny5c5vIc3n6+AlBEHHv/l0aGx1OT87xZmOyLKF7c8WnXz4mTWKWiyWFSoM0yak2GixdF0OH3b0NstBje3eb0aBLvVlhPp1ydnWNUSxxc9Pjpj/BDRLaWztcXQ9YzqfIacBi3OPhuw+pNep0Oh00SaJSb/G7331KmktkeY5mOWTk3D7ap1yt8Scfv8dWq0Hgh9z0e/QuThFIUKWci6s+j58+5+r8FcFyzt379/GCiI2tBpqUMJnMQF6bTg8GA+aLGYe3j0DI+cUvfoWi6siKxp0H7yCLAlmao2lFTN3k4PA2x4+/JPSXfPX5V1xfD7CcAsPBkEariTuZUCkYCOQkUcJ0Mvv+4v6vGH/0LM3Hj55weOs2mqrx1ZfPSVSHrb/8t+QI1IoOqgj+ykOSFARSSrUqnruk1mpzdX6Bbdn47orFct1OSHyPNArpbO/iBwGZJHJ9fka10SRHIc0EBCTilU99/5BQDzE1kygNcYMVwSwicF2W8yXFWg2nXEKzTBRBYjFfImkmw+GM+XTK3q1DLl6eUGm3WE5GpIrEuNelvb3DcjZDFmE+HmLbDmEUkWYJg2GftBeR5xK6UaBQ0JFliUF/iChJTPo9pHTdAt3YP6B3cY5TsBGFnMl4xp37d8ijnOurVyAI1Np1ZqslaZ4ync257F4z7t+Q5/D0yy/567/+GePxGN20CKOE6WCM7djYtkqhuMvJ8SmT6QQBqNSqlOsdzs+uCCcDWp0G9Y0NZEXFjwIevvsuw9EYQZRxKmUqToGLwYzZaIYiqURhhG5qJElKkib4rs/+4RH1WoXZcMTOziaWY2OVKjx7eYIoigjimtW2sbvH2fEJiq6Qk2JYFquVTxD4TCfHaGLGRqvK1ckL7IJFnoR0Wi1028bQNFqNKl984RK6HrkkYZsGWewjkNLe2qZQLjCZr1itVrQ7baI0p7PRRshiurrOpD9kNR1TbXSI44xqpUqr5vDV4xfotk0QR1zdjAhcn9V8hlKvs3NwD02TyfIYs+AQBS71WonjlycggLdyv17nwltPhPwbUTesA1zfRAF9TV7J38x9+8OvW5tv0hF+APSEryHvh6q+bxNU1qL0b8YPySHCOOLy4hLDKrFYrpgNrplO1zeSTrnKztEdZE0lSiKyDEzd4Mnzz1i6HUqOQbVaQTdMSgWb/d0/5/jlS3TT4sHdOxQLFp9+9RRNUzl9+gW2U6NYrFCql9ZMUNNAdA1kGZyizXQwAFHBKtiYhs5kICOrOnka4pRKuL6LGkX0XhtHTAdDIkFEl0Qq1Srz2YyLq2tkSUIr2NQ3d8jzDEkvcHk9xLItJqMrOjt7qOb6O9u6xvWrMyqtJu2NDqsoxa40KZXKJHHCfOmSxjGaIpHJCmevTsgQ8BcznM0m7b1DZHLcpUcOVFptiGM2tjc5fvmKrXaLR48/Z6NZRNdKnJ9fIwoZp68uKNUaxEHIeDRFMRwUTefBu+/y6vKG0Bcp2iaKptAdjDGdIuO5S63dxjJUYkFjPp/yP/zb/45/+O0nnF2co1kG5YqDZuj0Ls5J04Q4juj3e+zsb2LoOkmUcXVxwcZGhzjNqVQqXJ1dEHoey8WC5WLOaDTDdhzieLr2uv1vOP7oKzwhSSjaDudnV+RZRqfVJvED6kWLre0NTk7PKZf//+z9R4x8a5rWi/6WXysiVnjv0mf+vduuqnbZ7mpzGmgQEtdITFEzASExQkwYIBAMELMeIIQVlyMdnXtu9700TZvyVbu2/fv8p3eR4b1f/g5i1669a1cDzSkmpfNKSxH5fV9EZiojv2d97/u8z5MBPyCVzXN5fokYiIQ0lV6njapFOHz5EmsxZjTos5jP2N67SSgcRRCVlfxWLE46kyUaixKJREjGYxTLm8zGK509QfN58eRHDHo9lvM59x7cxwgb3H94j+31NdSPpYK6nQ5Xp0fMp0Nef+M1ZtMJiXSCfqfL9t4NcsUi+VKZeCxBJJbi1q0biCKUKwXq58dMh13SmSyjwRhdD9FpNJhOHS7OGgiShmXZmIkUiUyaVDaDaztkc3mm0xlL18WIRqg3WrTbdSx7gSiCZ9v063XqtSsSyRSz6YL1rV2qlTKyorIMFHxJJ6yHmQ9nzGYL9FCE9999h0AUGI2GtOs1jk/Pef58f6UGP+6t2iXqDRJRg7s3t/CsGYahcXN3E0lW+NM//T7f/cG7yJKI5zkkCxlEVUaQNJZLm0jEQNclRN9hMZ7Q77T4wfd/SO26Tu3qGms+R9cNdCNCvlAiEoqi6hHUiIlpRliv5Jn0O4CE4AcoSojZeEE0HiedSBAxTUKxOMP+kF6ny3g8JpFIks+VmQ1GlEolNFVB8F0uzk6x5ksUXWM0nlBvNLk6O+b4YJ+jgwNe/8JbVKtVRFlFFETiySQL26HVHVLd3KRaLZFMZbCsOYLoEY5GyOZSzKcDzo73uTo/R5QNQtE47XYLUYaQYWAtP5Xu+RSafM5w/KcclE+uT8BK+Oyin7gd+MHPpjc/+/jTJoOfJbasnn2+dvfZx5/UAbVwlIgZI5nNo2oa8VSGTCJBPJGiXCoQT6cRBYFiocjR/itOj46QFZ1oPEa7O+Ls7AJVN+i020ynE6zFBEmSObk4p9HurmpUsoKZzFHIJLh5e4faxSXz6Rh3PmU+HhDYC+QAQpEQqqEynU0QgHjMpFDO0us26beahAwDXdVIJ5PggSQrREwTUdGQNQNNU7HmU2RF5+DwiPlywfnhAb7jULu6oNvtk8wVWU4nSKLMdNAnVyrQH/SJRk0830OVBBKpFLPxECHwGfS7JKJxkskEhUKWWDTGsD8gQKQ/npJMxBmORkymUy7PTplbS46PD9l/8YJev8+LZ4+JhEMYuoGm6iyWDgvH57JW5+Jq5VKejK9UnPrDEdf1NgIroYlWf8TFdQfXcUnEo5ydnCLKOq1Gk06jyag34Fvf/iH9Xh8dl+1KCTMUoVrI8eDRfazFjLfeeIim68QiBk+fvqQ36mPGEgzHU7zAo9PpUCwXcH2f+cIiEk9iWxbhSITZeEAhk/iv7u9/3vjlBzxRYr608AOPbC7DYjEjlUpSqawxnlqsra8Ri5voYRNRkrm6OMEVRM7Pa1Q39phOxuTLJRRVorxWYuv2XQqlIulUDNwlZ4f7pHM5up0O0+EQ0fe5uryiWEpTr12znC9QZYntvdvEo0kWkwmnpxdsbGxwdd3mxf4hp4cHjPttKpUKxUKBnZ1NapdX2HMbQw/huktCZohWs4XtBpweHzMcjuhNl5Q3dzDMCLbrUNjcJpVIks8VKeTSzMZ9FFlH0wzCEYPFbEIgCowXC5rtFk9++F0kUaS8tkGrdkW302GymKLoMvlCgXAkycVlk83bd6lubICkEApHqK5VcT2fbCnP6cUljVYbVZFxfQ/HXjIZDJAVHc8XUMIm23cfIEoylrVgrZKhWs5QqZQYDwY4rki30yGdzaGqKo+fvESQdJazGb4oE/g+sUgYeznH91zs5YJht8t4MODq7ITedZ2rkytS2TLpfJVWb8Z0OgHHZTIY4jsOjuPyzve+he9D5/KKdqNFbzBl7/Yddre3MDSdIIBXBydcX9Uwo2GWiymaqjAZ9phOJ1zVrhkOutRaDXqDMWg6qmESTyZIp03G8zHdXof5ZEQ8lUAWAyrlMkYkSrM35rrdxJckesM+Z8dHjIYrA9JOp4OHiO24iILEeDgins7hICJpCtniyrPPNE0MIwKIJJIpIqaJ9Jls5E9OZqv4DBh9OoPJz5zKfmJ9EPyUyCIIn90YPsvg/OnYz4KYz8+QW362qPgpkARAFPEDkWGvS+38mFw+RyQap9EecHlxwdMnz2lcN1FUlVwhR9gIkc0XmA07hDWNsK5x/HKfbuMaSRKZz+fEEkmi8SiL+YLxZIhMwGQwYLFY4ikGoiQjihKyrGJGwkiyiodIPJPBtl1CWphBt08Q+OjhCNPxlEQqy2A4otfqMhqN0TSDWCKOHtKIhWQkaSWQ7vjQa9ZJxCNs7myxvbnBg0cPiZsR7t69x40bu2i6ytHhIY6gsH90RDwSIZ5M43kBiqIiCgLXlzVq1w329w/RNR1dV5gMevRqpxSLORRJoFSt0Gu2mE4XLKYjQqpANKRSKRTw3ICwbrC+uUY4pFNZ36bTH+ELPgI2mUwGWQvh2iu3hXgyRTQWw1tMEASf+WyGGQrz8MEDZpMJF0dHnJ2ckykUOXr1iv54jm1brG1tIMkCmxtbvHzxilQqSbfX5cPHH/Hy5ITpwuK61ad+XePw9IrpaMDhi+dEYlFwLeKJBO3OgOtGBwiY9dukEvGVj6Xv89rD+zSarf/GDv/ni196wIsmEtSvr5nPJmTLeRRdp1Cu8OrgkGePn3B9dc3R/j54DoK75N7rb+AJUN5YJ13MYvkBRjTF1fkFEUNH/tiU03FdBElkc28XWVMY9HvM52PazWsy2SQIAqlsmsc//iGjTp9qdQPHdtDDUebTBX4gICkK6XwBw4ySyeVRZJlwNMZwOObFRx/Sqtc53D9AMzTqtSsEUSIZj6HIMqqh0u/1kWSNer3DYjZFkkV+/IPvEQqF6LRa/Mav/wrZVIhcpQCBQzKTJpPJEHzcRB6KmExmc+ZLC8e2GA0GtK5qxGIxJEnFdoOVk8F0QaPWZtjvc3V2huv7tLstIskk9fMzcB1s12U47K+YcroOssR0MsOxbIq5NJq/YH1ri+cvXpArFNAUgel4hOv7vNw/IhpLYIYjaKEQoZiJmUyRyZfxkdne20WWVFzbYzYa4NoLwiGNSCRCbzQkXy3iukus5YynH75HSNd58MYjJAkIAkbjIRtbm2yslZAlGVXTqddqjMdz9JDBfDpkMh6iGQZbt+6BIFColFEVAV3XiURjIKlk8kWm/S7JRJTpdM7p0QGICtOZzb2H9xCRIBBYzGZIsgQCjIcDOq02i+mCsGGiG2EcP6DeaNHr9ZlOZpyeXDGbLRgNR7ieh207NOsNfM/BtS363Q4fvfsD+oMhg24HVTNoNOofs/bgZ1vFf/Zk9Wk/1s+QW4LP19s+WfSZ9xA+B5Q/7/1+diL41E8n/BwwRhDIFQooisx42Gc2HmLNZ1iTHvZijONaWJZFLBIiHY/QalwQjcWImFGarQbLxZR8IYciq0TjKRTNwEwm2NxawwgZCIgM+z0OXz7FtpecnRzS63UIRU0cx6Hd7TMZDxE9h53tTQQC0tkUqWyKqR1wenbKZDyiXK0wnk4xIhGatSsWloVj24QNA0SBSnUd31nSa7fwBRnb9VnMpjiOzXg6xwng+OAVzWaL9UoZazYkrMlYC4fRxCaezFAo5Oh3ugyGYxAlBEGgUqmQzaTZ29lEkCTWdm/h2B7lcoF4Oomg6BjhCPF0kUpljVv3HmDbLutb6/z4h9/DdX0ihsbl0T6Cb3N0eIisKFyeHuHbFqPxEMt2CEfCeI6z0uiUJBLpDK8Oj/nw6QuQJTLVDSaDHoogoOsRzFhidQOma4yGQzQjTDKZ4cnBGWYyQzhiUkwliUYiSHhEQhHGvQ5f+NJbzKdzxr0Or1485eTlC5IRlcCZU6ysE4vGeP3hXXbXS7SvaxQqJSbD0c/7dP0Pxy894O3tbSMpOrF0hvr1Jb12ncFgRCgap7RWYjGfcfvOTVxniR/4DHtjnJnNcDRlMh6ztbVBr9dn49Y9rmstXNdD0XUGkznLpcNaZYNhr4+iG/h+gOPYiJ7LwZMnaKpMEPh4vs/+y5c4vofnuYSiEQ5PTjHN0KqJuNUAQeDlkw8g8JjMZty8d5f7j+4hyxKFfAFJEEhHoyh4GLpKJGRw/mqffq9HOp3m9bffJpdIks5kWS4XjEYjpssl1406mqYwny+xLY/m1TWDTgvX8Xjw1leYjiYspiO+/I1fIZtNMp+M6HW6iJJIyFDJZvMIQYAe1hAkAT0aw3Vc1tfWqGRyZNJFZuMp4ZCOu5zjW0tqJycossTZ0QH4Lr7j8Gu/+ZvcvXsDz1+JJC/nC3Zv7PEb33iLQjGLI0h88HyfQNKYT0ZEEzEcz6LVvGY0s5A1DSMSZjTuE4roxOIJBFFl5+ZdNEPHTMRIFjKUNrb41a+9yWY1j6EpKKqEoqo8fPMNXN9DUgR8HxRVYTbscHlxRqKQYWt3k3Q6Qa/T4eqyznA4pt0f0e+2kRSR5XyCZftEYjE0TUEIBKKJLPlcDkU1wHV5/dFNYvEYngeJVA7PcUgk06STaXwhQNFVksk41VKetXIePJdhp8Wg1SDwXMKRCIlEgumohxD4iEFAOpUgEg6xtrXFxu4WhY0NbNsipOvEU2k+k1D8GZDhk5mf13TwMRB+fDD8CSB9tvXgp2s//bqfPTX+3PiMAgx8mgUjfPwmWijC1vYG2WyGfLFCvpAnmkqytrHGF7/6dazJkEev3WM4GjIYzcmVqhiyQCgUJqwZbG3f4I0vvcmjt97Edx3KxTzXF5ecHZ8hBT6C75JI59m5eZv7r72J5weMJnN0PUzYDFMuFdi8eQtPUnn69CWKEcL3PXzbIRkNc+PmLfqdBktrSblSBQTCpkkuncJZLihW1tGNGI5tYS8XJNJphv0ekijgBwKdVgdRUhi0Wnz5a1+m06rz/gePkVSd7Z0tookYvX6PyWRKYHv4iPQHY8IhndNXzzHjMWzHo9FaOWQ8efqY3nDKsDfEULWVEMJ8iqpr/OAHP6LdHTKejKlUq0TCUer1Br4gkUklef31N1BlmTu7G2xubrJ35xaS4FMoFWg0WziORe3ijEG7SSIWY9CqUzs9QVMVUvEob37pC4ync0RZwbVtLMdlOnMBAVmGte1tTMNgOJpxdnLCZDpHU3QG/QE+PqPxjBfPXrJ94waaEaaysYnjOCQzBaJmnFs3tpgslvyv/6//lZNai/FoiG0v2dvb/m980P588UsPeI16HUmSyGSz+JbHxtb2ykvOsvFtn+bFOWdnVyiGhhY26ba7ZDIZ5qMRuXQaZz5D8FwqpRLN+jWGEaJ2UaN7fU0qmeHVywOa1w0EQaR2cUqhXMaMRYmnU6yvr5EvV+n2+hTzOXY2KoiBTSIaYTwacl2rIQYBpeo6k8EQQdKY2x5L26HZ7nLw6pBsqUJ7uFJDmEwGtDsdkukU/U6PRCZPq1HHtRbcvbnL+z/6EflshsmwSyhkcHpyynQ2o1GrMep10VQJRRbJ5bLIgofrLjHMMI7noioCmiQSj0YxdIVMJsV40GM2HxM4Aa3LSyrrVdKZLGenZzi2x9nxCYNBl0gyTaPRYW9vm/W1IppuEI0k8Owl8WiY2XLJy6MTTi8vAHjy+Amu57Kxc4Nn+6cUc2kC16LTatNr1tEVGdGzmQxHzJc2zesmpy/3MaNx4skMuhljalkUq2U21opMJxP6zSaNqwa2bfP41TkfPjtg79Yek0GL+WTCh++/z7DT4Otvv4Vphtm7cxMQkAKP6voGtgCD8QhFU+i2u6STeWzLoryzzc7OFpqioKky4+GAJ++/w4snH9Hv97m6uqDTuKLZ6vPRhy/IVyoomo4nGzTafabjIb5vs5iM6bQ6DIYTlsuV+4amhxAkFc+2SMQTZLJpkskU6WwKLxDwULAWDhE9hOe4DNs9Bt0etu3QbdaIR81PfdIDEIRPw9/Ho8HnvOqCgJX85qeKesHP0jL5mRPaz04Kf3aN7+djocAnzrEfg6yshZhZPpW1deKJBLKikcvmsFybg4ND9HAEy/EZj8c0mi0kVcPyQVJVUBUa7RYffvCCs5MzFE1jadtIssF1vU23N2TpCKSLeQ5evaJ2ecp01GM8HJCKRpAlidpVDUXROT85ZXOjjIpFt3nNYDhiOOjRvL5ibWcP13aYjsfIRhgpZDKzPQrrWzTq10Q0hdODA0rFIrt7u6RzRVRBJBYJMx4NUBSZQJQ4ODjDtmwSqTi24+G6PqlMAcde6Xa+Ojha9dImE2xtb5IrVwjwsRwX17G5ff8hw26fZFSl1WnRqteJmQaN60t8d8FsMmSymHHw4jntVodv/Po3UIIlpWqRwaDH9779Hezlgkg4ROD7jIZDMukkh88+YjoYMur1iWfXSORKDAYjbty6xa37d4nEYpydXfDy1SmTyQhd19AUnWg0SbfbwUymeefHPyYcDTEaDojoKtlMhovzC2zXptftYFs20XiSVrOJEQqxWFpsbK5z89Yu6UwC3/d4+vgp+XwOTVVJZ5LcvL1Ltz9kGUh/9ub+PxC/9IA3GY4Y9jscHxxiREwW8ymjUZ90NoMRMqju7jFdTNm5uYOqKNy4scPR/jPG/RbRSJjr+jXhmMn+s2esbe8ynU8JGSq/+etfp1It4gkQS6UIGRrJbB7PC+gOxniCxNnpOfcePiCWzjKZzmk0mmzt3sCMRJCATK7IfLbk/PAIe7GSr2rWrohFw6iqhKRKKy+7xYSbN7bZ2FpnvrSYTpa0Wx1CiSTN+jUfffSYg+NT7j56jU5/RCiWwUYF1WBnZ5dUMsGNG3toikwqGYcAEokkqhgg4eMHAgcHx5TLVX71m19nY2sTXde4cWuPbC7LaNAhGo3Tbg/p9nuMB12CACbTCYlsEkmVmS2XDIdj3n/vfQb9Drlinlg8RWltg/GgjzWf06zXKa2vbgB2trcgcDk4OCZsxtA1FU3XMKMm+XyW+3fuYMgBo1aL9vU1RihEMm6SKWTQDYPz03OefvQRLw/OmFkWETOEu5wh6TqXjRYXZ1cIokIkEmdtfZ3aZY1er89FrUGnvWqPkDWVcCzJ+fEFsiBRLRcRJQlBkhnP5vRbLRbDIaokoqoKyCJqOMKjt76E+XFq7c6dm4TNCAIesiwzHI1pXp8xHnSZz2akMhkQIJPJU/jY2ysUTXB+USOQJEqVEq7joYajBEgMp3NqF1dc7j9hNhnTuL6gVrtkMhqztGwCZ8lyPmdhudQbn65v/LShHD4POp87rQWfnftJGe/z/XufreF9MhasTmqfQOxPSC5/JoB+ig4arF7vCwKH+y/4/ne+zdnhK06Oj/HcJeulEmYkQtwMk0kl0fUQhmEwGvSZTiYkU2kUUUFVZJIxg+lkzMXJCbIgEgkbSKLEsNdn0O8zHE4JXJuNzV0q61vkc2lMM0KxVEaSJDRJpF2v8fLogkgsSdiMEg6FGfS6mPEE/W6LIAgYjcboqoLoe2wUU8h4+IFPezhgMh2jG2HqjQa9TofDg32G/cGq2V9SGPc7xOMm5WqRcX/AnVs3+P53/4SjV8/xvSXJZJRGs4Xr+iv/uVGPeDpFr9Om06jx/rvvs1gsSGUSpFIpBN9mNptSXlsjGk+RzRZZ29gmHU2wu7vLi2fPqTdH3L37kGQsxnJpsba5Tq5Y4unBOXPLYTaZsr61iyAoyIoOgkSlWmI6GWGEVYajIYvJhM1qlUQyTuvyAseySBdzyJpMvXZONBZjNpoQjafodPpYjke+mKG6sU6AwHw+5+aDRyTjMb7x1dfJ5VI0ateMeh2ePn6GETbxHJu927fp9/sU8mnuvvkWa9UKrz14wMnhCaPxjF9k/NIDHuLK42z31i6yKjGfTpiOBpwdvcLQJGRVwfd9Ls6vmIwnJNNZzFiC7b0bXF7WyBXLhCIR+r02rmNzdXZGb9jne+/8mPG0z/beBoNeF8txyBQqyKqKpmqEwwaqsart2Ys53V6f/mBFs+31eqTSSZaLGbbvU1mvcv/RfXa2q+RLxdVdmBtgRtNMJlM6jQaZfA7b8yhtbeB6LolUGt+1yVYqiLKEtZxzY2+H/nDIbD5jPJpwfXGF44kM+6NPrFMK+SyaDKKocvjqiGw6Q2DbKJKIoqlcXjd5+vg5w8GQxdIin01TKOVJpeOslwuENAXXcTk/PWW5XCkx2NMxnfo5ludSWt9k48Yder0hTiBwdnZBxIyRiMcRfbixvcHW1hpPD445Or1kuZhz3RrQ7XRwFhMUVWW2tGl0hmzt7hFPZwhHw/gCuJ7D6cvnJJIpQpqCIknM51MiUZMbd+5Tqa6Ry2YQPJfFZMhsPKVxdc50MsaajVFCUT766DnxVApVU7DsVd3C9T1ql9cc7B9z9vIp+VKBxXxOr91FMkI0Wh2y+SKbaxVCkTCeouN5HgQuT58fgqgRCCrtdotCIUcylSGdyZDKZjDMBKXqOmo4jBEJMRn0WM4n6JqyqpWKIuvb23iOS+3sBNe2kBVlRaIShZUBqW4gyyKTyZBkNo8ZiyEK/IwN0Gd9537SVP6p6U8ePwuNn53+rKbmT4DrJwzOn4wHn7yH//GaQAj4XPMePx84PxlTNJYLG0UPkcgVuHd3j3K5wH/5gz/AtlxmC5dms0nt4oh2u40gypwfHdBsNRkOOuQKRcbDIcl0FkSZ04sLZuMJ6XSCXKnCeDxh1B8QiDLDQR9N0+kMhhweHXBxeoKuqbQaDeLpAoV8DlUP4fs+b7z1JtPxhP5wjCwobG5tIggBjctThr02BycXICq4lkM0kkDXdWq1SyQhoFTKsbuzRWmtwmI2xnFtwmaUy6trRpMlgqwiyCHWqxs8evMNMsUKuzubpDNpDEUllUpxeHhGNJFCEFVUI4RhhPB9MKMxrhstFDWMrIgIogxBwMXFGZP5goODlzSbLVRdZzJf8p//0x8yGU24fec2tcsLcvk83XabsBmj225yvL+Ppquk0gkiEYMg8PBsG2sxo1DIs/Tg9Ly2kgPbWmdvo0wlm2ajWiaXS5PIpLBmIyKGhiwrGLEkR8cXxGIJdN1gMFnd5J+en/HtP/0W/U6HXqtOIr0SnsikkxwcndDpj4ln87w4PObd73+H6XDI+VWT5WxKKfl/tSX8ueLs9IzZbI6KCMs529tbGKEQnuezcHxmszmReIzhYEgmnabbbaPIK1WHi8vVZnl+eEhlc4dQLEahukaAwPVVE88VWU5sYuEQiWiUcb+DbU+ZTAYsZ2OWkwkfvvMOAh4CFq7tcF1rsFjM0RSZVqOGboRIZHLU2z3e/eApzXqL509eohkRrPkUTVPQIyZPnh9x8PIlvVabuWVR2VhjPpmgKhqxeJKzw1f86Ic/oFmrYZpRQqpMJpliOpszcz0kVSEej+EGICkKzXaTbrdHfzBiOp4iq2E+fO89Xj57jiCIXNauefzB+1zW6iwtj2Z7SKvTZ9jrkMhmSWRSvPaFNyjkcxTLFUJhE9vzCESB3c0qnmcTTyZW4ta2Q2cwYjmbM5/OkUSFrbUKkXCYSDiCZc2x7SURM065VMH3fF4++YDHHz7m4RffQJEFHMfh5ctXZMtrRE2T+w/u8Zt/4TeRVZXxYEB30MN2LHa3NlCEgN/6S7/JfDbmjS98gZu7W2zubBOPhrhz7y4hXSPwA1xried6uLbN2uYWy+Vi1cJgyOiGjuPaBAH0Oj3GwyHdRo2zl88QAw9RCMjGDZLxGMl0GtMMUSiUScej5LJZRt0mg06Ti9MjDl/tMxr2WS6WLGYzZuMxqVSKaNjA9QPmiymaoZIv5Clkk+SzOZaLBa7rMRp0iSfjxDMZZFEmHDIJhULoYRNVMz7fFfcpYPuEfPmTqZ/Nd/6c+BxkCZ8SI/sECT/llfdfOzp+/PVnT4wf8zgFge0799nc22Zza5NO45o/+oM/4nvffYdypcLDR/ewbIsABVU10AyVTD5HsVTkxu4OgihycXHCyeEhhq7jWVN8z0PSdWRF5I3XH6BrEuCiKDrjyYRwNIKmKITMGIgSZjQKgkixWGDQGdJqt7m8qnF8WiOWSLK7t0u9VqPZ6lEor7G7t8OtBw+YTibsbm8QT8SZTQbIms50MmE2c1aiALE4F6dH3Lp3F1EQCcVS+IJMNl+iVC7j+z5GxCQZNckk4vzgB+8xX1goqkA4rFFeX0NRDRRdYTIc4tpLQrqKGYliuz6ypjOZzGi129iLOXdu7fJrv/I2ApAtVREkBUnwiKaSvPf+hzx5ccT9h/eJRgwsy+Ly4oxQxKRSLfGrv/YNVHkl8baYjIklUzi2SyKVxHUtookorWYLSZGpbG4hiHB8fkEmm8Vdzrl1+w7ddourszN8e0b3+pwffP87uM4STZYRkDETCVxP5O6j14nGY8TTKfIbe+zvHyFLKt5ygj0fE9INvvTVr69E0UURLRTm8bMX/5Xd/c8fv/SA9/rrryN5AovxnO3tbURZJJpOY6Yz2N5KcyKwbQatBvXra45fHRCLpxgOxuSLRcKaSuD5VCpVOq02S8tG9ALKhRL1ywZX55eoikG3O0ASJRRJZDQck0ym8N2A9a2bRKNJJqM5qVyJTv2axsUV9XoHSQnT6w1Wd5+qTNg0KVWqxJMZTFPDcxaEwxqapjNsd3j9jS9wc3ub5WxOEAQU1qoIosJgNGXv7mug6KSzOeLpBJGYSTZfpt/tMug0OTs9Y750uLqoIckKjmNT3NwmFI2RzuZwbAfLsohGDARBoFosMR0OUUSBbCrO9kaFIPDRQiaO49HudOh2+nz04Ue0Gg1i0SjNqwYvXh5xcHKBpipk0gl0M0Iik6HbG5DI5pAEidFoSiwWp99pkshm6fe6JFIp4ukUCAKhSJhoIkkyFUNTRLZ2thAEn0GngesJ2LZFo9nk7KKOKCr4gkLjqoMZTREywqxtbCIgEgqbeB68PDij3x9TWd+i227huQGnpxes7d7CF0Vu375JuZinXK6iaSq6FqZVX5muxqIrqbMbN3aYLpYIokAsHKJcWmPh+Hz43o/BWaLIIv1en+9/93u49sp5Q5BUdMPANMNkc1kSsSiL6RhZ15hbNi9eviQeT1EsrDRPXc9jPBxzcnBANJ5cudqHzVWqtNMiEGA4HNAf9JEkGUXVP8XPDD6XRvwJMTL4FOL8NHX5WaT6bH/cz09j/tm1vs+/9lMUlc83nIsikVQWtDDNZpPRcMx0PCKeylCpVljYDpYTEI2n8X2fbC5LKBQmaihousbSsXCsJbKkkMzkSCSSrO/eQpJkxMCnfV3j8rJGOpPhxq3beAHkcnlarQ6GKpNPx5iMRwznFtfXq9Sypkks5kvi8TiOYzGdLdBkFVUP0axfsVzMubis43kgyDLf/vb3cWx71TaTSLKYj7mxXUWUNc4uLul2+6iyStSMYC8mRCNhFFlk1GvT67XoD4ecXdW4btRxPBcUmf0XzxhPl3i+QLdeYzEeEU0mufXaW5SLGSJhA3s+x4wnUOQwiqShGCEePz/gvScv0cMhRr0O4VCIwPNQZQlnuaCQz3F88ApZkQlHTEKawubWBu/96EeMx2N6nTaZdJpcqUwsHiOdiHF6esGw06Fdu8KzHVRRpNkZ8Z1vf5/29TW1i0sQJNxAYHPvFvF0jmQszpe++g0cy2F9+waJZJy93XU2KxVmswnf/8632bl1i5CuYi3nTKdTGq0O08mERw/vs5wviUVj3H1wh8NXh2SyBRzb/m/u8X+e+KVXWul1u3Q7PULhMM1ek3IpS9SIcn58imu7VLe2adbOuXnvAaP5nMrOFoKmEo1GUVSZo+fPiSWTfPjue0SiSTbWK+iawqAzxPECOt02mhkhhEgsGlpp44kBnd4AVQ8RS8RZLKb82m/+Bu3ukFw6gS9K9PpjAj9gsZjiBBB4Pu3rSyLxJJFoDEEOkcmIJFIp5kuHuJGl2xvhLCZ4rs3JwQG7t/bA9dAzCfLFAp0nPaaTEZPxhPFkykJYrhiCfkAimaFeu8IXPARFIRIzWc7ntNtt8vkss+mUpfWxxc9ogIdPvrTGdDJDkmY8fP01/uRPvoXnBniew2IxQwR8e0mhWGI+XxIxQdMNLs4vefDgJpouIgQ+l7UaV0evcDc3mM0XCIHI/uEpti/Q7fXwHIfhcEEQLBgOZsymYyRVY31ri/PjK8Ihhdu3b/Hk8VOmoxHXokBlc41BZ4Qm66iGxnyyYP/5Yy5PD3AWM/RHj3Aci73dba4aTW49uI0oi9iuS8oMcbV/SMQ0iUXCDMdD+oMh/W6byuYm7V4XRVPJ5nPYjsdyueSd9z5iNOhS2b7BYDxh0O2SyOUIxWJIqgaeQ2m9Sq/Tpd8fEs9mEQSR8XCw+v0GfaJmDEXViZhJxsMhshxiMV3QadVI5bM0Lq/oNK8JR1MkU2lG4ymDXp/LyxYgrQSnXY/ZbIyo6ASCvEK1T8mmfBp8hJ+DWT9fGeUnacpPU134FOvzJ7D6Werlp0f41KrgZ1eJErKiIqoGidIWGzu7RHJ5kDVO918iCCIP3/oyGxtV1it5/r//6Y84P7vEXs5YSBIhMwmuS7fXp7K+TqlS5tWz50QiJsl0Cl+ApWWhqAbFcoXa+TGIIEoihioS+D7N6zqxRBI9HidQdJK5Ao7tkCmUcBYz5CBMKZ1gd2+P4XiCENjUrq+Ix2M0G3XCkSiO45IvFggZYbKpGJFolI9+/A53H7zJ5eEBluuhfeyrOB0NePnqFdFEgnAs+jGBY0i/OyCdyzAYjLBdGA36OIspaxtVDpoXtK7rhOMJrPkMTVVQJAHPdTm5rLNcLFFVBdd3GAw7KJrMcjYhHNGZTub4loVjLylV1qjX21Q3t5nMZthITJbw/ofPyFeKPHn3XXxBJFMuM7c8nECiXm+jqDKFSonRZEIoEiZbLDMZT7hz9w7tdpvLq2sc38eybQaDCUvbZTLs4Ysy2XSSo8NLEqkcqmZweviKbKHAbD5jiUgslUdRQpwcn6IoKm89user41PMWIKz80s++vApxfIa773/mLt3biAIHrs7a/iuxQf/Ixv/nxG/9IC3dF1u3L/FuD/CR8RyRMaTPq5lUyxXEYWAxXzCZDrn6vSEm/fv0Wo2UQQYjpbs3L9PJGJycnLBbDpk2I/S7XQIPJtwyEDwLcYjC4WAdGqb0chh7849prMl1tLh4vSESMzE9j2c5YKt7U1e7r/Cno9wrABVM9A1nfrlBTfv30cUReazKa495eL8FM3soYVDxGIp5tMJw36XfCHHbLZkObOwZnPG/QULe8nccRAklcAH217Q7XZZLjLkiwUCUSZVyCDKCo7l0rm8wF0ueeNLX6RebxAAeiSKYBgwm1MullivrvH8yQtMU6XVrONaU7781a8wGozoDiYMhlMEWcMPAhrX1xSra8RjJt2rA9q9Hk6rQzweJ5FIEf/SV5FVlZdPP0TXwgyGAxaLOWbUJAh8BEVGDGBzrczRwT7dTpOXtoumhYjEs0ynFrlCiSCA6XTC8atDZuMx1mTB5t4Nxr0OmWKJ0aDPzu27vP7gDv+f/+P3ee4HdPtdEqkEp4fHTMZTRATs+ZLryxq+a1PdWMP1AhK5JKlMlNrVGel4lI3NNU5PrxAVjfl8gSLJ5BJJ6u02D15/g3azDYJIp9fn6FUL13VIFcqs7WzRa3Xw/IBes4ERCbGiBwUIosBsNKLXvCJApH1dI5FOIgkirr3EMONIqoJiaDidBoVShWGvgSwJxNMZrPmUVDrH9dUFmhFGDSewpv2ffuB/gn38WTC1evapTCeffvGqJgf+p8DzpzW/z479LHjy6TlRQglFMaJx0uVtUqUq3W6bQqnIg4cPePnygNmwT8g0UYwQl1eXGKbJwcEBsWiERCLOwXGPxtE+iXSWg8YVppkkk1/n6UcvARk1EsUa9ShlYrTrIY4Pj1lm09i2xcJe0uu2MSMhFAlcz8NA4OzwAFmUcawlWihEgIgcjWB7Ls3LM6bT6Yogko6jmilGwynaYkGuXOHy6IDFPMZgNKbfba56Kh2H6XzIsFtnOBrjSyp+IPH6V7/OWqnI5XUD14fry0vkhIqiqSiqSjxi0GnVKVQ3yAUu6XiGfmGdWCKKJKu8PH1FsVIllojTrF9jLeYUigWi0QS9XodUNs/N3XW6H5NyysU8P/7x++TLFRLJDJIo06zXicQTiHgEgrdSHcplqSUTpONxjLDBYrZE8FwyhQwnB0coqorrWCwJCMdiRONxWp0+o/GqVppM5egslpRLRTqdJrdu32X/+TPW1qsogsCdezc5PItydXbCbG7x7jvvUtnYZDgakM3mkGWBi5Nzfvj+cxaLOamFze2dDZ69fEV3NGAyGXN+WaNQqvDujz9gY2f3f3Tr/7nxSw94mqogSSoeMqYZZTgYgO8SjcWwljaqIrN373Xa9Wt2dm7iWjbhSAQNqJarHB+fUK/VGQ4GuM6CizMHXVWJpzOM+z3m8xnhWAzTNFnYSzLpFLbrc3a8jygo+AHoJPjg/ecUixn2Xz6jdX2NHo7Q7XaobN2AICCWTIAi07y65O7dm7QbLTa3b3B8fIIWCdOoXzPqdnjw8C5G2OT0+IThYEirfg2isFI1d32SmRTT4WoDNKJJ+sMekWQazZBZLJfgzVnO5ty4dQ9NESjm0tTbLWKxOJIs0R+MiKaSvP/he8TNNN3uCMXI4I+n3H/9DSRFAVFCUVfmkrFkmsl8zmtfeEQ4YtK+brCxc4vixjqKJFPNJnn8/BWz8RDX9Zj1O6y9sUPz6oobu5tYrk8hn6febOF7Phdnxwx7Hda2dnBti0Q6SyhkcPj8GclsFs9zkWUNz3dwrDnJbIpSKUcsbhJNxPjBt+vsP9mndnZKKBzizq2bNFtdEBWWlk0ynSEaTaKoGplcjsurS/r9Aaqqcb1/RP2ihu8JaFmdWq2BpskkEzEsN2A27tNqtjg9eMl8PMB1PazphOraGov5jGI6j+dbJBJpSrkC+y+e47ku4ViSUb9Pt1FnMuwQTaWAgEQyRfvjlFq92cQVZGKpJM3LUzzPI5nOcf/BXS4vLhlN54QNjfc+eo9UoUq+ssliOia9tkvz4EM81/5s2pLPnrY+D1AryPNZaW1+GiQlUfg4dfm5s9rn4hNQFQS0SBRJDxPJFkA2SOaqOMspsUyB5XKKqqpIaoiP3v+QTq3G5q27nPc6BL6LETII/ABPkLFsn2Q2h9HoUAzFEUSITOfcuncPx7UYDDqUN9aJRqJctLp86zs/xHU9zFiEdD6HJuXY2t3kIqyzXq2g6jrnZzXSiSjWfIQZS+EHAuVSntliQb/fp1jI06ido4d0AhEkRSNmRui02/Trl9y+dYOOruHZSzRNRwjpbFQrjAc5VD1CtrpJLh3n7OAl8Wye2dBiEIowGM6RBREhCIgnIkTNMNtrJeqdEaPRhFwqTrfbYTAeooZ0djYqyLICjs1bb77Bn37n++h6CNcNmC0sxtMlVyfH5IsVzq6a2J7PfDTg9PgIUdVwfIfD4xMUTeb41Qui8Qwb6yV2t1Yp+V53QGlji5OTC4bdOo++8DaLxZRhy8WMmqu6upnh8YcfsZVKM53MaNausecjUokUku+gKipnZ5eomsLJ8RE3bt3EdQX6owmHR6f4+NRPD7jzxhcRYmEmgz6LyZipbpBIJJAFCUGEVCrJ9cUphVIeXdfAd7l56xYn+y9IpXMIosLzJ09+QUiwil96wHvw6AH/+ff/gHAsRafdwTTDPHz0kMuLK9qtJqrsY3k+i9kMQVSpXZ2jKQJr1SoIIolEgmKpgK5KdPpDXrw6RQ2HWFgz/CAgV67Qrl8juyLDyRLfmqLoITKFMhcH+2zevIsoijRrbSaJEIvhkMrmLo16k+LGFkZIZ9BpsrGziYtEIKqcXzZp1GqUy3kq1QqurCMGEr6zwJcVBt0epUqFfr9PNG6iGGHCpslkNKFQLHB5doazdBAlAce2GY5GyJMJZjiC61kIuoEZjzEYdvno5TGT4ZhRv4/ruMQzBSRRRDWjFKqlFcvq5JytrTWqpTx/+iffJm6abO7doF5vYds23WYH1wuYjoeEQxGq62s8ee8DrPmU6cOHzJcLHr7+kFf7B5TWNkGEbCFPpVql1exydnrGcNAnlU6zmM+JZHL0hn1CikoiEWE6X6LqYVRNoXPdJBSOQuCzs7mOqJu8evGMbD7LqO8wGXS5cfceQuAgKjK9wYhoJIYkyshALBZlPhsRiSZYWHNsa0k6X2A+mZDK54mYyRVb0ovT7/Tota5JF8pMJmPMRIa546OE4lTWt+m1O6ytbxBNJgiEgNFgzHIyIqRrHOwf4AYCtjVDEMFdTklubxMgEiCQLZRIZwuIosR0vkpT91ptLMvB8wPEwCMcifLy+Sv6vTbReJzpZEEyX2Zze4+ri2Mcd+V9Fs2WGdRPAT53cvs8yK3C/3hEQkASV5U2Pwh+en0G5Faw9ml2pyAIyKqOKKskS1WiuRKqEaZQ2eDxO9+jsrmLEYnSaTiohk6v02BzexvXAVkLo0aTzBZLlpMB8/GQbqtJtbpO0O3iKQLXzQ6BIDLutyhV19CqZbzAJ1/IcXr0imL+ziqT4SxQZRnP9dAjUTqdLqV8Bt8TOHz2nPrVNa7rUTs/Z2ktcawF8VSe5nWdwXDMbNxluVhgOR4RM4aiKgSuw+XZCZKiM+i0iKVWGZVwLM18PiBfqvLRj39AMZtmtpggCi6BD9eNLrFUBlUxODl8gScqTMYTQobBxvYu9doF49GQbrNGKJpe1eAlCUTwfIdxf8if/sn3KFQ3CLyAZqfHdDxENULMZjOWiznrW1v41W2ymSRm1OT87JSvffktXr3cx1c1zk9OKJQ2mY7HGJEIdx/cpdNu0e50mNou8/GQ5XJBLJUj7Fp4bkAslaVROyMSSTIZDDBCBuvr20isNFtlUUCLplClgN27N3jybB9Z1VnMFyxti8lsieH57N28xeHBAd/4ylvoikSpXGBrrcKPfvyYbK7AwcsXxFMpNF2ilM+QyubwHYsP3n2fe48eMRr20FWVfLFEOhbh7HTJcvyp7MUvIH7pSSsH+weEE0lu3LqBLAGCv7K0GA4YDXp0+0OaVxdEzTiRkIqiKGSKVRa2R7vbY2lbvPv+U569POHq4oLJYNVvEgnHuPvwEaFwmFypSiKXRzdWjcQ3dzcoFwq8+ZWvs75RZWFblLe2mA6HJDI5bNtFEkVScZNxt06pUsXzBDrNNmooQrfbJ5HJk0gkuXnzJhvlIpFImGQ8gSqpyKpGNBaj02whqQZGOMx8NmE27mHbPtOPpbQkEYqVKqos0bo6pd9rs7DmeAK8fPoYRdZQZJl0oUQmneXN1x6SiEaYjsZ49qqm41gLYtEonutxeHTOeDgFNUKzPUJXZUKaRDhs4ixsbNsmXyriBxCOxgmns1x1Biwth3qriywI/JW//FuI9hJZlmm2+sxnC7b3dtja22NrewNF13CXS/rNNoPRlOPjc14+e8lyMaN+UUNTDe7ef4iq6mzduMFrD++DKJDL58hm0rz15bf5+lfeYH29go/Mk8ePkWWJ5WxMPFsgCALs5ZzdnbWVmO58xnq1RERXGfcGyKrKcjoiFo0BHt/8X34Dy/HRzTiSamC5PlEzTLvV4erigulkybs/+AHPP/iI2vklxVKZZFTFiITodDpkKpt4jk/ENInoMoV8Ed91kRWV2WTCsN/BCMexbZd4ukAyk0VRVLL5Ar32NcNRnwCBpe3S6XSRZRkjpDOfDJmPB2RKG8QKmwjS6t7159XUVhF8rLiyqtQpCCgfP/f9AM/3Vye9nxOfNKBLMooeIr+xy84Xf41Hf/H/TvHhl7n1pV8hni1x//W3EASJfHWdbCGLqogokoKmqMzGQ2zfRdVVPNclFo8jihJaJAKyRFjXWMznH4ujm2xWS9ze3WRjc4PJeITleLR7Ha6urzFTZdr9CXokRKlaZffmTUqVIoHnMu4POXi1z4ujM5RwFNUwWdvYIZsvcuvOXeKJBJ12A0URsZYTwvEYzmJG4C4JGSqGEcLxIJEusrRcEskMb3/pbRzLAT8gmU6j6GFS2RKz2ZLReILjB+xsb3F7dxff9THDGvfu30GXwF1OWC7mLCyL4WCIZkRx3IBELIbneiyXFr4v0ag3GXTaiIqGHjFX4uPnZ8iaiqEp5LJZPNdiulwgKhKDQY9AkllaSw5PzhjOl9QvL3HmM+azEQIB4XCIxWJOsVRmNrMQg4DldIzvepiGhhmN02jVEWUVI5JEVlQajStOLy5wgE67i+85+MDmjZuk8mXq7Tb9Xo/pZIrl2ASCiKRpOK5Hu9XGMML88Xd/yJMPn9Drjfjg2RHnpxekEyaxaIT6dQ3v42xLo15nNByxvrlNNGpi2RYbpSSvPbzL+fkxt/fWfqb15v98/NKf8C5Oz4nGEhy8OiKZySHikIhHyCZ2+eFoBr7NzRs7hMwo69UCk/GEjWqJ6WjE6dklVxeXJAtV8uUSpi4hq5dcnp3gLuZ0Oz2s2YTNrZvULk9BlDEMjfHc5dnTZ+QKK1fwIHAxDJXAc8llUyuWnCIwHPTQVBVdkzg+PmTQHZDMFgkCKOSz6IZBtz9gNBpxvP+SwlqZ08NX5ErrzJdz8OZ4nkPgefS7PTK5LEevXmDGU9huwI07t8il0zx5dshv/MX/hat6i+lsjmt7GJEYk/GYbqcNgYdhhLms97B9DyHwKObT9Ls9jGgSVdeZTZeo4QiubzMcDOi1WtjOktu39uh2BwiizMZmicFoQv3iktuvP6Reu0ZTdSREIkYERZR45/2nSGqI8lqVk4NjpsPJSuRXEglsC3yfm7dv89G77+EHItPRAk3VqGxvM55MycTDnF9eM5kteXV6haa18VyX995/jBnS2Ll5kx+9+yEiPvlUgsN+n6ODF4TDEebzGa5js7G9w9HRKbXLGplijlrtiuvaFdu7uxTKBeTgDVRFAVFlvvTwrBmTsU0kHEGSAzKFNcaDLrqhYHsOZjKD6/sUS2vUa3V+uJxRXd/i2LVxFg5ze0k8nsBxA64uTxgPx/hBgBGOEI6nCBk6V4MuiVwR3VCRBIFkzGTYbWPZqxTSoNfCtZc4ixmtZg41HOPW3g2a13WMiEksW2LYuPhcQ/lnn/90xAt+emL7eanOABAlCVkLoRlhAlGmcusRtueTzuRRQxFMQ6Z2fkmn1cU0Q9Rb1ywmFslcCTGA7vUVo8GATKHA1o3bLC0XdzmheX3Bo0cPODl4xa2794lHo8w6LUTfZtgZYlsz6pE4l6fHlNc2UOdLYvEkgWPz9N3vs3XvNWaLMU8et1hMhjiFPJFkmrjncufuHR5/+BHzxZxYMsV8NCB7c4fDlw4XF+eMBn3ShRKqEaF1fU4yHmegG2hGiFG/y9e/usO5GeG73/0+N27sMeq3ODoSKZQqjId9zo4aZAoLlpbFfLbE90XOjs+Ixk3mHvgiSKqBrkRZT5sIgsrx8QGJdJpwROf2jW0sy+b87AzdMBgNRzSvr9nZ2WZ3vczLl/uU8ilGpSKDThvX8QhrOrFEjGb9AtdeokUieIsJi4VFNJVlunQIRxNMh32+/NWvIIoK9XaXVCzC1cUF5Y11TDNEsVxZ+dO5LoG/6qKUBAgbGh3HIRSLIJDi+vwUaU1kNh4w7HWRJJHJsEd/MERTIJ0vIgoSnu8y6Dbxlgua7T7pdIqtGzd48eF7FCpVAs+jsp7n6PiYs9MLHr35BZ4+f4XnuTz76AnZtS2myzmR2QDbTjPu9/lPf/gnqKqOKAhUNreJxP8vt4Q/V5hmiLt3bpJMxggZBrFoikFviKxqJFIpSuUqvf6A5dLiBz/6gJ29LUrZJLFkktfefItSdYPFdMrp2SXdwZRet43jBihahPl4RLlSRlJEzEQCTRVJpeI0alf0W02s5Zx+v0c8kWA+mRKNROk2WhzvH2DqBvWLC0RBoFGrYTsOxc11VEMhkUxyeXbGiyePubo45+DFMwqlAmbIJBIxqV9dcnZwhKKHmU9mRE2TSnUdMxIj8GxiiSTHR0dcXV5zcHhKKmEymy1WgsROwLg/xNAMAiQkWeDh648oFYrEoxEUfBbTMaP5nMuLMza21kDyMJNJuu0+e/dfI5ZKsLZeoby+RSKVYmEtcdwliqGynM+JxWLsra+hKxr9TpfxeMD+i2dcX9c5P79CC5l89O4HeK5HsVLGdlx8QWIwXuA4HuPRGM9Zkkwl2LmxQ6FQpFouEo2EcUWdyWSC71lEDIOLgwMqGxuYZhRd0agUC7QbHVrNNrFUBklW2djeIhJPEk2keeOLXySRStHsdEkmY2xU1rBdj0Qmy1XtitOzSwJBpNWoMxoOODm9pFDdYn17l1IhQyhsEA7pSBL4nkfj6gJ70udrX36LL75+F8+a0mm1uajVUI0Qb779ReKZAht728wXc+azKdWtLWRFYTYZ0rq+YDTqo+ohQmacQacLgo9HgOv5aEYYggAzbLJ36/6K2bm0WEwXNK+b1E6PSETDfOXX/wrhWOozNbtVfPYO+c+6X1712QkgSkiazuatB3zpL/0/uffNv8Kbf+n/wdYbX+dL3/gmUdNkMFgZKp+enFBa3yCWiK1U96MJFHWlk2o5PuhhZE3Ds108z8ezbcK6RiyWwAjp2K5Pvd7gow+fUN7YZjKdkC0UcF2HsG4gKyoXp8d4lsXVyTGOF5ApVcmlUwT2Aj1kEEmk6fUHjPuDVXZjMmA66hF4HrPZDEmWaXc6BJJMOKzy5hfeYNxpETI0ZFEjGU8gqSrL+QJdD/G//++/T63ewl4uWTgugSitiG2zCbIsUa6s4bkBjmNhW1Nu7m1y+9YOresavU4Pez7j7OSYDz/8iB+//wxNFcjn04z6bTzbZzga0u11se0lyWyBaCzOxuYOqihTXdvACJmoooARMghHE0SjSSx3lYBOJJIk4lEk36PZ6BAOG4hCwGw0wLJsFM3ADwJECbbWS5TLZbRQmFwyie/Y9Lsdsrk0V6cH+M6STD7HeDJmPB6TyuQYDYeU13eprG9y+/YNDF3FMDSqa5v4rk3gWfQ6HZKJBH7gMx+PiMYSbG2ukysWmM2m1C/PePj661hLi1Z/zHe/+0MEZBqNGs/2TxAEkVG/TaFcJGJoxBJZXNvDsj1ENUR1aw/dTFDevMHC8tnbu/ELxYNfesDbu32HVqdFuZjn6rLO3Pa4arT46NkzookovuNRKhSQBJHpeMrz5wf8b//b/8HFxQWDbodRr0ncDKFrKuPxFMfzuffwHtubVd548w0sy+fF049IppIIsky708dD5O1f/QZ3H9xhe3ebUrFA4AvE0zn2XzxHC5uMR1MisSSIMpIAuVSKxXwJgBi4DPtdHNcFRCxrgaZrTCZTtEgcQQDf94mYMWbj4YryHo0SCoUobWxjLecYYQPbFzk7uWQ0sXj25BmB7zIZDlkspkiKiIBDLBZlNJtxeXlGLhNHEgI2trexF3PMdBzLX9LrNJnNRiSSMepXdRq1a66uG/R7XU7Pr5lOF6RzRaajGbWzc2bTKe+98y71y3Oc5YzJZMBgOma+mKFqGp67akpPZjOUyjnCIRXd0JmO+uiaQSaTI5Wvoms63VYL17KoN5r4voXvu0wnE3Q9TDaZIBQKkUnGee3eHpPxhO9+50d0m00EOcLZ+TX23KLX65BMJZAVlXwux2K+ah25ff8uL5494/D5c4JAYu/mA8bDAQhgxlIkU1lEARQZhu0mF6fntOo1Li4vGU4sdm/fIpXJUKxUABFJlkhksty5/xDPh2Hzkvl8xqjXod1oYBoy8WQaSRTpNy8xY0lkWV6pn4gS9nLOYjEhmUwSNeMkMgVisRj5UhHH8xn0B1j2HFEUKa5tEAqHMRMJZD1Mbzgmt3kTUVr9S3+22ZtPxuAnfXg/vRQjhJkrc+Orv8XNr/82N7/xV0ht3OD07AzXsckVsnjOkufPX9DrdNANg2JlDVlVMGJxOoMBkhYi8EXa7RbjyYij/ecM21d89WtfYTTs0mo0UfUQiUyaeCKGroZAkNCMCJ5no+oq1xfnvP/uj8gWS2SzSYajEdFEEs8PsCyLUMjE9cDxbJLxFIVclkcP7iJ4PpKq0eu1MSMR7j16QCQSJRyO0esOQJBIJpI4C5t2v4/rQ+C5LEZtatcNitVNZnOHQNQRBJFiMY8Zj9Frtllf20BRVWRJpFwq8OW3v4AiOiTiUSJRk1AkwtrmBvlyka9+7Qv85m/+2koCLxX/2HsuIBVP8tqDhziex+HJKb3RDMu2sK05uqbRuL7k4OSUg4NTpsMu//kP/jOtTo/FdEIkYTKfjuk3L9je22Xc6zOfzwh8B9uaM+h26TTr9Ntt2td1Gs0ek5nDZL5kvlywmE758Y/fpdPtcnpySKc3YvvGDRbLlfh9OplG0VUsa4rt2iznM1RZJpc2qW5s8OjhQ+7f26Pb7RCIIpbl0h+PWNpLhv0W8VSSF4crcY/hoEvz6oLuoM9sukBWFGxEtrY3yVeqLMcdDE0iGQ2TzqTZWCsS1kWi8RiqJiEpMteXF9y7vcdk1OXgxXNqtcYvFA/+pwDe9fU1f/2v/3VSqRShUIgHDx7wwQc/7aYIgoB/8A/+AcViEcMw+PrXv86LF5/tqLcsi7/1t/4W6XSacDjMb//2b1Or1f7cP8ti6RJNJpnNZ+hhA0mWcFxvxRicT2j3Wliey4cfvE86lwXXIZVfpWzmsxmxRIpsJkng2tj2gmQ6SShk8Pyjd/D9JfPFmDv37rGzXmU2mTOZzHCsJYNWi8MX+4iI7D97TiadJBpSSSUT5HIr9fybt+/ie+Ajrpyt51PKxRxmLEo0FqVYKuM5Hvcevcn6+gZm2MBbTkmnk0RiMdK5HOl8dgVEtSt6/T7LxRxV07hz9zay4AM+vXYXWdXJlkq4/kqOLJBgOZ+SjKfxlwGaHqbWbDOfzfE9D2u+JGbG6Hd7bG7t8NqDW9zaKZFMJlZqEpE4iqwAErlsGkmA01f7pDOplSVTs0mxWuHOvbtEIjHs+YJOqwUCtFtNSuUiUmDxg+/9ANf18H2XQiGHrklIoog9GxMPKfgItLpdjg4P+fAH3yNhhomENBzH5+j4FD0Uwg58Ti6u2bl9k2J1ndL6JiIrb75oXGe9skbE0JhPxzRa3ZULxs4e/cGMdLbIjXt3CcdNfMHDsRcU82nq9VPm8yn5UpF2q0O2kCOdz6PrEQRRwPU8Br0RIWN1Yjk8OEYUJARBxHY9Lg5eki1VcWwXWQooVdaw7IDZdEm73WMxn9NvXpAtVlksZkiySDydIRHPEjLjHB8e0Wqseq+a1zVi8RjxVIZwKLSqq8bjqLpBMp0j8D2Ggx6W7SJroZ/+n32uvXwVgiwRTuUo7t0nufWAnbf/AqmtO/iKieNL6KEwiUyedKGMpBhEwmG2b98lXyiCKFJZW1m5WEsbf7Fg0W1zeviSly9esJjNCByLjZ1dStVtImYSXVfZWKsSCxucHZ/y4oN3efHsxSearY4voIUiZIplDFVlOltwVauD53/cE2YSDmnE4iEMVebk6IRGo46hhZnNbUJmgkgoSuD7vNw/YDyxOHm1T7tRQ1JUeoMR9etrVF1DUVRCZphUIk6hvI7rgxcI2I5FNptCVg10PUSlVEIPKURiEXqdNv3xkFa3x/NXJ2xs75FM5UhETV4+e0K7sxICOD+/4IPH+/iiys0798imEhzu71PvDJhMZoiijG05REwTM2qiawatZotwNE5hrYIreNx78wtI+Ny7sYWmaASejxmNEEnlOLtscn11xeb6JplclqcfPiaRzKBoGqVqhd3bt6iUS3Q6fZ48fsbxeQ3HdwhHDDZu3KBYXiMUNrluduj1+5wfvWJp24TCIdLpNMlkBttdMhj1+L3f+8+0+jNOz2o0O11sa4m1mGPNZ0x7fXLZAqniOiF9xSFQJfjtv/SbFMtFbMuhur2BrmtsbK7x4smHTEcTkokoC8vGcn103WC5tEimMgxHY0RBIBo1mS6WTBc2oXAY2/VxPj7d/qLiF17DGwwGvP3223zjG9/gD/7gD8hms5ycnBCPxz9Z80//6T/ln/2zf8a//tf/mt3dXf7hP/yH/Nqv/RoHBweY5koB/u/8nb/D7//+7/Mf/+N/JJVK8Xf/7t/lL/7Fv8gHH3yAJP33K2jvvzwgk01Ru7zETGR48f47GNE4zhLs5ZJHb76JLIlo4SjPnz5BDAIqW9t4SwtrscBxXV69OiSRiCNKEuFonFarTba0zvlli8uzc2RJ5eTgFZa3Oo0lEwXWNje4OD5mMRsTT4Tpd1r0ejLVG7fo9XoY4TCzxZRwPIKs6diLOclsBiEQaFy3EGWVRrsLQUCr06fXH1LMJYnGTRzPYzRbEo6EqW7voMsKsjxmPp8z7XewZitDU0XRyOSLdLsd0tk0i8kCXTdImiYXFxdU16pIisxwMEDRDZrdASIihhFifWMdTVW4vq5jFkpEwmGur69Zzib4nsd8OkFSRFrtVTN/p9Olur7B+tYWtesW/cEAxxM4fPEUSQ2jKQqZ8jqZTApcFzMcptduk06nQVbRjDD2fILnO7TaTXxfJAhEJoMhlfIaoiySyWZptfooqk6pmKQ/HLKzu0cootOq1fGCAE2DxWJKOpdn2O+xc2MPZ7Fkaa3YgnooAqKKpspcnF9QqzUImyFGgyEEkK9U6fcnGJGVJ6C1mFPdXKdx2SBTjDKfzcgU0uTyRU4OT0in03hOgKyFefXqCM9eUqkWaHd30RSBfr9PMmayvV7mT7/1faKJFP1Wk527r7G2UeX542cr4ojrY9tLZvMJvidz89YtnP19fGfOYrkkmVa4PHlJcWub6WRG7fwIPRRlNupSLD/C9QL0SIxUMsWL7/3BZxrGBUFAlBWMRJrNu68RNqPYgko0laN+dYVmGCyXU8qlDJfnF2xsrGEtLCzLZT4b8e0//T7L2RgzmUWPxnE8n7CispxNiCcTCDfuYltLhCBg/eEDPHcJokK9Xuf6us6g16U2r3Hz3n0S2Ryt6xjRTA7d0EiFdZpX5xwdHlM7P1k1ePsSRyfHhMwImXyByXBIyEzgIxBNZhEXc1KZJKPJiHAkwtXZEeNBl2I2TX84xrGWbK6VMKIJTs/O0AydSDJHrlih3WlRKJfZ2ihj6grX7SGP3/sxSBI+AoIk4VgWgiCznNvkcjmW8zmlUokf/fgDJN3k5PQMXZXRI2Fm4zFm2EBXNDzHx7Ycjl+9ADw0SUWRBIqFAt3xlHSuQHg65Ctv3mf/4JSQJqJIEt3GFXfv/irHh684PzklnS8SIFKpVtENHbVa4eDVAbvbG7TPD7k4P2U2mZJKJ7HtGWE9xNZGhW/98Z/geB6OE+Bac2KlHKXSfU4O9nEXU+zlgn6jDS7EognMeIL65RlhM4okyCQzWUbjMfFUnvl4ghkJc/TsIyKJGEY4hqEbyOUK436b2WKBLCt0O11K5TXO+10Oj06YLBzmzWNiiQyt0ZBULken2Wb37n2KxRz7B8cIksr+i+cUKutYixmOvaRea+AFPs58yrf+6L+QyuSYDXp4IeMXiE7/EwDvn/yTf0KlUuFf/at/9cnY+vr6J8+DIOCf//N/zt//+3+fv/pX/yoA/+bf/BtyuRz/4T/8B37nd36H0WjEv/yX/5J/9+/+Hd/85jcB+Pf//t9TqVT44z/+Y37jN37jc9/XslZmkT+J8XgMQDKRxrI9iuUqi/mU3Vt7FCpV2o0Wl1d1RuM5VxdnqIaBGaSpbGwieBaZVJxoOMT7j1+QK1RpNa9RJLAsh7AR4ea9Pf7L/+//wAhHaDWaJLNZbm1tcNWo02t1aNR+SLGUo1m7JlcqEjLjLB2LTqeLPZ1SXatyenTC21/5Ak8fP2U8mlDd2ODq4hpd11B0nWGviyCJqFqI+WKOHokyGQ2IpVJMJnNOj05JZXIcXhwiqyqqKvPGG69zUbvGjOjYjkur3mAxHRLZ3iCiaozGYfqtNmFDJ5mIc3x6yvXZJelSicVsjhj4nJwuScbDOJZE9/qKXr2OKX+Fl4cnTCZjIqZJIpVkaS3xfFaOzU6b+WLBxcUVF2fnGGETx7EZDPrcvVtmMFYolfK0Gm3moyG18zMkSaJQWuPy6oxZvUHUjPCVr7zJwdEppXKeVCZFvdFkNJ+yXCwoFbJcnp0jiRIHRycoikqn08W6mLJWreAg0G71EGWd2XzGZDyh0WiznI5wHBdRlGm1GlydvCKXXSnabG1KTGYW8XgSWRIYjEa0Oh6LyYh79+4zHgy4vK4RT6UZdvp0ri+IRAyicQdFkbA9n6PTU3x3TiK+Q3WtTKtRx14smM0Fpr02d2/vMJ+PSWdTTCYLFssZEdPEWdqoOLz15mu8eHFA0gwzalwxXgpcXl6gh3R0PUyv18dxIVOo4DkW4VCIqeOQyRex5lO6rSaz+QwjEqZ66z7NkxfMOg0kLUQomaOwdQtZjxJLmsiKyPHzF4QTGaJpgUImQaPdxwibWMsZ5XKZ5WLJsw/eJ2KGyW/fZDQc014ukAIXUVXxfX+1MaazjHp9JuMxtu+h6RGanS6JZIJ2q8NsPGJjrcra5iYXJ0fkkzGeH54giAGDQZ9e2+Lu3TskEinu3r3DfDYhFDIQJQlJELlxY5davcV8YRHSVQLH5uzgGZPJlHGhSjSRQB2OMEyTbCFHPhvHth1K5TLHh/v0pxaDThdDN5gO2vzgW3WMUAhDUxF9l7CmMpnNKK2vc3V6QuDaXF8c0W3V0A2DiJni4NU5o0EHQVJwfbBtm3A0QrfeRDdNAlFiMBxTyCc5Pq2tbIRkCASJheMST6aw/YCLw+ds3biHKsZ5/OyA4WBA23eIxhN4sojjLNE0A0nUmNsB11fXlColDl69QDMMZuMhrWaYZDZHvpgmnknjLZcUiwVeuHB2UaOyVqHXaPLm228zGFVoNOt0W2fIso7nuqRSaZaWxY2b21xd1JD1MPcfvfax8avGsNdlNpmwnE0JhXTMqE6pUubi7AzHC1Ys7HyO9vUZjrUgHI7gLKdMpyMS6SyT2YSwGaPX7VOKRAhFoqxvlPEdG1UNsbZWZrOU4OlBjf1XM2bzObIskS8X8W2XcqlCt9lge2cXTdN58tFjEtnMLxSffuEpzd/7vd/j9ddf56/9tb9GNpvl4cOH/It/8S8+mT87O6PZbPLrv/7rn4xpmsbXvvY1fvjDHwLwwQcf4DjOZ9YUi0Xu3LnzyZqfjX/8j/8xsVjsk6tSqQAQT8XoXJ/juXPGnTrbOzu8fP4Cx/GIJtKcn56ze+MmO9vriIHNZNjj4Plz+qMp3/3hj9E0jbAZJp3NEomlwPdIpE1UXeXOwzdZX98iCHwUTeXFs8f06rWPe4IixLMFVMOg1eriA3dv32Taa+FbU45eviQIPNrtAZfnNVKpLIok41lL8vkcvu8S0jUUTUNRJIQg4PDwjH6nR0iRqV9cYegRXMsmEgmTL+RxXYezs0t0VebZu+/gW3M0VSEcDuNaDpdnF4R0jeViwXwyptnq0W+1iaXTJFMpXGuB4zooqowzn/Ly8Jjc2ib5UonZwiIcjjBsd5lNplxfnjPsdbDnY66uahweHKKHwiyW85W7QirJcjonFk+TLZaIJ1OEZBF7OccIh5jNFyiKQjweZj7uMx93CIdDXNXbnBwdIqoiS2eJsxwTWBPqpy/wAh9d1zHMKNFUivmoz3w0ZDIbU2u0ef9H73ByeMh8PqPfHaDpYVTVwDSjZLNZ1qpVouEQsXgMAYH5dMJ8tkQU4MXTx4znS1K5Ep69xAjFsGwH2YggKBqqpnDn/k1e/9KXKRfyKKKMNZ+yu1VlPuoQSyWZuw6GaWLbAbbr4dkekXiKxmDJf/n2e8iqTqVSQdVUGrUaf/x7/28CzyYej2JbcxQthGKY3Lz/GpXqBiE9zNbuNsX1CrXaOdbSoVipYkYjzCcDJqMe8+mIbCGHJIvIioHjQXLtJvd/6//Gztd+m+23vk6yvMZkOiFqmliWgx6JUNncYtBr4XgO9+7ewHFd9GiCheUxmEyw/YB0vkwsEiKkiWTzOYxIFNexiCdiLKYTzEgU13NRNA0zliRsmnTbTRazGYv5ktFoTL3ZpNXsUN7Yo9PpMWzV2bv9kLt3bxEOR9BVlV6vy3f+9L8w67cYthtMuw1m4yHecorsLZmN+ii6xsVFjWSuxBtvf5mHb7xGOpWkmE0jSQqTucXT/VPGwy6ua+F7AZl0mmIxh72Y89rrb7J74wZvfvkrqKEwJ+eXPH55TLPeYH1rg3Q+B75HcW0TPRShurGNHjJQNZWl5VO/buLZC9pXl/SaDXx3gRiIWPMF3V6fWCaP7VqEEgkCQUIURJJxk3A4TEgBxTBoNeucHh0wX9hooTC6GSdXqBAsLb71nR9Qb7aZjvv41hTLd6m32jiLGYX0igwUixromkG/P6Hf7XJ+ccZVu0Ov0yARj5JM5/AljfF4wdV5Dd91yBUKZEsVLs+vmMwWjMdTEjGT6lqBfCbO4f4BnhcwnEzpdvuISOh6iJAiY0/noOiU19bIZHI4josviGQzRWKRMGFD4+LiClUPgRgw6PVwPA/VCOMGAZ7n4bs+0WSMxtU57733Ee3BjNl8RjSRZDqZoBkhlguPfn9Ao9mkUqkiijKirJBKpRn3Br9QfPqFA97p6Sm/+7u/y87ODn/4h3/I3/ybf5O//bf/Nv/23/5bAJrNJgC5j73BfhK5XO6TuWaziaqqJBKJP3PNz8bf+3t/j9Fo9Ml1dXUFQKN+jZnMEKBQqq5Tyq5sOFrtDv1Ok8b5cy4vjnn87juEzTDjXo8bt+/gBz6iJGMtlsynPW7urhO4FvF0Gj8Q+Pa3v08sHiOki4TMMJ678qja3t7CjMbY2bmB6/vs3drDmg4RZZnJdMbOjVu8/fWvMZksSGeyaLKIYWgsbJt3vvddUoUS3d4QTYRHj+7RqV/jTMfk81kW0wmqqrOY20xHA3rdFt1Oi1QqQeu6hr2YU92ospzPMGMJECXCkQhGNE6r2UAPh+n1h8jhMKlSgV6/i6brKLKMZTlk83kePrzP2lqV/fMGomJQLpdJJWIcnl8SSBK56ho379xGFCWy+SKipGBGTWLxOELg41oWxVIJx14gSxLVrT06wzH16zofvPcB7esrPHvJfDbDCVyuW6saRrG6TiCJ+K6NIoGoalxdXHHnwX3Wq2Xuvf4mCHBxcsB8PmbS61ApF4jFoni+xszycSWFUrmEpmlU1jfY3NliMZ8QiBKdTptACGjUamSLVTwfHDdga2eXXDZLJpvDWTqkEnHeeOs1ptMJHz1+xnWrw2gwJBoxef+ddzh5tU+2sk63PyRbyNPrd3nw6A1UUeXpe+9zcHjKdDbl5laVVDzCZDwASaLfbnF2ckpvNCZbKHLn3l1i2RK+EuXZqyNkLUwun8aMxxkOR5ycnNDudGk0B7gLm3sP7hEKh5iMh6SzBfLrO8iSyltfepuXH32AoUWYj/pEwjq27RBPFzDCxupvYS1Qwhpn52f0uz38QETXJDRFZjpbEopFCQJoN3q02k2uTy+xZjNm0wmN+jUXJ0dIqsFgMMJ1HIq5DNFYDA9YBDJG1FxZ3KRTuLaNKMl0a6fEkxlOXu0j6xp6SKc3nmAmEiTTacaTKafHx/zpt76H64s8eu11fuO3/hK5XJ6vfPUr3L17j+/+4D0GC48vf+UrDDstwObevdvUazWePfmAx+98H5eAWCqFYcYJmXEkzSCTz1Dd2kTXw6xvbmGacYaDKfPZnEQsxKBVZ9htY1tLZuMJtu0RiUYxIiYbu7tY1pzRdEHg+6TiEUQRovEEphkjnoxjxuOsrW9y+84e5Y1dLMvh9KJNMpknnUyTSKfRQya98Qw9HKJcKuIuLTL5IrFMgXbzGt9zqV2cYYQ1bu7toIgCnh8QMqPcvH2HbCbFqNdntPB4dVzD8Xzee+8xg/GMfq9HoZhnOZtQTMbJ5AsIrk05m2YxnaCoCtW1CtPBiGjMpN/trDQvAwtBEOgMZrS7UxpXV+zd2OHo8ABZglAsjOXYqLpGPBFbub7MR4i4SCq4ts3xy5ds7e0yGQ3p97qIQYC9XGBZDoN+h1btDNdxaNXrHB++4v0PH3N/b5O1jQqH+69450fvkoxoWLMh3esL3MWM6XjMeDKl1+mSzGS4rjeYTKeomgq+9wtEp/8JgOf7Po8ePeIf/aN/xMOHD/md3/kd/sbf+Bv87u/+7mfWCYLwma+DIPjc2M/Gf22NpmlEo9HPXACTwYBKtYo1n2Gm0vynP/wTRrM5ih7CNMN87Ve+SeAFfOHtL/LawwdEYzEEVWb/8Qc4iyXWconr+EymixU4SCqN2hXT8ZDD42NevnhOMpthPBiQzZXQDZNsLo+qyHRbLSbDMWEzytxa8GL/AFXVOD65QDdjLGyfH33vh+TzeVRJIpaIoikuy2mfXnfAhx8+xdDDFKtVqmsVPHtBb9Dn7LJBaW2LUMgA1yFuholEDaTAIho2GI1GuJ7L1fkZIgGt2hXz6ZjReMjx4UusxYRCrgC2xfbeDXRFoX52gqoo9AYjTo4uiCezyKLM6asjbMclGo3Sqde5sbtNIhpiMuzjew6CZ1PMZljf2sK2XSpra0SjIRRVIp5N43oe5ycn5PJpSpUiiWyefLGIpmuIgsSg3WLU7+G6LtenR8wGA+7df4jgCTRrNV69OuKH3/0OKTPMYjRBFCV81yUcCSHJEq7nYKgy3WYDBZFcPo+hySxnIzq9DpPxhJllYbse0bBBNJFkaVnMplPOT444qzV58fIlr735JvPJGMG18Bcz3np4k7AmgT3Dno8JggBZ0UkV8hTSJqpgcXV8iCQEvHzxBHtpUcrnyGQy1C/OCEXjROMxNja32d7aJBI1MRSRkKZQOzngdP8F9rjDqN+i3+qsTIFFmfGgR0hfmeGGQgbDbo/53GLc72MYGq7toikKEuKqUbjdY217h+r6BqlMnlgyjWGEOHr5FFmE08NXyLqKJgqYkQizQQdB1nn19AmpdI54Mker0ycSSxFPpCivb7J3a4+3vvo2KCouAelclkTcXNWjkzkajRaBJNDvtllOJ3SabVr1JiHdQBEFhsMhpY0dtnf2KG/sMeh06DRb4PsE/qrc8PSjD4knk9y5f4edO7cQFJUnT17S7XYZjKccH59y895tPNdjtliSSOVRZYNw2CRb2SQSS6OEDEKRCNs726iBw7DdwLJ97NmC1tUVbrCk3WqtelZFj063S7c/5rW3vkA6leH+/Xt4zgzHdRBEiYNXB3Q7PdY317l5YxvbCVjaDpIk4Lk2pUqZdr2G7wvULs4Y9XqIwYLFdMJkMqF2cU6hkGPv1i1qFwfYiwn7Hz3m/LJBKp1DDFzW1iusbWygyCqaFsINXPREhoePXuMv/MbXicdjnF3UqNUajHotFHnl+fgTRrBuGIiiwla1Srm6ztHhAaNuiw8fP+e6OyaVSnJ6fk6700GUVUwzhpmI8cWvfpVirkBI17g8PmDYH9ButlmrlDBDBif7B/RbHRaTPqqmU2t2mc0t3nj0kMvjY2bDPtlsikgswWCyoN8fUMrnuXP/AU8/eBdJlggZYURRJpaMk0hnwXNQFYX3PnjG2fEpyWKZTHWH3mhBJltg48YdTo+OP85gCcSTaQ72XyEKcHn6EwHw/xNg9HPiFw54hUKBW7dufWbs5s2bXF5eApDP5wE+d1Jrt9ufnPry+Ty2bTMYDP7MNf+9sbFzk4Xlkq9UScVXbQCaIrJWzuMsbJaezHQ0Zja3+ejDJ0RiK73NzZv3ya2t4QY+d+/cIp+NsZyNOHz2Ic3LU4qVErquc+/Nt1AVg2x5nUK5wnA0oF2/4OT0gF6rzmw647XX7jMZjFG0EP7HxXF7uSASDrO2tcXF2TnLpUWutMmd27d4+OghuhHi4vSMZDpLrzfg7OSU3XsP8AOB0bDP7t4OlUqRwHd49fIFy8mMB1/4Kqdnl+zs7pErFolGU5gRky+//TZ/+S//BW7sbbB36xbxaJTpcEAsGcPQNMKxGLZtM53POTs6Qg/rJBJxXGuGbbssXYgmorjWnF5/yAcfPCaZTjCbTMgUikRNk+loiKbKLJY2+6+OmE2nuIHH0/ffIWRGiSWSJONx5qMe9nyKGPgoeojrqzqxZAbVMAiQ6Y9dRsMZ4+GIwvoG67t7lLZ3iSdi3L21Rb5UQA1HsB2YTGYMBmN62DwGAAEAAElEQVSq6xU8awo+LGZztnd3uHlzD1WSUI0VpTyfzRIg0Kid4fs+nVaLXKmCoSmEzQTL+Yzt3U0kKSBXLJHJ5klmS9y79xrJVJZGo8lkvuDi6JgPPnrOaDTh7mtvcnJ0xmtvvM7W7gbf+OY32d3ZwnF8ur0hzVaXTNIknQgTMyP86q//GoNul2/+1m/y9te/ws79R2xtb/CFL765MnSVJFRNQVZERoM+hXIVMxoCAlL5EgQ+RiSGKosE7oJiMcNs3MfzQdM1zo5e8OF7P8Z2XRKZlR1RsVyhVCiSzBbJFkrcevQW1fUqWijCwatXtJoNDp4+w7aXdBpnTHotptMxs+mUxXhAJBqh1W5zfn5FoVQgEhJ597vfIhEziaZyhEIaurYiL4mCiGYYOEuLyWjM5dUVvXYbH4FYKsP27jbRRBrbg1gijePadHtDOrVLnj57jmyESKczlIs5wrE4uqqTiMe5vKyRSGWZjoe0+n36zRqTfgs8j4vjQ1q1KxRFpJDPMxv1WVgOviDRqNWRVZXZeMLGxhalUoH33nmH73/ve4TjcRRDI5bO0B9OGQ4nCIKAEQoxmSy5ODuleXnIB+//mOV8yqDXpdusI4gCvg9qKIrjODy4/4DZqI9nOwQEPP/oAzqNNu5iRiGXI1fIEU0mUHWN2sUlp4eH9LstKuU8uqFzfHjGYDDh1f4BL/dX5BtZFpFlFdf1+fKX3mJ7a4NIKEKhUmFje51hv8uP338CqkYik+Gr3/gVdM0gHtG5efcOBB6JTJKFNeX504/oNhpcnZ2wWC7ptFsspmN2tqv4fsCTZ/soephht0EsFiUSjlIpFcjlcww+vkGIJ+LIssp4OCARi9C4vkLSNTr9LucXl4iyQihsEIomCEdipONxJtMJ5WqZN157gJlIEY7FKJbLONYS3TDoNK7xXAddV7l79xbJVIp+u8VsNCSbTVGorJHNFUD4xdJMfuGA9/bbb3NwcPCZscPDQ9bW1gDY2Nggn8/zR3/0R5/M27bNd77zHb70pS8B8Nprr6EoymfWNBoNnj9//sma/96IRg2a9RqDwZCD/cP/P3t/8iNLnp7ngo+5mbmbufk8D+HuMUeciDOfPHlyLJJVLLJIUVe8t/tqIQkNAYJ6IW0oCNBagABuJUA7/QESWrpSXTVFiSpWsTKzMitPnnmIeQ6f59nNzd3czHoRBaLvqltA3U3h/rbhCIQ7HPbG7/ve93kJhwLklpbo90fIbhfX19fImp9+f4TPrxGPhvF5PTiOzcm7N7CYMZka7O2fEU+nmeo9soVVxqObgs5UOsNkPMAY9zg5OmDY6VBYziEILgrrWwgu6Pa6eFQZx5xzdnBEvdZkPukznc3ojUZE41FSqfgNTuiixOs3+7TbPVRvgGarwXgyRPRIZJJRFvMx/XaFwWjIeDxk9/59JI+KLxSlWKzQbLbxahr6ZMyg16NYqeKSJN69PaY3nFJYXUMQBA72D7FskdF0SunyDJdLwOvViMciBKNhqtUawWiC7bvbCC6R8nWZVDZLfjlPPJlgYUOjUkRTFb59+h3nR/tcXl7THwzodbtEowls00H1+UgmYvSHQ54/e8bWzi7BSIyApiJhMzcMBASmgwGRWBRV05iZBm63i06rgT4Z06lVuLiu8d//8gvUYBjLXKAGIri0CDPTZDSdIgiwmI3pDboUi1Xq5Sr9VgtDn9Fvt/AGQ7TafTy+MJo/iMfrxR8I4nZ7CQSDnF1d0e0PuC7V+OWz53zx9S8pXhxTbdSw7JtguuXYFDY32FxbJpWIk0snCceShMMxzi4qnFxccHh8QmF9A302YzgZ4shePG6N1bV1mu0+wXCEhWnw/MUbzo72CcZSvHr5Erdb4vTkmFg8jeoLEk8vkVrKEIpFiKdv3LsBf4hOo8LJ8RHVcplmq8t0PGRtYxWwSKVzfPzhfWKJOJFQCJ+moXlVLs8uaVauOT484vXzZ4guG8UNoUgYsJE9KoWVNT75/LdJpFKoikIimcVcODTKNUxjRjwWxhgN2d3ZQna7KV8XGXVbDDptEokU87mF4IJgLEVyeRlZ86JpKulsAn3QRRBvJjPjQY/RsI9LsImns8wXFrKi0WlUkdweLEfi6rJE6fyYaq3GUB/RrN+858nUIBrwkUglGA8GuLUgji0RDEdIpNLcunObUCxBMhEjFAqwmBm4PV5k1cve25tbRj6/jOjy4BFlTFsAycN0PGYy7BONRREWcxwEJNVLdnWVW9vbZJaWyK+skkgvYZsLAqEAq5vbHBwc8P7gBMXnx1rMiCaSxBJpYrEwgWCIQj5LfnmJRr3O2DBwRIhn0iwWC64vr9nYXEOSJBaWQ7teptFqEYxEGfdaaP4QWjhBdzQFQeLs5ISLkxPevXiNLxBCdbtQPCrl6zKtTg9VU3j+4iUvXr1jMhoynegoXg2/FuDRo4fIHh/TmYVLlAhGk3i1AI8/fEirXqPZaJBZ2cByBDRN5d3LF+gTA49XQXDZ3L3/AGuxAJfAcDBgKRakVS4zHo1JxEKIokS73mR1bQ3BcRAcG9GxqDe6/NXPv+Dk6JROo0G/2cCYTLi4KuLyaKRTaTJLBey5wdpajnq1TCy3TLlYYn11GUX14Pv/cvf/Os6vXfD+yT/5Jzx9+pQ//dM/5ezsjH/7b/8t/+bf/Bv+8T/+x8DNKPNP/uRP+NM//VN+/OMfs7e3x9//+38fr9fL3/k7fweAYDDIP/gH/4B/+k//KT/72c94/fo1f+/v/T3u3Lnz167N/39Pr98lEtZYzA0kj4dYIkGr02NqzFlYDvXSNSDQ67TRghFGwxGCIxD0+1EkCRcW5UqdSCgIC5Pk0grJ7DKS24Pq8zPodvF5vWQyWcy5gRYKompees0qc2NCo1bi/KKI4vYRjgS4OjliMZsRicUxxj3MmU40mabWbpPMZmlWa+iTEaFYjNzqJgvTwBEkhr0RrWYXXzjO9u37jIYjbNtFPB6n124QCgW5PnlPMByk0+8z0udEsyn08ZiT82v23r2iXi7RrNcplcusbayDS8SYz/FpQT78+AnLuSyr62tEI0GqpSKapiBaFq1qGdkt4/ZqVKsVBEHA5w+ihSKoqoo+MUjnV1jd2GApnaLfanF1cUHt+oxoPMFoPGHQG5AqLDMYzXj3bh+35qPf7aIqEuFohPF4gOAS6ffbdEcG7d6I5c1Nmo0K2aUlctk0qUScuW5QLxZvILijLul0BpdlIUoyqzu3EVwu/NEwc0QWCGxubSNzMx3o9QeYhkEwFEQLhLk+v2Iw6NDvd5jpU4IhH+1mk5WVAj5NZXtjlVw2xcbGOiu5FH43LGyHr56+Zo7Es+evCQaDHJ9ecrz3ilqzxWxh4wv4CQRCBPxhnn3zC376Vz/j9Xff0O31GXQaLGVzSILI+uom6WSaYCSO6vUicdOP5pFdBDWFZrXOyf4eYOPxKjS7HURZwnZJuLUA0WiQUCTG6cklb1+9pFot8erdEY4jkkqlKFXqdLp9Fo6N6PEQCHiJRCNkUknW17YJal7uP3yAZU4ZDzt8/eUXHL5/T7lS5fjomHQqzdraGo8eP2YxnRAJhxkORvhDMaLxFLbjEAwGiceT6MMO9dIV24UkzUqNTqWMoevMTYhn8jjWglK5QmZpiY38zZQnmwwTDmhcHO3hONx0vVkLemMdLRJDsG1yS0uEImGWl3MoqsTbt29ZXclz94OPCUQSbG8V8AhTrq6LVJpN6uUix6cXXF1c4dECWA6M+23CUT8fffQB7UaVDz58xMXpKd/+1c/oNxv4VAlY0Ou3EWSJYbfDbDxkd3cbWVEY62OO3r+hWq0RiSfRvF4mswUuJUgilUDVfGAZbK6vYUxntNtDzAWUSlUmUxO3YFHIpEinM3g0P/3RGLfi5s7OJm7BZty6ZjrsYs50EESS2SWWMml8Ae0GLI6NZeqEgn40vx9REnErGqpbYm67GOoGkUQSSZaxF1O2b9+n2+2zMBdowQD9bo/f/f7nRIIa+rBHo15l7/17fvn1UxyXyNatWwx+1Vrx4ZNHJFMxQn4V1eOh3epxVW4z6vXJF1YRRJHxzGRzZ4cf/PD73Lt/j42tDRLxOL1WA30yQJ9O2b17F83nZzwaI6saLklEEmF9YwPN50P2uJnM5+gTnf/2X/4rlUqDdDbLoN9laswol0r0e30G7cavTZvg/wTBe/z4MT/+8Y/5d//u33H79m3+xb/4F/yrf/Wv+Lt/9+/+9Wv+2T/7Z/zJn/wJ/+gf/SM++OADKpUKP/nJT/46gwfwL//lv+SP//iP+dt/+2/z6aef4vV6+bM/+7P/oQwegORysZLL0a1X8fpkTo+P6bXaeNwijmOTzi2Tz2VYXs4x6PYZ9HsUL84ZdDs8/PABG1u36NZLjCYjApEYqVyB62KJwlKGoF/h5HAfxeOh2aizMA28AR/vX79h9dZtVgvLrK2ukEolMPQpum6wvL5GKl8gklrCQWQynHLwdo/ZZIogyFyfX7B77z7GdMLF6QGhSBxnrvPwzhb9bptxt89satIsFfGoKodHp6xtbBEIaKxv72I7C1rNFtubmwQ0H8Z8ynyuE0tn8Ho1ep0eiaU8oiTR77YwTQuXqjIYTXj+7Dvq9Tq9TouA30cmHUOfTBA9KgtLYDGzaNUb5PM5VtdWUFQ3lm3Rajbw+AL0h32uSyUiyQzp7BL+YIhAwIc5N7HMGfFUGsdlEwz68Hq9zBcOS8sbuGQZ2e3FFkS6jQqzYRe36MIY65ROTuk2GxwenzKdmRTyeWLJBPFkjEQmTzgSIZXK4g+G0TSNXq+DNTNot6tkCwWmhk4oEiUYDBEIaOCYBBQXkm3gzAcs55LMpjPCoRjObIZPkVgr5LEQGBs2X/78S5qtFvO5iW1bpNIpXC4Xm1trIEK9csX6ah5V8dIuV7k6OeXNd0+pla9pFM+JxOK4ZImt+4/4+MEOkYCXv/yLn9IZDDHMGeVqlfOj9/TGY9qdDr3+gKOjE84vLhBEF/5QlGgsQyGfAXuBT5HY3V7FNHRMR0BWNbx+H27F+6u+siiOYBONxtGnM4aDEc7cpHS8h88fJJlOMpka1FptTk5OaLbauD1uUskEqUyax599zoMPn5DNZWl3OlydnyHJHjKFArFUmkQqi1tR8aoeMA0W8zknp+fgOKTyy+wdHDMajZFVH5ovQCAUwCWAoeu0GnVcLhETD6oaxFrYGPqYRCbF7oPH2I6D2+uleHkGoogWCmKMb4qSXaLIYu5gCxLPn7/FmhtsreW5LNWoVVsYszkzfUosHiEeCRKKRpgM2ujDNo45o1ZvUK40b4pzRZFYMs5HH3/I6vomu7c22dzcRnQpiJKEorqxbYtiqUH58pp4PI4+6OFYCxSvRrdZI5OMItgzXr18jSSIKIoHt+yiN+gzM2fo0ynFSoNOZ4DjcqEFfAx7XXxuiISCnOy94dnrPVrtAbFUllD0hhrk8bjp9ob4Az4KuQzDdgdrsaDZbCNJ4o3Izea02i2uzk7x+73Urq6oXV/cTEQGfbrtFo4toKkqK/kclUqJXzx9QbFcJRJLkEyniSaSqJqPXH4Vn1dja3uTs/23fPnlLxlOTQKhEEu5PI1KBcsyMS0HWZLY2Fjj5HCPbq/LT/7ip3zz9XOuLi6Y2xZaMMh4MKRSrlNtNglGgnhkEWs2ZvfOXTS/n8FoSLvRxh8IMun3sGyH7NoWhZVVvvdbv4Vom/gCfq4vL4gENALB4K9Nm+D/JNLKH/3RH/H+/XsMw+Dw8JB/+A//4f/h54Ig8M//+T+nVqthGAZffvklt2/f/j+8RlEU/vW//td0Oh10XefP/uzP/jpq8D9yXKKE43Jz68FH5HOr+PxBbNNg2Glimg7z2RzDsBiMDY723jKaLnBED51GhWA4gi15ePjkEwTRQ7fVIBkJMht36PS6HL59izGdUSikSGWSPHjwmLkxR1a8TGcL3h0eY5pzjMkYazGl16ixe/cBs+mYYafB6dsX3NrZwu9X2VgvkE6ESWfTlEpVpvqUaDJKKp0kHI7gINAbjtBCIYyFyc69+yh+H41aGc3v49m339BoNKlXqwzaTVSPG8e22Vjf5NZaAcFxwCWw+BVs+nhvDxyB8sUZbrcHc2YTT2aJJtJcnF5RLxX5+ue/5OhwD5dlMuq2GI8GeDwK84VJvVpma22VcCRMOBbHXpgosozPe4MGG3Q74CwIRMK0a2VUj5vLwwPq15d4VYnCcgGP6iGVSTBs1snkCigeD6F4go2dHVY31ohF4zz8+LfQwnHOT4+JxCPk8lki0QjFyxNajSonJ8c3467xlPnURLBcOAuLTCJJIZdDkd3MZyb9/gDN6yUQCtKoVFlZWyWYSLKynEdmQbVSotufEElmef32kOFAxx+KICtexuMJvf6IYDCMX1VYTEfs7R/Q6w2YLaDcaOGPJfjgk09xyx4Uj4cnD26zvXuHnd3bzPUZR2/f8ef//eccHF/y2WefEo8EEGSZhWUjIOCRPaQSSWLxCIV8HsuCarmKoescvn3Fl198zWis41GDTGYWvmCQ8XCE7dis5tOEgt5fcRq7tGplrktlJEmksFzAH42S3dwhGIsjim7SiShBn8ZMn9BtVnFwKNdqTHSdXndAs15HQOD2nR20YIjhxMBB5urqmvfv9xAcE83vJ7a0QiKTJRwOk8pmuLuRobCyjKqAW3bRaTUpF6+wTB2HBV63RDiR4OzsFHsx5d3rtzSbHTyKD8s0MWcGM33K5s5t8pk01atzfAEfiuJmfbVAKBKhWbvpfzQXN3u6YvGKVn/CuD9isYBYehmPopFKZ1C1AIKokN+4B0hE01mWshk63R6qP0QsmWIpk+Krb55TqnXwuCWCgSCp/Cr+cOzGmdptIws3HMuFaRKPhjFncyrVOoriZXd3GySBhQ1aKEgkFkUW3WQzOfqdJlogyKA7oNvt3wT6JzrReAJF9SMLFsl0BkXx8j/98f9CMBxF9Wk3LsdOl+ncwRcMIooitrXAraisrq1izSdoqpt4IkG9UkRwwerWNqahIys+xr8KpZuLBe/3DjEFkYUtMDNmeFSFSDLDaDhGliQqlSL7B3tkcnkKt+4QiyUIB8K8ffGcbDZDKBLFLbm4e+82lXIJfWrgD8dILxUwTRPBdRPBOT8+ZGFaKIpCMh0nGgrhCBKKqrG6skI2nabfufmMVa/KsNvgyZNHNw3xxoyTszOevXgFuEgmk0geN53RGH3+6yWt/MazNIfDES9ePKXf7/Piuxc4WDz6+FPcXh+79++xlC9gWjNqldLN7NyrEo+F+K3v/4DBcMLZ8RHNVpNy8YJQJIYsughHb/J4LrcHy5rz9Okzev0hIFI6v2RpKYc5HZHNJDBtEVuSUb0Kn37+PeYzE8uycEkiheUcAb+CP+hHn075ix//B5ayGaIBlUA4jGHMePv8KdFUim+fPsPv0/D7Agx7XWwcerUqoViCiW7icXvRfEGshUA8nuDqqsTr776j1+1xeVUC0YW5WPDw0QMifj+FzS18QT+LhYUx6VMqniG7JfyaQr9WvHFj9Tqsbe7w2W99TCSeYjyZYswXTGcWo4lBrdnhYO+AbGEJ27II+HxEoiEuj95gOwtsGwa9Po4gsQAQBLZv3QLRx+HpFb6An7kNDz94SCoRoV0vYc2mtFttXj79lulsiuR2s7y8jGMajIYjXj1/ht+rICCiahqiKOLxyHhVCZcEw06NerPJxDA5OzlBcAlsbG8zn4xpNZtUiyUWosLTb58TDMXpdAcEAj52tleZ2wuuLy+pV4rUzg9o1KtYszEPHt5lNOjjuCSa7SEeVSWeyhKKxjFmM2xzgeaREF0C9nyAPxTkl9+9otOsEw546beaOI6F7ZJAlukNBmSzGWxHYDQeYpkWisdLpVhiaSlLt9UmHI0SjEbR/AGwHRwE5vMpxWKR8nWFbq1K5fIcy7rB5CluD45toSoy6Wwev+ZndXWZdDqBT/UwGfS4ur5k/81r3r8/ptkasnFrlx/96Ae4BJlWq4fkuXH4nh2f0O6PMR0ByeVgLkxOTk+w5lNiyRQPPviQ6WSEJktUyjVqjRamZXN+XeXi4opsNouiBkhks2Tyqzz86HM++ugjwvEEMhajVo2T92/YunOfcCRKp1HFcmwkbNbWV3G5ZDa3thFFN43OzajbhXMzkUklyBWWuTy/oNfvge1CURXiyTj9XhdRUjk5OaVyfY3H7cHQdQb9Dl5VwXEWDMcjbMthbtqcnlwwGA6xTBPbWtCo1em0uggumfFowqDbxR8Ikkyn2bz/AFsQcFwedGNKu15mqk8RJZmlTBbLtCiVazdrjNL5TUWPIDCdTkmkkmRTaRrNNqenp4z6fYKRMIvFgn63wfXpPqVqi4VpoetzZsYMRRSZzwyK52cE/X4effABvX6PZrvNuN/HrfiwHZmtjTW2tza5viqjen0sr64SScZBlJjPF4x6PczBiEGrSTZXQJY9CLZ1Y1Jq1giGgrgxyUT9uGyLk9Mj+r0+Ni7KrRaT6YTJoIsWiuBye5gtLDSvSiwS5M7tHQbdJvFIGI8sUrm+xBcMISkqZ6enVItn5FcL1Ns9Di+umc4XtBo1vJqXVqNDs95EFMG0HIaDIYJtofoCKIrK/UcfcHV2yu5W4deqB7/xgmcDqaUcoltmtpjhkm6QR61aiVK5xNXZCfVylfzKKk9+9/fp9ds8uH+HgNfNoNvj937wOflMnOmgQ7na4K++/IpYJs1YnyBKIpt3blMrl3B7FPr6CBywFgusmc762gqJRAqPJCIrXt7sHXBxcsjtnS2QZNIrGwz6A6LROMcHh+TWthE9XiwEotEom+trmDODWr2KtbBZ21jHERzimSwzwwAEmtUa15dnOAuDcMCL3m8TjidwXALLG1skUlmCsSgeUcK24PD4lKODPXxeL5IgkM3lcIkiXtVNPBZG8Xj4nR/9IY8e3sWjKMzmFl9/+QsqF8cgODiCC9sR8PlDDMcG1VKRaDhGrz/g5GCfWr1z04fn85PMr1OvNRBcLkTZTa9Vpz8cYMx15qZJtXjN2cE+B8fnlIpVJLdCMJZkPJoQSS4hSgqz2Yzjs0vWd+4hSh70uc3UtJFFkV6nx3AwYjjoEYyEcWyTzMo6G9tbFHIFTGOG16/hWBarG2t88MF9RFFGEET8gSBBxYVpzpjqOku5ZabjMZu3dljfvsPD3/4hiWwKSfVRb3ZpNlsMWnVEUeL67BRzMad0fohXu+nGcywBl2DzvR/8Ln/4B7+PRw3gIGKaBtGwn8JKgU8e32Epv0J7YnBZrJJKZ5ElhQ8+/hSvTyUciRCJRFnKLdGqVlA9Ms58wtwy8QWCzIYjkokkHlVl++49AkE/rWaXF6/2uCyWyS8vIwoOY31EqXjN+5fPODg6YTDSKazvEvZHcSteTNNGcIFbUfnxf/xvTI05y8sriPaCXruGW3FjTGf0mh1atTrXR3uY0zHBUJBet8vV5TkTXWe+WGBZC0zHhUeL8vrgilarTSGfI5uOcXl2xMXZGS+/e8be3imqP4qsacSX8sheP4FomJ3dTfKFFcLhGMbM5PT4kIvTQ7748ivMxZxU4oaU9PT5azrdHqF4glG/jez2oGoqsXicrd27zGYG+qCHV3XTHYxYOA755SW+//2PUb0iSkBj1B8w7PYw5zNEUcSy4OLslHarSiDgx5pNKZfK6JMpC8sht5RhNl+wf3iKIyp0GxUmkxHBUJS1rS3cosPBu7cMRmNC8QSKR2Mpv4ZH85PNF7AtG5fgotHscVWuc311RaN0jeTWqFerqF6Nhx88JLO8QX65gDGbk08G+d6njzk5OWQ+N/F4PFxdnN8A5hMJMtks8VwOXCJzB3rDKVdXV9j2ArdbxiNLRAIhypfHaB6Raa/GnTs3U6RwWMPjcTMd9wkHQ/hDURRfgMnMpFSpc2v3FpF4DFn14A+GcUtuChvrGJbF3JzRazUpXV6yMKac7u3RH4xxEImkl4inCyhagHAshjmdkohHcbs9FCsVKsULJvoEJA+Cy83m9jaSS+DLL75kqBtMeg28bgkHgdFozPHJKePJlEAozMKc/1r14Dde8EoXF7Q7fcrnx6SyWWTJw2S+IFXYYGYYhGIx3B4PoiiheYN0KmVOTi/57sUbri8v2ds/4fDomN0PPmI2n7O0lCMSDJDLLbG5uYloOUQjN6HlWqnCzt07GMaU1a07HBxfUC5dc3F8yuXpCZ1Gk3gyiz40mI+nnJ9fkUxlCIWCDDodlgo5jg/ec3ywh1eROT464c6HnzIYTMmvrCBLAuN+l1G/z9vXbxhNZxRWl/H6vHzyvc9ZWV0mlV+9KSe9umA86HOy9w4J2NzcYGHO8flDpJbX6PR6mKbB+sYKlrkg4I8ym1t8+8vvcHncyB4ZB4uFZTEeT9m5vcNyoYDiueF0joZ99H6HXD5HJhZAklxsbu8Sj8d58OQjtrc3mfabLBeW8HkVJNtBdns52j+i1+kQi0YREFA1H6rXSzCgoQ8HpNMZUrEoo16X62KJ48MDqldn1Cs1Bv0+4ViYTrvJ6uYWyXSGcCyOrCq4XAKyJDIa9Ol3R3z39CmyW6Xf6XB48J5Bf8DBwQkeLYDsVrCtBeFYFNtx8IVibK0V0BQ3RwcHPH/5GsnlIh4Og+1g2zAaDsiurGFbNr/3N/6Axw/vUljbBEdgMOgyHvaYGRbHx+e0hiMm+hDTWVCvN4hncmzs3makT5kMB9imxajf4/J4n06zzuHRKfvv3tIdDgiFQvS7LRS3iOpViSXSBH0auUyM7du3CPkULHNCIpMmnkoy7tbxqhI+f5hQNInfFyQYjhKJRQgn0qTSKcbDEb1GjUqxiCy7kVU37XYD27YJphK4vRIuSUTxBcjkCjz5+GMGzSr1epXCxi1Sy+tk8sssr29TuqpxfHBIq90hkUqyvl7AIzkMej0sx6LX7/H63R7GwiSTTLC+tYnj2MSiEeaGgcuyiMejjLoNLk4uePn0O7yKBweHRq3CdDonnYwTj8WZmw6Hh6c0qiVq5TKFtXWS0RiCIyC7PUgCRCJBBoMRgWgUyzTY3VpGXkwwpwYe1cu3z9/T77SxLej1OgguGa/ipd2s4Q148QVCrK5tkEonQHIx6NZYmAbl00O+/epnCKILYzrj8uyCcb9HJhlhebmAhMCdBw+YT3UQBHrtBidHe5yenNPtNLARyObyaJpCeimDKArk1zbQAiH0SZ/sygoeWSbmVylfnXJ+doaIyeXFNfV6B0OfoHq9CLKHhSBwWa5RvLyk2xsiCjLXp8cY+hjMGffu3iGVuelSlGWJmT5BdnmILy2jxlNk8xlcLhe1Wp3xaEjx/IxHD3ZYXs7R7/VxbIeTy2tM22LQrBOJROhPxpydXRJQVLyyzPnxOeYcFrMZoWSedreHqkrEExFefP3lze/Bolgsomoq4Xic6XhCKpEmnsrRKpfwKhLXl6fMp2M+//wjfN6btYuAQGopz/LqCpZpAjcdg6FYisvSr9e08htfALuze492rw3WDJdjc/z+Nf5Y6gb2qg9QwyEmxhDbttBNk8Kt+wiiG0G02L51i8F4TMinoU+nXB685u4HTyhfXZErrDCbm7RaPR48fkJn0Gd1Y4POYEyjWGRn9xb9fgdRlPn4k+/RbLe5ujyjVi3T7sggeYilUvzy2WvM+ZRgOMTMnKP6fGzvbLOwLRwsooEwxeMTTscDLk4FIokszWoJxefDmM3odLt0mh1Gc5uT598SiSUolSo8+vAJHgnS2QyyS6DXH2POda5ODxElD263xHRuMJvNcKtelECETrdPq9VEPFPpNRuEY3EmkxE4C4LJJUb9IZlMllqrDZJMMJ5FVL28fvOeXqOKKLhYmCZL+SyD/oBgwM/Dxw948fqA8tkZyXQBqVtlMZ+hD/u4PR5G3SYNl4goQSyZZDQc4NgWW7u7lEoVltJR1tafMBobCC4ZRVVYLGzK5QqDTgd9PCIUTxAMeDEsB5fsRlUVEGx6/S6t9oyttTyx5BKdXp8FNro+onhxgrlYEIpGSaZiHJxdMV/YhKIJ2vUqk1GI8WjCwlrgUiRUv592p81g0OfqbB+fP0jp4pRbTz5j0G+zsbnJ3JwTTyU5ObvEHwpjzcZ884tv+f3f/11MY85XX3/NvTt30IIBrs5PWcwmKL4bU4dtWezefch3z95QK11z9/5trs9PmegGluUwGkzwaBrBQIDT756C24dbUdi+c5eNrVs0a03q9QaOvcDlEjg5PcOreZHcHlzCAkWViMYClIrXrK/kCIZ8dLs9BMeGxYLFwqJSKjM3bmpdsOck4gnMuY03EEQfDzk5PiFbSIMdw+WSKF2e8+ijj1g410iCfQMMvrqA+ZTkUoqvfvqccDTJpNvk4P07hv0+ujFjaz3PvcdPiKVTqO48v/zyr9i69wB/UEPxRRiOJ4yHIxzLIplKEQ4GGQ51REnGq2n0fxWCDoWClM/PGU0XqJoXy7IYjsesbm1yeHjKdDpDcua/2g0OWNvc4O13T1nfWmE4aHH89g2JdA7LAZessLSySTDgJRKNM2o32dxcxZE1et0ekZiX+SRPpz+gVm0AC2wEXC7we920cBFORMEloxsjJI+HeDrD0ftX6KbJsN1mYdrkVjcprC1zfHDIaDzGmC9wCRIry1nCwR3+47//3/CF44zHOuNRj8zSElenB6xuPOTqsMfZ4R7BRIp+p839h3fQx1MWjouAP0DP7aVUrWE7AnPTIOhX8WrrfPvdG+aGzr37D5mOJ+hjnaPTa0bDMS4EHn/yGc+//SVaIIA/kgDb4vbtXU5Prjg5u2JhjJnoOtmlZRr1EslYANlZoVptomkayaUCkWgccz4lGg6wWNhcnF+RyefRR32W80v4VQ/BWJhGpYQ5W2B7NTZv32Mpk0LXDV6/3scX8DPsNfF6/cz0CaJbQQv+XwWw/0NH9XuZDPssrW8xHPRILhVuGH6qh9zSEgvDILe8QiYeYdxuATbX10VUXxDLtuk169za3WXcbROPRwkENKKxGJPZjP5oQiAUZDQZc31+RL1Wpnp9RTiZ5vzimka5gmNZeFQNURQQHBvTsolmMmheFb+q0G3U0QcjvIqHRCRKo9bg+Pic66sSjz96Qr1VI5GOU1jOg+0Qj8fQAn4GrTrz6QTTmHH77m3cLhHRo9LptAkF/Xz6+A7X52f81V9+wd7+Mc+evyC7uksmmyeaSCK7BOLBACuZJM58yvnhO/aefUMgHCEQDrKyuU42t4TmC7Jx5yGWYzEYtLm+OKJdLrKYmzhYRKIRcssFfv+P/gbBcAR9MsWYWYwnJh5F5eXz14QDGrfv3SO3WiDi9+FTJCIhH25Z4sGHH7FwoFisUClX6PcHpJIxsqkU+nCAqoU4OTqiXm8wGg7odRvUq1XSuTySx83O/XtEEzG8ig+908E2TfrtOtFYlGgigWHMGM4dXr16zfnZBQISlasrUoUVYqksl2cXlEtNzk+vWFgCXn+AmWkwNU3a7TrbG+soloVpWGjhBJKssrlzl9v37hPP5vAHA2xub6PrNyDtbqfLpNdn2GmTX1lD8yoY5oyZBW7VR1c3GM4sQuEk2eUNBGTAxYcff4y1mDPsttm9dw9EiVA0jltRiKbzdPpD2t0J15UW4WiaaqlIo1QhGIpzcnTEeDLArym4sAhHojx88gQH0IcD1ja2GEymTOcLPB43brebi8NDRqMxlu0QS2YRRIlYKoPXH8Sj+FD9AbRIiHazissBx7GJRCMUlgt88vFHbG1voU+mdDs9Op02fp+XRDSE1yPz5KMnjAcjnnzyOX/8P/9PPPz4EzRV5MMnjxl0mlTKZTa2b5FKRPjum6/J5XIIMx1zPCTo84Lbi+oPEUpkCAXC7G6vM5+NMfQRz5+/xKOFSaVzTCczwqksf/ij30bzqkiKl1ZnwHxxIwBhTWVmLFha2SIQCNPtNNm5d4+ldIaFLXLn3j02NtfQNJVOu8140Ccc8BHyKSQzWR4+eogsmPQ6DcajEaLkwXQkJFkmGomSTmeZ6CZHp5f02g0ujs9oNVpMR0NKl1eUrq8RFR/YN1VNq+ur2I5Dp9VjZW2Dw8NT3u4ds3Frm5/89y/4xfN3uNwSvpBGJJVE9Sis5jMs5ZdZzeeIxjPYszmpSJxMPsdkPKdSrXF1ccFwNGRhmnSbTYadNtOpTqc/Ya7rmHMLNRilNxiRSKeYzaa0GxU0TaF6ecpibuDTvEx0A0GUGfS6qLKI1ytjWRb9wQiPqmE6FuZ8jm2a3L53F8MwMEyL0aDP2cEbrk9PwIHV5TyWMUF0e7BcHoqlEuXSJY5jUdjc4vzqknK1Rq1S4/WbPfqjIcN+A28wgFsN4FU9fP+3P0UUIJ3M/Fr14Dde8KJBLwG/H1M36Hc63NrdQVMkhv0+uDV6wwG4RN683aNQWCMa8OIWLLyqiqKoyDJ8+c0vqVaKZAsrCIILxxFotToM+iM67T6XF2VcLi+l0zOs2ZhPP/0AwXZQfH60UJjBZMjl2Qn3Hj0kl8ui6zMce86g32N1dQUBh0A0yfnFJapPoz/ooagqw9HN33z3/n1sBPTZnOtyCdNxsbJ9l2g8jeT2YDsC714+w+3zki/kCEejPH9zxMCwcXs1ukOdmWFiTEZUymUa1RqD4YT1Wzu8PTgjlU4S0LwIgkMiFqVRLBIJBogEvNSLp4z6XQ7evUfzBVleLhAI+Ugn4zjcNDlM9BnFYp1GpYyDg24YlK+vaLW6XF9d8+71W6rVOgfv3qMEo6xs32Y6MwkGw4TCYURJJJnJ8/CjJ3jcLkrFCs+ev7jBf12VuL4sovrCKB43Qb+PteU8bsekWynSbtZplot4ZJGlwhqbt+4iqwF2795lZbVAPJHEWizwqArtdgPDmOISHPyal0wmjuDMcSSVUrnI6tY2grMglkjc5A5lhUQyzvraCm5njjXV6bfbvHr6S2ZTnZ3dXYb9EcfHxxiGyeXFFbFonO2tNWRFJZdO8Pnnn3J8cMrVdYla8ZzrUpnL8zNanQrdZo219WX8gSAu2yLk92PORmyvZtEUL2+fP6VdKxNPJQjHI7CYk4hFwSURjMaxHBuXJDIZjzF0nWg0juj24HIJ9NpdOpUSxtTkeH8fv8+LV/MSCoQIBjW0SBx/MMC4P6RRLtKqlek1qwTCITq97s2uu1RCn40ZDdt0Wm1aoynHx8e8erfH8dkZ/l+F+WeGiSWqhONJ7n30GcPBiFQ6Q7fd4dmLfd68eoUajNMZDlE0lf5wwhc/+QmKJPHg4X1a7TahRBIEFwGfijOb0G1c45ZEao06neGYdGaJlXyeW7dvM58Z7O2/583L51SvL3n1dp+JPmGuG0zGY8LhEFN9xNTQSaTTDAcDRoMxIjLddo/jk3OCfu9NkLrXZa5PcMsSw06DX379LS/fHjGdm1yVq1wXK+jTMaPxhMlohGMvyORubl2XJ4eYtoPi1bj14CHBcIj11Q00TWOqj4hGwyyMMR5ZIhGJMJsMcMsy/XYN1SMRiicZz2wGkxmJRISdrQ1cooe4XyMdDfHqm5/z/Nlz5oZOuVRhpOssb+0iyy4sy2RqLZBUH4PBkDvb66SyWZKZHE8+/oy79x9xfXHG0ck5LvHmmVUsldl/d4huzGk1q+i6QSKTRnbLBKIRTEPnzt1bzGdzfvnVN7SrFZyFiebVGHTb1MplVF+AZ89fcVGsE49FMBcGPn+QDz/5lB/9jR+ylF8iHA1x++5dBp0OsusmzpBf3eD05ATBssjnsjiSB8Ht5ez4gHqrQyie+tV3PcV04dAezvB4ZNqNyq9VD37jR5rHe3s8uH+X5y9fIikqb9/sIboc0st5JoMhbllk/9076teXyG6F8sUxdx8/oVov0arV+a3f/oyTowvSjz8hHImgaCr1ZgtjMkZwCTQrLXJLST779DN+/qVDJr/ML7/5jkQ8weeff8zzV+9o1MpklleoNRuMWh3yGxt0RwYra6ukMmmM2YxIJESrWiSbX6ZSXZCIZxh0u8xNg26/hyR7yBZWqZauCEcibCyn+fqLn+ONLVEs15hNDAyny7g34P7dW1xeXDGbTvAoKsXzQ/IbWyhuyGRTGPMFnWab4mWV6VRnpXBzy9u68wDLtghGopiOhD5fsLa9SzTo53mtiuhyUL1eGuUitrVgMhpx7ZYZdZt89tmHhP2eG3iw10vxbJ/+oEd2KYeiqIynOoWVZQxjTq83oV6psby8yuH+KZpXY3mlQKVaYzIZkUqk8foEFN8Gkixz/Fbn5OA9qxureLwR/KEIPkUks7KK7FYIhMNIbtjdWeX5y30sy2A0mVC5vsAGXLJGq9JgaWUdn09j1GmztrlOpVwimSncjPAEF7Izpz/s3Sz/PS4uKiUay8tcXJVIFlaIREIszBnNVovOUCcW9vPpgxxfGQYeRaVRq1O8uMDjC9Kslmh1Ntg/OuXB40fMbQdj0sMfDODx+tBkAVnxoXk9DAdtKlUV27JYv7VDtTem1Ozy4MPPcQHzmU2/38c2DVKJCG+ff4fbH0bz+bm+uryJhTg2tXqLRumaWCJJfzgmtrSMaYOq+fH7NQKBAK/23/OXP/uGyvUFqVwORfNy694OiBLFcoW1XJruYEzJmJDNpKm1lJvmarPFsNWgZ85pVar8zu/9gEksgWUvEAST/bdvKV5e0W9VyK+tobjdPHx4DwuZcumSoFfGF07Qarbx+v3YoswvfvkcURT4nR/8DsdHJ0yNOaenRUxzyp37j0glU5yeFzk5uSCgeShelxElEUlYsHv7Fgd7B8SiMcLhCLYF6rrGxckBluPQbdZ4vyfRb7f56PPPGAxGdDs9kpk0bknEraroukEkGsXs9ri6OGc4GJBZ3sSnaey/PkD1erEFCERjBEMxRr0mU2OKIImk8wXu37/Hs9dHqB6Z5VyaVvmaTqtGbmWVeqPGeKKzME1ktxvTWiBKAuFAmPJUJ+jTCHhlLEfEJQosbIFWq0ssHObg4JBYIoUWDuML+ggGgrhlN7nlHN3uGEVTiScynJ8d/Yqz2uPZ8zeIApSvLvH5bljCIg4TY4bls/GpCsGAD69PpdOqAW7C4RBpLcsvfv4FosdLLpu8gbpbFtu7t9FnJp16mbVbtzl6/4pOs0U4skU4HEJzy+Q31vn5l18SjsYZj4bcWs/zH/7Dj5kYc8Kx5A16MFOg12ogywqa6iMa8LOzvcl//9mXtGtljGEffTTCHwqieWRisSTnls1YHyMpMp1a69eqB7/xN7yxPqE7HLOYz/H5g0wGbZKpJI1KlWq5TCwRx1zYPPrtH7K2vkZyaZnpZErx/JLJYMAXXzwlk8kwWyz49ulzXrw+5Pm3L5jNF2RyOdIreW4/fMDh6Sn+YIh0Os1kMOLq9IS//IufULs8ZymbQXHLtEolXG6F/XevMRYmw4lOvVIhnojg9/tZ2bpLIBAkFAyAY3K4945Q5GanMep3cUyDcMDPne1bROJxljd3mY2HjLptgpEY9nTITB9hmhaWAPnVTSKhMKlMFsXjZv/NKypXVzi2hTEe0qiWcWEhu1V2Hn5IIJRkvrDI59LYxpTS1TVYFpVyGZEFXi3Iyckp2/fucefeXZZyWYxR72b/U29xflnEF4rgEiXuPXjM+sYG9dI15sLEMk0m+ojpZMR4PGZmmDRaLfTZDM3nZe/tK0pnhzy4f59IJMKwP8JZOCC6UH1eNtZX0TQ/5VKNyXTO0fk1oiiieANUzi9RVC/HR4dUr89YmBaL+QJBUEik0sz0Mc3iMZriQZFEBEyiIR/DXofZdEqvWUcSBGazGcl0gkAggt8fwuvzY5ozbBw6rQbX1yVGgz6S6OLs6IDzyxJPX7zGLbuIx6N4VIVMbhVVVfD6ArjdHuLRCO1648Yla5oIokTp8hItnMBxeVhYDrLsRtU0ApE4o+EETXToVS8pnp9wcXbM0fvnFI/eEE8kODy5wusPEo3G0EdDZJeDpMhUry4YTzpooSCVYpF+s4Zp6Dj2jGathCAKHB3sY4sulnIp1jZWmOpDookYjWabVm+MPplSr7fpdnv4AiGmUx2PYJGKx/H5g4RjKVwuGUEWaff6FK+vODy+oFKqI7pcgE1qKUsqGeezJ4/58mc/49nzl0z1KR7FS7vVZDIY4BJB9niJprP0Ok38fj8bm5tYtkU8GcItCbz65S/Q9SmGoVMvXXL49hWKR2KiT5lMF1imjepxc3a4x/7BMa12h0DIz6MnH/Po7i1Wd++ws7NNOBTi8O07UpkMsltEEkUMfcTpwXvarQbfPf2OWvGKB7d3WcpkkFw37syApjLqNhkNhiiyTCyg4cKFyxGwdJ1IKMLx6TmRUIBOq0mr1SEWSxKLBHlw9xaZWBRJBNt2cAkOheUC/f4QWfMjqyrHpzdtGKaho3k1uo0qgYCX9e1dpsYMryoRDMeYjsbM9QnT2Zxmo0W1VOLg6IK3b/aRXCqJeAJhoZPMJLj/6D6ZXIFANIy+MG/WEwGVO3d3mQ6H1OpNquUKhXyOtc0Nzs7PqTUaGPoIf8hP6eoax3TIL6/S67S5vbsNopuzk1McQSYUT+PV/CzmM0q1Ok+fPmMyvIHj93p9nr05QAmGkVWVUCyK1+enXS0TioSoly/pdXucXxY5K9VBENm9c5t4KoM1GRH0+aiVqwT8Pm5trXB1dsJ8ojMejX+tevAbf8PbffSISrHCBx99QqvdRUolSMTjFK9L5FNh0rEYb7/9Fu3OHcrXl2RzeQ7ev8Xj01hfvUuzWscfCnJVqRGJJ0jGY1QvjlnKJvHgQhFdHJ+ccfjmBVogerNDmE3ZuXufRq2K7FEo5POcnJyQW11jOofesA8Lk6O3b5E8HjZubXN+WaR4XcKx52SXshweHrJ17wEfPdzhf/9PP2Z79zaBUIzp3KbZblBvt4mm0vT6PSxLwDSmFNY2GY51rko13j/9mtzWbTTVy3IhRSK9xOZKll5/RHugYy4WdAcDet02s4WFCChagFqpiKb56DVqmILD3Xu36Xd6uCQXjrOg32kje1WODg4J+Lyk00lKlTqNWpPhWOfyuoQoSbgcAQcL1eenXm8wbDdwCRCMpm5Gp6kUY10nk0sRUBU6DZFUvgCCxMHeO0xrQXIpQPHkhHw2TTa/zOnJCatrG7x6+g0Ly+bDTz+h2xsieVQ6oxkhr5tAMMR8vqBeKVMpVViW3EzGYzIrWyial9OjYzJLeTqdPsbMJhZLYcx1WnoHt6LQaHbRFA/DThdrYaDIMueHR+zce4g+njDstdnc2uXo+BjbXlBvDsimImQSAV7Np1RqRYb9Hs1SkaPsMpOejhYOQ2/MwnYx7E9xFg6tRhNRkjg/HWHoE8b6nHbj8q/JI+lCDlmAaq3P6uY603GfVqeNS1SZzXVWlzMsJzUOT68YNtqkUhmiqSUm4xGy24Nb9qBqHoJe6SYPGI0wXyxICTnWlgs82sxyeF2nWOuSiCYwTIfZZEKx3cCfyIBgISk+BLfMfD4hFg2SzWXp1UvEkksMRlMkWcS1mPPpx484OTsnEstwdvQG0eXGnlvYtsWHTx7wVz8fc3ZVJBiOMujWKWxvEYuGmI6GJNJZ/vIn/51QNH3zz0evx3RqkkjnaLVbLMwpmzs7TMZjPJqfSaWGgIPi9eGSJHbu3qVcqt/QYBJRdN3kiy++YtzvEPIHUDUNt8fNYDQilkgiugTmtsz61jbJzBLVeotOs0Iyk2Rq6EwmU/xeDx6vD38ohiB7MedzDGOOIIpomoooy1xcnLO2vormDzOe6NSbPYypgTJdYLsqTPQpsUgIO5uheHlOo97E0Ic4zk04u9tq3kwvDt6zvn0Xn8/H5fkFk4lOs15jeXWZSDRFOpVAUTxMZybxeJzJaIIk2vgDHqyFwR/87g/4mTDHms95/36f+XzCaj7B2/cnNGtVUrkcx2dnlM8PuXX/Abql4vZq3L53F9mjoA8H/PYPfohpOljpFKNhD5eocnp0QCKbJlsooI9HdNodZrMJyaifgDvH3uEpFiIeb4BOs4VpznF73Hz/0w/5yU9/RrfRZjYe4ogSQTuC1+8jGE0gym7evXlHNptDcGb83//Xv8WzZ69vmjZkietyFdntYWllGb9XY9D59d7wfuMFr9vuUSmVcRyB8/23eLx+TgJhHEtgbXWF49MzVnbusgAEwWZlOcObV88JBAMcHhwiWzOM8RCP5JBfWuH09IydB4+QVJV6vc7WrZs+rEYxRmGlQKlcR/H5KFdqLK8s43JMfv7Tn7K6vUkymKVUqbO+vkGn3cYfCOCPRhEcF6pHIRAIYMxmhAJhFjOTbCzAcDCg06xTjWV4/ebgV/Zrk2DAh6IF0DwKM8tkMurTbknYgsRUn3D3yWd4FI1Y2E8qFaNUbrK+mmc6sxlcXLFxa4ur6xJudwCvL8jWSgbZo9Cql7EdMG0Xo0Gbw3cH2Nhs7mzz/s0rlje3kGWZ7nTOWJ/R6uu4BPAHA+izBZdn5zccwgePuTg+IpZKsRiNiSdTFFYKdDpdNrY2KZVK9AZ9ypfXqKqX8vUldz/8hEqtSTASJRyJIEoSVWeBz+/D5/NhGDOmszku0cW02+L1y5eYC5t0JkWzVqU5m7L74CHXF5fs7NyiVWvQ67QYDHqoqsKg22U6GRH1F0gk44guBy3gZdboE4onaHUGXB4e8KO/+ceMRn2KkhsEEctyODvaR3CJZNIJ8tkYZycHrK6t8eb5N9RbYB1cIqk+llc3mP0qhySK0Ou1GAy7THWD2XRCIJrEZVu43R4URcHn9eIAy/kM81EH0xhjTGeMhxNkSQLb5O3z5yxv3ELzexmNBshuGdO5ydHF0llESebd829xa0EapQvya1tUKkW8Xi8NSWQln2M5n6NUrCFJAgsHqu0J9fqAbrvLsNvDthxm0wnbu7e5viiDaCGIEo1ShXEojmmOiacyJLMFjJmJork5Pb1CYMF1LUZheZVkPMHeq5cULy9vxub9MTPdYGd7m2K9imma4AioHo1WuYbmB48WRPM5v2rWPsUyTVbW1uh1+4SCQVzCglubm1zXW4wmOu1mg0xhBdNc0O50GU9meAM+Lk8O8Qc1ItEkSiDM937ncxrNPjPTIhQOkE6m2N87oFq6Zm1rh05rgjGdMer3EQU3Rwcn2I7D0f57pqbDfLFgqo9RZJF2o4sZCvDxxx/S6g6YTE0MfYzPF2DQ63J59J5gOMKgP8SruMnks8yAZq9PJptjOBoSDIXpmlNEbFwCTMZjbt+/jT6e4PHKpLP3uLy4JBAIMhr2Odg/QPEGEUQXg9GYo+MzvP4ArdIliqqycfs2xnTGRbWJ5AtRurpibWuHXrvHj//d/4ZLkjH1KS5HYHtzHaPfo1Fr0+61CUYiPPvuJZLg4PV78Wh+apcVRMGi322xc/s2sfQSo7FOLBrh/OAdt3Z20WczPIqXUCiEYdp0+mMalTKi6EZy5lTOT4iGI7i9fgRRJpW9S/X6Cklw4dgOF/tviKRzTMZDjvZfIUsSHsVDLJPHshZ4Q1HGoz7rK2scHZQYiT1SqeyvVQ9+4wXv/OSEdGEVc2aQXt7AowWoXp8RjibptLq8f/EdkdQSY33Mg3u7vH79moUjMDPmxGMxvH4fIJHJ5gGBRvWaySRGp1EnFPZju1xMR0Pu3b8Ltsn7Xotkfp1gMMjd7bW/DlgPe0Na9Ta4YGvnFs1a/Wb3IrjYf7dHOpslt7zM+9cvuby6IBKOgKRyeHLF+u2HDIdjsrklptMZkWScbDLN65cviWdz5BJRLs8vyKYzTCdj3l5dkkgkmc9nlC+blCtNguEgpUoNR3BYLizh8qiE+gOi8Rjlq3MWxphWvUY8lcYyTUTJxe7jJ5y/3ycajzL/FQVCPz9H1TQiIR9bu3f5+qunLBXydNodVgo5LrFoGyMEyUUoGkIQwOfXKJevcLk9iBIsHKiUKkiAMZ0w6fUIJfIs5haxVIKG1aQz6OMPhHGrGqlElLPTmwaOVDzKudvD8uZdXKqM4lb40fc/5tX7A/TRBH/Ax8n+a4b9Hr5QgnQuiVQWSCUzzBcL0qkkbjXEm/cnZJfXScTC6KMhIU1DVRVOXn1Ls9OmfHXB6sYWpatr7MWcWzv3ODg8IZdfJhQK4Q8EaTc7yJIHZgZbK1k00WQ+GVAulVlbW+GqXGc86vPBR5/SarYwp2M8gTA+RcayBAajESzmtGpl8vk8ujFj994TFK+HqW6Qy6SxbItffNVG1w0ywQB3dtb56otf8N0vvmXcr7N77xGWIBAJRwkFA/SaGm5ZRXYryKJIIpWiXr4iUK8RC/l49eIFpctTvv/JBzfZudkM0eNiaWWdTqNFKBQgeO82r16/IBKPg+0QjqU5ef+S6aDH3Z11vn3xhtLlGaN2i8LuLrgkStUO1XKV6bhDIpUin47hUySKtSb6bIaiaiwciY3dHYTFjPXVAtfVNr16hW7lCksSsQXwBYMoqspgcIG74WZmmrzbP2J1eZmFYfDZZ495/+6I969HYLnwBfzYtkUgHGMw0lG9oxsKTSXBydEx3XaHaDzOfCGg6wZ3H31AKhEllwojqwGCPoX/8p/+E0vZ7xGPRzk+es/l8R6ZfI65OScUTtOoVVFVL5V6l2a9yMb2LTqqysXxEarfj+LVcHtkVm5tIVg2tu0w6AyIxSMIkoTP5ycaCSA4JnNjil/zYVkOqUiEaS7P3ttX7Dz4AFVxk0qlKF6eo2h+fD4vpasr7j9+TK3eJBIJk4nHePf6KUG/hle6MeG4JYmr83OarS7YNopbZPfhBzTqVULhEPO5yXQ2I7+SQfUHKBfPCXq9FGsVJLeCMbdxnAUnp2eoPi/7B8c4jo1gLYiHg+iDLl6fF1n1MxjPKFeqiAikl7IEgj4a9RYIEsn8KpV6G38gyv7rb6nIMsFIitVCmgd3t1nMDCS3m9PrBntvXuJ4NF6+ek80FgPbJpGI0Gq2Obu4ZDwZIXokCv5fr0vzN17wbt2+Tyjk48///b9l6dZ9FoMOblEgHAkhOQt++0d/wN7BCaPRmJev93EJDp998jGnpydY5hy3KPPVlz8nlimwmM24df8xuj5lrutEonFUjwePFOTV+/e4BIkHH35Cq16neHbA25CPy4tL7t6/y+XJKb2pTjAS5f2rN8RiMbyaj2anzWwyIhjxs725wuXJIdbcpN2sYwsOjVKR5NIac32E7rIpLK9gOg6zuc6k3yQQDPD2bB/dMBj3+2g+H8lcnpExY25Msc057fN9UtkM0chNpsUfilKtNnCJMvFUmoVpsjDneGQXjm1SyK/xvHyBV1ojHgvTajWwHRHBcXHrzjaqFmCi61RqbTxeD5LiZnl1ldncIBIJocoKjVrlpm4oGWX/zVtWNraxHYd6uUwv3sYXCPPR47sUr0o0mi1kVWXv5UuWt3cwFwtse4GmKASjcd7snVItXZPJ5ChWWliLBclUhPF0SunshGfRKOenpxSW12m1emRzaywX0sxdKid7e8z0KT5fkFgqRbvbQ/F4GLebnDfalMNBet0mK1u3abaaPPzsc2LxCOOJTq6wij8YwbAcJI/KsN3m8vKCVrePqnipN9u0Wk3uf/ARzXYXVVX5+NMnfP1LmZkxxS25sOYzTHNBs1IilY6RigVpNDokUym63R6WquDzR/H7VYKxII1WHY+iUTw/w6V46dbKPPzwY84vLpjPDS7OL5lOpzguEQuJ4VhnuZCjU6szGusEIxF6gy7dVpOp34ukupkZBqIDzc6AeG4Vr09FtwTCsRi9bo9msYzgcuNVVZZyWX7xxTdEohHG3SGNUglH9DIe9llaLmBiEwmruKwZ1+M+Lgt6zS69VoVoSONHf/OPCQT8rC+n+c9//he0mm0MfczqSoH+SGfY63NrZ5dXL19z5/ZdZI+HZ88sBHNBNBRl0G6xtb5MJpOiUCjw9Lvn+PwFvvrFdwjOnLsffkQql8flcuj1DGKxOOlkgB+/f4FP86Ibc0yXTF83SBXyZJeWmOgGk4lBwB/k7PCI4XCJ0tkR2Y0tGrUqu/fuUFhZYW//GJdL5u69Hbbv3Ob5s5ckUwmM2YR6u89sqtPrtPBoH+BRFSazOcl8HC6vyeZWGU2nmLMJk+EAfTLBTiSQZDf1eoPxZIbbLbP38i8IxjN4tADfPH2L5tcIxRNYgsjcWhAOaXzvB7/DT/77X+LWQoz7fU4O9thYXWKBiOiSiCQzDEczpsYEzBmbO9v0BncZdxp88NGHfPvtUy7Oz/D7Q6RSafqtOvFEglAkQigkIkkugqEAzUaTTDaPqmnojk40FkP1B2nXaqyurVIuXnJnZ5Pv//D3ePbyBY5LYTIx8AeDmDOdzW0/4UiCTq1FMB5hNOwjSSpj28IXSrC7s8PMXDDs9olHw5xfNFlaSjHsdVE8bjK5JZqNBsbcJJlKkc+lSKUSvHu7R25lnVa1zsvnr36tevAbb1pRPArtZoP7jx/z+OE9VgoZtre3cTkLVL8Px3ExbNXJ53LIkptoMsVkMsYtSYRjcWYzk92794mGw8zGA0733nKx/561tQKjfod2qwnSTW4nFAowHo+RZYmltTXcskTQr6HPTFqdDsv5DNGAD2thYsxmHB+8pXx2QHZzA8cROT484u69u8TTSYLxFG63m36nQ61WR18IjCdjOu02gVCMarVOLLeOPxRC9ri5++AhtmNz9v4FouTgcixMfcTO7g5uyYXLtiheXnJ6eIAxGdEsneMIApXLa/ZfPEMQJDy+AKvrq9TqJX74o99HFGRExcsHT56wlM/ikiUuLsr0u2NEHKqlK6zFjH6nh+IWyWQSeLUAoVCQUbdLt9vlmy++ZDwaYdowM2a4FQ9XxSuKlyd8+eU3nF1ck1nKo2l+VH8YwRHp1hrYszk+1YM5bnOy9xpZEhFlh2r5lEAkguD2YhgWhc0dyo0m0+mM/mhAu9NmqZAnlilQPDsm6PffdI5hcX15TKt6RV+/YULu7G4QCIe4dfseXo8bl7XANG0uzi7ptupclyvsv3vFciFzs0PJrRCIxel0+8zmOplMHFmUWFg2rXabs7Nz/tP//l959/Ip6aUCLkHg3r1dEmGNQCTK9v0PUPyhG9dos0vp7IBapYgxn7B/eESz0UGUBFyY+FSVSa/LfGYiiRLxcIxoOIQgS3hUhXRmiUgijRYMULy+ZvPWOul4gF63jaKoCIs5ljEjEY1hzgz+03/494z6XSKxKOurK+y/30Pz+cgur5Df2v1VbdaAw7Mymk8jFY/Q73WYzaeYxpj5fMY3X3zB0cEFndYQjyzjD/lZXV9mNu0SSSWwRZGRPmFhW/z4z39Kvzdid3sFl+PgEuDe7haJVIb8UoZQyM/J0R4TfUo4Gmd1cxPHcZHILNPpTRBlhdl8gUfRAJtULothGHSabfzBCJPJmG6rgr2YMZzcFOM+fPSA9eUcPtXN2dEBxesi79++R5Zl2q0KlVoVYwETYwGSQioRY/PWNpeXl7x48RLTshAEh/5oytdfPyUYjeMIAi4gHg3y+NE9XDZUrq4RRZloLEGnXsZlGcQCCqNW41cQ6wWryxl6jSrvXr5CktzIqobi9xNNL7G8uYPL5dBu14nF4oz7fd6/eEqr2eb04oqrq2usxYLJaEIkFmM4mTKbQ7/bJ5NKEgyEadartJtt9l694vL8mm6zzsraGvPpDH00wLRtTNvGNuc8enifTDbLuN+l025QL12hKgqF1VU6zSbDfo9qvcKgP8LjkUnnc5yeHjMxTK4rdVqjGdPpjNWNNQqFLMlElEg0huJVEBwHxwWBcJxYKodl26yuFkilkuzv7TPWp5SqdZ6/fMfJ6QWlUpVMKsqjDx6SSydZyudwYeHzK7zfO+Dg8JRBr4sj2Hh8XnxB//+vR/z/0PmNF7xqvc7em1c4okK10UDxR2+WzNUWhi0ydyyefPY5S7k8PtXDoNOlUiphOwKXV1fM5gbhaITriyNiySSr66skUxFWCjl27z7E5w+wMA1alSrBSJJOp8fZ0T7OwubVs+/YuX0bEdi9fYd7t2+TiIfZeXCf/Moq00EXj+LFNm0uTg5p1irE41G67Sa2ZZHIZNm+/4iAT2M2HTDo9RnpFs++/ppeu8V8qvP26TeoPh8rywX8msInP/wRgVCUdCJJLpdBdrnIFDZ48Pgxc2NKJr9CYSnD448+4tGDOwwHNy0C0UgI1S3z4vlLxpMJxXKVZqOO4lEZ9DqUr86JJ1NIEpTLV/R7bTweienUpFFv8OLla7766Zc0S0VyS3kc2yEUieEPhUmnU9y+tUE+n79pUZAUkpkcgijh9XqIhANcnBwjYpJKxnCcGYrPh9eroflDpDI5cpt3iGXWiMWyNKsN9vf2GfZajMcT6penrK2vEvZ7b8Kvkky9XmF9Ocennz0mvZRhJbeENTPQvD70iUG9VkGfzhj1erx+8YrReIa5sFBVlZkxJRgMsLSUwuvz8sH9WxjDHsa4h0/zUzw7xuf343GLhMNBfFqQ8WTO0uZtAuE4ihZCn86QRBebm1ukkwlmwz7jwZg3z59iTEf4wyG8gSi37t3HJbkIBgO4JQGXuaDbapLOLeHz+ZhOdVqdAc1Ok3fvj6hWO0geH4uFhTU3kCUXufU1ItEEfp8Pj6JSb5Sp166QRJFms4s7GOPup7+NLxJl1G3h8ykEQ2Fq9QqN8gWPH+6ykk0z7tTZf/OKTqeLI7oRZJFQPEMynSKVy7N7e4tEOknAF+TjTz7h/uOPsRYWPs1HPJEgs7yOW/GSTsTweTWG/R5uxUcgGOL05IIXbw/weH0YMxtZ8YNbQxRdzHQDzaPg86nUy9eMhkPq9Rrnl0Xq5SK1SpXTvbfokwml4jXnp/t4fX5cooA+GfPim18QT6d5+sunXFxdE4vHWVtZY2XlpvVgPOjjAgTJxWTYoXxxjLkw6bR6mCZ4FI1oLHJzi80t4/f7yMSjtK6vef/iJfVSkWKxyMu370nmV1leW0PTvMgeN5s7O8TSOc6rTbZv7zLq1cmlYwTCcXKFHLe214lnsqgelTs7W9jGmOrVKZLLhWTPAJtAKMQf/tGPCIZDHOwfUq+3iKczPHxwh3QqhW3OcbCpl4t89/IN+niKoihEEgm0YBwcm2g8iSO4eLO3hxaJE41GSSdjfPGzn/L189dUyxVkxUsgEMReLGh3uzRrNTxukYAWJOgP02/fxIIePLjFrVs7CAuLWq1NqXiB4BIoX13RrDW5Oj3ELd4Qenx+DZ/q4WL/HcZwyNXBa54/f0G1UsFxFjiCyHBuc12qofl9vPzuO8rlGi+fveTq+pperw+CC8NYEE1nmeoTdu/coVUusXtrjWjQ92vVg9/4kaazmLG2tctEnzLHYWEL6HMTY6ZTuTonmUzQ6Y4Z9CdIkoO1mBHwB1jb2qTebKAPBlg2uFU/c1vk+vyKDx8/pDcc8Py756SW1jCnM1Y3thmMdYLhMIJdQHGreFQvxXqdvZcvyeXymOaCr/7iz/jeH/0xvW6XwuYtvOEYguOQTsVpdTo8e/UeYzolkdYYdDsIjs29+7u8fG0ym80QZZmFaZBfu4WAi0Qyjurz8vLtAWN9jNjt0KlXkSWFOw8fMOh32d5c5fr0EI/sIhQK8tO//Cm/9bu/w3A4pFkts337zo2BxSMTCEcJeFUCfj+WbaN6FGT3jSut2WqRW15jNppyfHCCPxREdCvMDIOtrR3S8SjPnr+i2e3gFh0W+hhZknH7Irx49pxgJE5mucBkNMEYDQgEg4geDVGS8fh9pHLLCJJEOBKhsBTn4vyM0vUlTz77nGarS7Na5erwLevbm+hTA0mWePToDu/cEtVyHdXnw5yZWAsbZ6YTS6eo16o0GxUSS0tMZyZ3Hz8B28aaxyks5wj3BtTKVfr9AbFwhO2NVf78cA/J7eHlN79E16ecX3VpdYd4vD4E2yaZTGBMpmQLOZLpNGENXlwdMp2MWF5bwyOLjPQR1WqZRqPN2uY20UyGSNSHoqhsreUxTZPpuM/16QULfcpwOGRj9y4CMlalwsb6Oh6Pim2aiJJDfjnPu5fvCEbjNKoXCLaLbGGFyUjn9HCP3NoWYV+AQChELhRg1GmhyAKFpRR7h/t4QwFKx8eEUlm++quvEF0ubt2/xzUCnf4Qe+HcVPj4vXg0H+urOVqNGhf1Bu1uAEGUsJBoVop0a2X29hXMuc1gMGQ8NghEFvh8fp5+8zWn51dIloWkqFS7Y0xRpD9oE0snOXz9jF5/hLOwcInQ7fXQ9THN7oDJzEHzhVgurDCd2wiIpAtreNxuBJeE1yuxvXObvbdvGA+GROIJWs0+qaUckugiueRnbhiYc5NgOIbkdjMZDVE8cQKhCIgi8UQSxe3h/PyCYrHExs42kuKlVCyTW17h9PgIr9cH1pz00hIBn8b5dYlgMETI76PZ7HJ2eo41M2hUapg2tFp1PvrkCRYC3mCUbn9Mu9VDEExCoRCTYY/ZZE4vv4QnEGa1kGNtc4vT4yMioQBNzYc+s0glktSvLoivbSCIIpVqDbcoICChTw1Et5flXJbRaMzZ4QGa34dtz3AWN6i+yXBAIJJgPOxiz2cMhxMCwRDWwiQcuzG7xbNxsqureGWRTz96xMHxGaXSJZ1GjXGvwXS2wfu9UwadFo8//vCm4eCgRWF9i8uTIxaWiNsbpFQuY84XrGzv4sgqbq+NNxjCGwxx5+5t9MmM51//FYFwiFgkSnuqs7G2jKmPadVqJDMZ9l69YG1rm5Aq0KqXicVTjLodDic66XyBdquFPjN/rXrwG3/Dmxs6qaUlppMxoYCf+cxAVvzIio9QOILs8dIfdBFlEc0fJOD3E45Fub685OTNG5KpFG+ePyPg9zKdjsnls6wWlmg2BySSKZqtJpXiJdVag/rVOS7bwheIcHpxhhKOcfj2PZrmY32tQDig4vbIjEcDrk+PSC4VqFxdAmAtbOrnl5iGTTASZ2EatNt9ZqbJ9dUl9atTwsEQ6ytL7Ny9zepyjkwiisctYTviDZIrt47g3OR3otEoiqJyeX7B2ekRiWyB/8f/8x+wlEvhD/iIBQN061Xi8RAfP75NxK8y6A8Z6zNePX/GmzfvqNcbHB4f8+r1K1Y2t3HLMs36DSHk4ZMP+eTjJyiKl5kx5fjggL/48/+CMbeZTEd88Nn3CIUjTAZdpuM+otvDxckhNhIe1Uc8Eef2vQd4/SGK5Rr2zMAwprz67hdYiznRaAJRcvPJ93+I4vMzn01BWGDbFpqqcP/eHTyKl8ODYw5ffMf2rQ0kx2b91j2qxSrFYgXbpdDqT3DJMpl4CFnyUK81OD0+oVYsUW90uDg757d+74dMRh0MY45uOKzd2uWHP/o+4XAAt+gQSwRIJmNoXoXD4xOmc4tMfo2L8wsCgRArq2t4vRo+n5+JPscXiWNMp5jGlAePH3B2fMRY13n9do9+t41LceNxyyTzKwSCMSKJJSTBxf2dW4yGHbweF9eVCi9ePaPVrCErGsXr4g0STvGg+YPcunsXt0fGXhioXj/TiU6ldE29VMY0LPyahuUINNpdMskU8UgMURYxxn1kt4aq+Lg8veTieJ/DgyNcHoVgNAmOQLNWY+/0mlAsRSSeRHS5mI4mZFIZ1ldXWdu9T2F1mdFwzEo+xYeP79Jut2m1u8iyTK/dJJ6KEg8H2X/znEmvi98foNnqklne4sGDu2zeuUuvcxMF6Xfq7L16SrtR4vz4PdVGnUmvQzYVY319lblpoOtDFMXDwlxgWhCOJbEtkUQmgyh6uDo/p9fpo+tj5uacQa+DPpngVjxMJkOSiRR6r8vu9hoiCwKKjD2b4PeqTAc9opEIXrdMLJEgHEsQjaUoLKUw5nOCwQCHr16y9/6YZqOB7BYIhEKYpkE+myISjiIKLqLBINPJEJcsk1u+mWZMxlOisRTjQZuT/bcEwjGKxRKv37zHdMnMLYdOs8np0QVzG7YfPGBpuUA4GGA6HNHr9hFEgdlselM43Kjj93uBBfF4gqXlZeamyd/6W3/E8uoamqKQjCcZD4fYwHQBe2/eYkymdJtNBAeCoTBu2U2hkCcQ8LO2tcn3fu8PiaWyjFstxqMx3VadVqtOJBLEhcV4NOHxZ99jfWudpXQcUZK5ujzn/dv3NMplXNi0GnXMmUmjUiaVjJJfWWN5fQ1RdJFbWaHbbvHog4ekcstk8gVc2ASCYW7dvkdI83N3Z4PsyibTyYhEIo5lOYzHk1+rHvzGC14ym6NVr+P1SCznslQuzui2m0QjAYa9HlNdJ5ZIMLMdDvff4bgkzIWAaS6IZ5fRp3PckkR+fZVJv85oOOLP/9//lXKpTDAcJRoL87/83/4m4YCPja1NEvEYljNHEQXG3T7dVhXV76dcbXN4eMRHn/8O9UqFfD5HJOBDlCQEQcTlmExnOs1micXcvEGJjcasr22wtrFKbn2TleUcg34XReQm8+ORcCHQbbUZ1CuEvB6mwx6GPsXtcfPqm69QtSDBWIp6rcF0alIqVVA1H/3BkFAszvd/9Pu4RBmXKBGMhJHcEuFEmkAkSSKVQlU1vG43H96/Sz6f4+HD+4SDXiq1Jk+/e4koQjgcIxSNsRDkX42PRAZDnXZ/QCSZ5pMnD/jD335CNBzE53LRLBfp9/tUqjXatQaT8QRB9DCfT4lmlpC9Ps6vqgyHfbrtHlcXV7hcMmvLK2zcf8j61iZHRycoqkqz3SUcTxENhohGwpiLOYlUlNGgz6A/onR1xdbubYqlOvp0guZTkN0SlrCg121jLwwi0RiC6KbT73BxdUmv3WIwnDKdTkkvr3F0eU212SSXz5PJ5ZiMxlTKl1j2gjevXvPty0NsQebDJ49vqmcUN73ukEi6wMJ2ofpVzNkU0SUgK16GwzGt3hCXy4VHVShfnyHLbo6OTrk+PWSo61iLBYFAiFQmg+Zx06vXsOYGS4kww1aVmTlH8Wokkinm4x79bpvBqIfbI+LTZB48eIA+GtGoVLk4v6BebxBLL1FYXSUUuoExT/U5S6vbPHj8ASvLeSLRCIpbxpwbxEMas/kCywZZkMhnM0QiIXrdJseHe5QqJXq9Gs12l0q1huIWkVwikuwlGAzR7fbxB6Psbt8mlsqxsbXDra1tms0G5xeXOOZNuNojSiytbPDo8Qd88tn38EeTNFpd5vMZ+4fvqZauuTjcIxiJcn1+hup2EQurnJ8eICkeLo7e48JEVd30Wg3K52cgKVTKJc4O3pHNpvEobo4Pj5gvRPqDMYlUih/83g+49+ETPKoXr9+HPhmgqF46tQbD/oBBt8l3371msYBsJsPK5jaCPcfnC5KJJ9lcW8ZeWOy/fknp6px3R5e0B2NUr0an02Y2nWAuFvhCYbxejZ27d/jeb32CvTDRAmFkWWY0GHFRvKKwvYMoC1RLRcaDAb1Wm4N3+2iaF8Ut4fFIBAJBtu/s0uq0cCsKhc3bXBUrIHjodAcUK1WKV6eUry7ptPoguHC73QTCEfIra+CSmc1Mzi7OGY9H7O+94xffvmDUH/D8q58xM+eE4wmWV9dwqwqF9S0C0RRv3h4gefyMe13GgyFTQ8flmNy59xBR0TBNg3gqiWUtyBVyfPj57xCLJ5nNF7j9Ya6vrxn0u5yf7nN1ecnCBr9PQXZs1tfX0Mc9avUmxYtTur0OouxiOhkzGk2oN5rMzcWvVQ9+4wWvdH1JvXjN8tYuJ2fXhKNJNL+f8bCL5tdYWCbNehl9MMCxBfq9GxCqYczQ/F4uDg9JFtZ58/wV87lJKBAgkUnjUUTmcxN9rHNS7jDRDYLBINbCxJlPuffgHqYxRRIEQtEI5nxBMJqm3uqC4+LOvQfsv99DdEnU602uixV2PviUQCiCJLuRJTeicFPU2Ov26DcbDMZT+qMpp8eXvHv9lv/2n39MIhlnNhmgqBqa4iYQCBBPJNGNOcXLc+LxKKlkDFwyr98esXBcjA2dv/iLvyAW8nNRrPDv/l//keWVHOuFFNPRgERumVazQafVQZQ8bN7apVxrc3VxgTm3WVrdJZnJcefuPTS/hktSkBUFr+rm9//gd9HHPRamjter0ihdY0seemMDR7zBo0XiSfzBCNPphMvLYya9Nt/75AmhgMr1ySHT6ZzS1TmD8ZhKuUytWsftlpFlkV67wVe/+CWfffQBK/kcldNDEqkEb969ZX//LYlUDFXzkcjm6Q/7+MNxouEQLreIMejizGfUi5ds7txG18eYLonLqzKmYRBPxBiNBrg8fkxTIBJLMBoOWeg6rtmEg709Tvbf4Qv4KKyu4lV93Hv8Ac1GGVlRGY51TEPHg00yEafXbnFxdkn59Bi34keUPBjGjP5gQrPRJBaNEIuG0IJh2v0xLkkmmUrjljz0+kPOTk8olWv0xiO0YJRwIoYjuFA8HmzTZNjr0W61KSyvMmhW8Sp+BMfFxdkZ1WafeCZHLB0FARLJOLFoGI/sZmt9GdUtkEilsRew9+Y9//U//zmOZZNKJlAUheFoRqNSYqYPkd0uYokoAa+MaZncuXuPP/zh90hGw9SqJRrtzs3O0i3h8bjBtshmM1ycHdHrd2mUrqhVKyQyCZJLOTr9EZ1eH7c3QLvfxVwseLd/zMX5Of1WA8uCeC53k93MZUlnsziWjapq+Hw+Mkt5HPsm3iLJXurla9a2b5NMp/jwyUc3eUtd596HHxAIBcCBZCpD9eqEr7/8im+/+Za//Mlf0mp1+epnf8VcnxIIhJlMDMDh4ycP+Rt/9AcIAlwVK/zy628Y9ho8/uRjDGPE0cERvYFObnWTTz7/lE9/53cxR32WElEeffCYyXDAcNDHti16vT7Vao1uo8ZsZtJtNWhUy6g+DbBQJQnNpzKbW2haiNnMwnZs3F6VXq9PLLXEwnIwZnMcy2HUbHBxdsag38UyRiSTEWzHJpEIs7G+TTAUIhQJ0u52adfKDDptjPEIY2ZiOi76gyGjyc3YVxThk0+fEAwEqRcvQHQxm89xA61alclwhG3oTPt9JEWj06wjuURGc4fReERAkRh1WyQScZ589BGiy2ZtZQmPLDEejXCQGPXGRKIpwpEkbreK4zgEwkF+8cXPUIJRtnZ3+fiTD1jZWuPo4IhPHu7y6PEjFNnhf/2bP2Al93/FEv6HjkeWcRSFy6sr+vUKTz7+iHqlzMDtRXJr6MMed+49YGKYpJayuBwIBLaQXXB9XcXn96N4ZBamxUe//QPuLCc4PT1F9Wk4toQ/HMEw5tRLV1QuTwgn08RjMerNNm5VZfvhx9SuS/g0DS3gI5XOsLm5wmAwxUEkHA5QvDrD5Vikc3k8wgzblmjUisgiqD6Ni4sL1tZyyC6bsT4llssxm80ZdFssHItY8qYV4OKqgurVSKWiPH/6lERhE8t2aNbq2Is5B2/2uH3nPvn8KufjKfFUkt5IJ+D302wOUH0aoUCYVMhPt+7BmAxRfUFEYcGLb7+mUS3zzqNhzgyyhTzd+ZxQIg3iBNsCG4m5CcPhmHR2CQSJ3MYtvnv2ikGrynxqEI2GaFev2PngQ+rVKvFkhgePHmDbJslkit0797l/fxfbnPPtd68Y9PtYLhFJUSleX+MLxfFpKgfXNSRRQvP78IeDeFQPxZN90vEA++8OcYkCssdNo1LG0FdwTIGPv/d9JsacOw8/YDmfJ+D3s/f2DX7NQ0Dz0KxX0TxeDGuMLCn02k1WN9dQvRqDVosHd+/w9tUrHAEkl4t2o445m1E+2QfZzeu3r/C7ZRKpDEeHF+SX19nYXCMaDxCPxuj0ByiKgm3OaJQvadYliqUisiSjer18+bO/ZGV1hYDPh4NDJpXk+TffMIjcFGEOumNGgzOCkQSJdIa3r17gD8eRfT5yK9ts7exQKpUY93ssTJteu8vKyjLdRpVK6ZpquUQkmmb/9QsSSwVWV3OE/RKTqUG93kL1BVjZWKPZ6VAuFhEQ8Hq9zOYme/sXCJKEvViw9+4dhg39scHG7h263Q6teoOldAjVI2DN5kSiUURJJvT/4e6/1l1J0DNN7IVHwHvvlrd7be/SVlUWq8hukt3TGo3MaHRh0qOz0cg80+xpskmWyarKzJ25c3uzvIP33gRMAIGI0MGi7iCPEleAAzx4I/7//77X4yQSDXP0/j0X1wWGoog8l+nUaoQikRsLt7XLpNcllYzRLOUQWwUe3P1rFsslvWYbZTEnHE8zs5r5y9d/JBRP35SmL5fY3E6iQRduu5lee8725hreQJg//flbzk6vWExvqvciIT8bO9sMp0uUxZR4NIQv4MNi1hPwB7nK5ri7HiN78pq/fP0nDGYr0mxCPJkif93E7I9jtljw+ryUC3kajRb9dota3c9EWmC0CByfZen1BtjtLtY3tphNJ8zFHtFwmKN3BU5Or3H7A4iDPhaLgMlgpFOvsrOzweXxMeJ8QDKTopLLEkokUJQlrW6PdquFLCvojGb8sTRLjIRjAeSZhN3hwON18V//4R8xmWxMxCGReBKHy80nT+/T6Y9pN9tkVlLU2wJHb1+RSG+gKAof375Bb3GgM5jxejyMhmPm0zGP7t+l3+swmUqsrq/x+uUL1KmRiaiQSmdo1Ip4bDZ+/Te/5ccXb9BQqTdb9NoN4sEgXp+X7tUVsWCQbqWA2GsRDfm4vOxwfXWNpswZi2McngDNZg9lqcMTjFIpveUiW0BGT9DtojNZgMn6k/LgZw+8WDIFGpycnbK6vkE6ncBqFWgNxrQaTbr1MsK/ObYisRUazQaqGmIkjkjEI6ytpHj/5iORaJzd9TSFfJ7hROb6ushyqWBzeZFmE/bvHIDeQPbqmqWqMFuo6I0WZnOVhaJnNF1QePGSeDSCQadyenyI3elFU5Z4vAE2draRl0uCO7dwO5x8PL1gJnZQl0v63Q56rxepP0FTljjcbtRen5XNXU6Pr3G57KxtbTMUJ6ysJLGYjNgFK+PxnOL1OU6nh61btxlPhgSCHvxeN1fHh3z/6j2FqwsWkynx9CaNWofRcEgZCMViBP0+xkMRnc5EIBJnqcjceXCX16/foyxkbIKA2O9gNenRaRrTkcgPz5+jAzxeP/VWF6tFQGfQMxsOiEUjxJJx9Do9q8k4o1YNWV1ydHJGp9vE5Q1we/8WiqajVO1wcO8+0+mM59/9mWIhi8fjRTAa0RSVfK7AoNtmJvYQpzNarQ47958izZdYbVYCNg9Ob5Ds8Ufevf/IbDwkvb6DWa8HHTRbbU4/vCOZWaHb76O3CqSiMVrNJg6TisVhYlYVOT0+xm53sJiI1Dp9Lo4/sLpzi0qpgt5oJJZMo9MZUdUFs6WKAjicThRV4uT4kk6/S8DnxG630Wh3UaQZa6ureL0Bev0uy6XG/s4mO2tp/vEPRsKRENNRj29+/8+s7z4ikdkgEAqiLmU8/iAYdPSrVTw+JyajnmGryWw0xmCAgM/Nh1c/4A8lGEsS0USUpSoTiCZxuZycHR/hicaQ5AXlcpH+cIRZB7FkAlmaMjMZqDbaqPKCdHqVaqPNfD7DanNgtNjRMKIzOW8iOx43BYMBu8VEV1kyaNUo5WuI0xH37z+g1ugheEKEIzFarQ6RZJrxaIgmL/C63cwsAtVKHrvbSafawMiceSyMN5IkGg5Qq7UwGAyY7Ha2dg9IJCN0ByIjtw9fKEKj3cbMjN2dDY4OT1BUA5PRkMvrPJKsIIl9jBYTKkZ8kQSZTIahOOE6X0RSdZjNFsxGHfVKjclcxmy1U2p0iKRXiERCSKqFj29esru9ye7WCr/73R9p9pKI4oCt3U00gwGb3Uk5d000vcJ41Me5sUossY3bYcegN7Bcgs/nwOXyEF3Z4OBgh++++R5NhflsQrNew2a10u6OcLi92FXdzdRo0kewbVKr1RAHfaxWB7P5glqphLKYAiqjoRlxNGQylhgOpoijEQ8+vcOo06TdG7CyssbRWQ69xcpCVijkC6iA1xdgf3uN6Vik32uhoWB3+5DmEI3GGI6GLBUVv9dLsVSm024DOtIrmwyHffq9Lsl0GnEiUsiX2dnd4dXz7wmF47h8YZ7/+IbxaIQ4aPPw6RN2drc4PjwiHPTjdHgxW8yYzTcPdNJsytpqknK5zkySCSfSjCYzrq/OMaKRTMSp1yo/KQ9+9sDTG/Ssp5Ncnh3RaHb5X/6X/0w8ncHhdjEZ9Th48Jh2f4QvGEZFRVUVHA6BwWCIQafj7PSCi9MP6C123HYdKgYmCx2KTk8kEWE2lTAIJtDdGJX12hKrICCoS5wOB+9fv8QViOC0+zDoDKxvrZPOpJlKM3xeD4VcllA4gCTJlAs5dvf3MBggGPbjWU/SrNeI+FzsH+xzdHKFYDVTK1bxuZ0YLAZy1+dI8xCji0tc4RClso7FfMbnX36KJCk8e/YS0DMY9PH4QhgsNuqdHvcfPsJgNcFylavTE7q9Jp1KEcHpZmM9QzaX583lMfPZnHA0iazMWd/aptNqMhl2iUZDtFstTDYH0WiYiw8fcbpdCA4r9VKR16/fIw4HxNIr1Col4rEQW7sH/Pj99ySiUVRNYyyKZNbXWao6NgJe2u02P7x8xWw8ZDmT2L//mNlsdNPjqWgYTTZMVgsBr5f5fMFo0MMXzRANR5CcIocfDlE1HWsbK7j9IS4uLrn/5BPmKlyfHhMKBlnMZsznErK8xOP1IjhcXLx7zWQ0YGNnl9zZCbHNTebSHHcwxkomw1wUMRj1iJMZbm+Q+3fvUKi1ySTjSLMx4nhENBFHNxzQqDU4Pr1gvpBZ29lhuVSYzVUK5TrTmcR8ueTyOkfp+oxANI00HVOs2VjIC2bzKRbBjqYsCUXTJGN+dBY7J4dH6Fhis9tpVYo4bWbETgd1qZDZXKfVaaNXVZrNJiajGbtLwCsIvHv2jK/+5jfodSrL6QSvP4hRM2AWnFgFO/5QGKPRiMsbIImO2XyGQdOxWKh8PDpEVjQW0zGaTkerVkGaThEEG+m1dRRZRq/CaiqGrMocv3mBJE3xud0U8iWm8xlWm5XhoM9yPkEUh2iqHptgx+Nz4lRMjEZ9puMZeoOBpWbCiIZgE+gMBhhNFkaDPt5whPLFKcvlbXRWG7nra7qjEQtxyPreE9rNNla7B2kuozdaqDU7oDcRiadYKjJYb6IPx2dZlgsJj8+H6nbx8tUr/MEomg48ThvZfJnpeIDZAMVsHqs7yLA7IJsr4/U58Xk8BFw2Gno98XAUu8uDc2+TP/zxj4R9DgouN+GgF1lRODw+IRa5aToaiAvqrVMsgonJdIa2lBh0O5SKNeTFAqPbQ6vdYjaXUKYTHjy4S8Jno9EbodMZicWi+ENRptIMVVERrAIWkwGP20Gv1UKRJTY2tsjqDUSiER7upmi123REFWkyw+fx0JVVPr59jtfrwxOKcHaZw+l2ozOakecqvW4XwWrBZHfg9fgIhv0o2haVSp14Ksnl2YDixUfWdvYZdib0O00WywXaYoLd5cTu9hILe5ExUloqrOzuoCqbXGezPP7sU2LDIdnrLP5IApPZRMDvYWNvj2w2y6DbIRT0I8+mjPpNorEkj59+Tu7iHIBEKvWT8uBnD7xk2MeHj4dgtNKqV9Hr9QS9fuTFlLk4YCpJoGnIiyXDbh1/IIjJbCEW87ES93OZneLyh5BVHYoKnXabUqXCYjZGsDlYykuS8RhGgx6rxUZidYtmo0I6eXMEMN7ZpT+c0mu1MJogl8vx7tULTBYrps0tRuMJqWCcqThg2K6Szdt4ljtn7+FTpoqeq2yOjfVV+uKYSv6S9PoGb394zs7dR1htNpzeAE6vn/lsxrTXZiYILKQ5hydZcpeX2BweAuEAS2nMbLbEaIA3z3/gl1/9it5wjDSd8fizX9But3jw9Al9cYYgCCzmc8LxOOhNpBMZlvKUd29fYTZb2L97H4NOz8cX3+PwBfH6/fhiSQLBMEaTHnk+R5VEXE4bmVSUXqME6Oj3BnRbLfSKgsPnxxcKIdgFLk7PiMTj2KxWPG4vV7kZDpuAzSbQbtYQrE7u3LtHvlBkvFSo5nO4vS52D/Y4ef+RdmdI6ewd3nCcbquJ2WhEZzRiMhkI+n1MZRl5Piefu0LsdRBsToytBoqqEtT0mK0OnG4PVpMNwWxh0K6jGa3kzi8womMyHLC2s4lOnaM3mqi3BxSurrh7/zaC04GaL6JqGge37tAo/yuddodq9hzjxi7+UIjs1SUaKvJiTiK9yu7OFmajHsHpRIeRZiVH0OVFJy/RqQrnJyf4fH7iyTTXhSIaYBNsOG02ZH8Im0WPP+BFRU+/04WlxrDXRIvH2d3fYTJfMpNk7C4H08mc8URiioH19XWatTLz2QS3141OW9Btd9DpdZSzF5iNOgLhMNPpFK8/yEQcIPVnpCJhXDYrJouVQDDC8cc3RJcKil7H//oP/xtOrx+bw4Oi6ZFViMejTMdj6o0m0lxiMleQpAXr21uYgezVGbfv3WXQstNt1rFYLNgcdhqdEc1qmXAkxLjfJR6NYA8E6DcDDPptTIITq9WEy+UgGLxDu9UlnUnSePkWlzdFo1pmKE5wuTz4An4cLjf90ZB69pLk7XvUqhXEfpdPnjwmFg5zdnxGs1EmnkoTT2YoF3IkdzY4ef+esMVJLBrk7PAddoeTXrPKv//tV0graS4ur7HanAguG8PJjRoqksiw1PScnl3TbNSwOVxs37qF3WphJi/J57K8ef2exPo2GC0kV1IUskssgoNYJII0mdMfDbE4nERjUcbnecKOOEevXyJN5yiagtXuRJrJTMcj3F4feqOZzGoanapSzOdQFjKYPYxnS+q1OrV6i2anjU6nxxMI8fjJIw5PLxn1OkRTGeSBSH8wxOzwUSzXEBwuBo0q0myCzWbDqFuAomCz2nG6nQQCQTRNI+D14HE5efvuA71Wm62tLXLZawSLQMAXQBwM8YaDhBMZ6pU6g55IKrOC3e1jNBri8/kwm81oJ0cs5hKlQgFVUVnf3aPTbrC5vcZaOsI3f/qWmfLTHq387IGXz5coF0s4AhEmwz42b5DLfI5U1M/dB08pFAvoDHp0eiO9dhOzSU9h1CJ7ccGR04PB4SYWTzGbzxjOFiw0HV6XC4PPh96oJxWOU68UOHv3iuTmPjpUZFmm5/LTHU6JxWPs7rn4/tvnuNxxMBhx+SNEowFCXjfnHwesJGP8039+TjCWxKQ3Ek2tI45nVPIlXC4/8cwai8mMR08/xe2106zV8IUDvH/xHJPZjMvrYTYZ8uu//huKpRp6k4DeZMAVjGG1mLnOlzBoBhxuJ/VqHZfbx3AqozMItBt15KWOTrOCLC2RVQ2DXsd4PGUjucpS01OqVrAJBtLr23QbVRRVZTqbkdnavenYMxqR5hOWwFgU2d3fJRYO8uz5G+r1JkaDkUg0RqFUxOYUuPfoLqVKE6PeRLc7JBiOMJ9OmEhzOq1rdAYDNpuffP7f7AHJDB/evgGdyvrGFvLcxcrKCplMilF7iNfpRF1ZxRcIYjIaMdlcdDp9ipcXRGNx0BtJb+why3Nk65iN7U2G3S5HHz9itTuRxyLh4DqVWg1PwE8yvUa5XGZ956alptZv0++HcdtdpDKrePwhVP0pZxdXyEtw2gVWUglev3pBKp3CFQwz6zdIZZK43W6uz09p1xuoygyb4OTd+w9Mhh2iqTXGoylmQaDeqjEeDRgOB2h6I65gGLPdxmyxQKeo+MIxzGYzvU6byMGtGyuHrCDYXSx6XWwOFxbBysnZGZFwlEQ4zMXHBeJoRKuQxxMIMx3rMFhu3iCDAScOm4fxTMbusBMMx5BGbeKxCMvFAnRGfJ5NTo5PQK/DajayspIiXyrTrpdQ9RbmssInj55gMBoxGkzs7W9h0BnQdDren52jaQq9Tptuo8HtBw+wG6Baq+O22bk8O8MdjOAJaugNphvQhUNIkwE+nxer2cRUHJHIrFHLXeE7OCCZijPodzEazCgKFAo5luoSg9GAYDHhC0eZT2f4fIGbqjyzCb2mEYuFyV2e43D7cLpcdHtdhv0hw+EAVYVCNsfa7g6DRoVXgz5mkx5NVdBZLOzdv08yHOGf/rf/jcOL/I0jT1NBD8NBH5fDSb3R4/LwHaNBkkgsTuHqhOuzY9zeANNhD18sjSTdePEK2SzTQZuysmB9fZXjj8eYzSa++OQ+F5dOXr18x7DXA1T27z3EYDQSDgeZLhT6gy7ReIDpRMRqNmIORzg7vcBqNmMxqnz9h9/hdDn55PF9FM2Ize1GUWRi0QStZoNKtczmRobL0xNQl3j9TtwOBz15Skcc4vL6sDs9TMYTnjx9SDKd4uP793z+xWO+//45iqowl2RKpTLOvR0CAT9unxNBsDDqddm8vYfe5uH1y1fojUZG3SErmTjhqI9CIYtGmflEZDKd4LLbcHg8PLhzwMt3J/RbbTrtLk6nh3ZvjNfjQm80sbuS4dufkAc/+yvNyVzBG01jMJnRm23cunWLZDTCSiZFfzRivlDRGQWK2SvcHhfp9XVMFiuJlRW++O1fYbcJTIdt5oMur77+HS67wO7tO0xnE3Q6A+fnZ5htdj757Eu2dncR7HaCkSj9dotevcp4LHFxckK/1aDf6TMbj0murGO2CHSGIrcfPGAiDrF5vKC3oMhLAn4/6lTEblQIhkPks3l+/PYbxrMFPz57wZPPvkRZgslox+EJoCoysjyn02mTv76m1+1SzOaYDrvEYhGmgzaa2YCs6Rj0J+jMVho9kffvP+IORJnPJQSnC7vXi8moYz6T0KkakiRx8uYHitkzGrU6Fx/f4XB5UPUGLk4P0etAlWXGgw6hQIzpeEzx/IxGvUWjM2B7cx23zUS/2+Y6m6eUy+J0OzEJdirFAla7nXqtRvbyAsHtR9UZSK6u88lnn7K2tkrA7yWViGPSZKTpEE2n4+3LH5lMRNr9IblCEZffgy/ow+4PY3N4sFjMWIw6uq02gt2FwWCklL0EecZMHGEU7OgtAs1uh2hqhVA0itVuR9MU9HATthesLCWJUDCIisZ4NMCsLejWq4j9Ntmz94jdKoLNhiTNcNgsrK8kWEoi9UYVFQ15saBaq/P+7WsCQR9upwOzxcn23i1sdie3Hz3m/oM7+EM+losFgtVBvZTl6vyMRjlPIXtJ9uqmwX+pKXSaDUrlClOxTzToJZmMYxfMeD1OHG4LVqebQrVN6foSg9nKYrnEYrOB0YA3FKFUyiM4naAtCUbCGIxmwrEkfo+L69NjCteXOAMRcrkS5UKBpTzn3bv3LOQl/X6Ps5NTusMxK5kUgsV0s+c0mfn48YRao4fb42Y4Ejk9PSdfrGEUHFisNtbX1tnaO8Dn9ZBMpZhNJyQ3tghFkojdJlvb69RqVXQm4Wbkp5mIJ1d48tkXeMNxjCYjgUiY05NDlKVKJOCneHXMfDpiIg7BYESaTSlkrxh12sxmU2r1Gj6/D4PJRKtSZT6XCUWi2F0u6o0Gpxc5mt0uGAwIdgeyNEG3WBJLb+B2OcmsbWA2GrFZreTOThlN5rjdHirNDtVmj/TqGkYdpBNxTCYjDruFrd19xH6flWSEzf07dKtV7DYrjUqRejGP326iX8vj9flJpDfY3Nzki6dPuLW7Rb/TQtNBvzdgPBqiaBrSTGIxmXH/3h3q5QI6VcZmtTGdjG86PQdDbFYTZjPc3s2wu7eLTbCj6CzUW32iQReNUoFmMU+pWGQqyZitTmbjKYLDg8FkYTKe0W7U2dzdZWNnh+VigcFopN1q8M//8ge++dOfqFdL1OpN3C4XlWKOgNdNo5zjxctX5PLXXF5kaQ1mCG4fbz6cYhbMOB125OmQyajBxcU5VpsbVdMh2IQbEXb+GnE0ZCFrvDs8p1mvI46nyIsFmrrg9OMHKqUSHreNXPbyJ+XBz/4Nz2S2MZqJTMUhsUySUrmEw2YCgxGb04W+06d4fcZiKhKO3KGYL2E2G7l1+w4aejxePw6bmdFwzKMnT/n1p/co1LuYTQJOhxOx1WRjfROHTeCHH59jNJpYyEvMTgcWkxV0GvJSI56KkVxZY9gX6fUGiN06qqqytrnJn//wr8RW1lioOtA0bHYX/nCA5WyC0+0jmy+xtrOHwWhkMZ9jZkEm6iZ7rge9kVFf5O6DBxg1hf1bO3QGIxR5SSSdweuyk0inMFpt6PUmOs0GylJi2O0hDnqYzGm0xQSDyYKqzFE1DRWNrVv7OD1O2nUfkXAUk1GP3WZnKS+QxBHBWBSHy4NRb6HZLOLyqIxGY/SoaJqJ05Nz7DYL4ZCfrVt7YLSgM5ixO6xk80VkaULA66br92I2gsNm5aR4jX1rj7PDI5w+L4uZzOefP+bjh0N84QQeX4DZZIYiTanXq1x8fEM0vYrd5eXq7AJFldEpEkYDjAcDHn7yBdGIlxd/+QN/9Xd/z3yh4/m33zDsDdBUPfVKHqtNQG/UEQj6OHp/RCDk5frygmGnzi++eMq3z35k7+5D3B4Xk9kCp9tBZn2N2WRCr5rn3oPHNGp1rrJVTDYPyVAAM6ADXIKTzP4eTreN6WzOi2c/YDaZGPQ6iL0GdouVca9NIhql0Rrw2Ve/xRuMkMtmqVfLTCUZry+ANJ2yvrbCYDDCYjEgSiqnr46IZdbxet0sZmMWCqRSCbLHb2hUinQtFoLBEAtZpVYqcWt/j+lshg548OhTxNmEoSgyGw/xBYIM+n0WiwWxRIz81SVLGfz+MMXrSx49ustCErm6vKbjceMKhNm9fZcP794hL2QajTprmRRBr4ezkyusS5iMBjSyJ9gdv8LmdDIcDKlZLTQaFSwuNwYs2Ow3Giy310e/2WIi9plORrz88TnJlQ00DYwG8AWCTCYS04WG2+dnzWLhzu0DVHlBu3jF55/9knqryUJeks/lSaTiNFpN9EYD/U6D8mWDv/8//F/pT+Y0S3nsDg+J1TSRSIjV1RSD4RhxtqTf7RJORrEIVsaDKdJ8ydr2DivpKOJoF4PJyGA849Xzl4RCfnxuN+PhlOOjQzRNT6/b4+P7Y5wuN4mNbTIrq5wdfsDlC3L33j0sgsD6+jpHZ1d88+c/cnGdZdwfYHPaGU/HhMMBBsMRLquDUbdJo9djMp9hNFtJJ5McHx+zmE1wuZyU81coCwmf18b/83/+/yBN53gicYK+IOJsSbPdwe3x4fN4EGwCI3mJ3mgkd3VO6fqCYCyNXq9jsZhjdfmZz5esrqYJhfz88N1zTCYbFqsDlzeA2Wrjs08e8/UfvyawuYnT6UaR53h9kZtwvThGHE1ZTCUkaUkys4osSTx5+ohnz57jdDtAVWhUCmS2ttBQWckk6fTGDMQx8ZV1atUqU0lG7o4QxxLVWhe39+Z381N+fvbAa7XqLGYzXB4Xw26P6WiAPpHkxY8v8YXirOzsMpmM8KTT7O5ucnJ6zspKmlatgaIZaLWaLIN+SldH/Mf/8B+4LtXpDmeEwkGuLk7IrG0TC3o4OjlnI5PAZHdRr5TwRcK8/Mu39Hxh0qtpDEYvtVYTsdPD5QthFQQ8bhfjqUQgtULA46XZ7tLr9fC6vbx5/gqd0YIvFEWnady5e5tGo0Fmc4eZokOnKQQjYXRmJ9PxlFyhigGN1c11JoMu/X4Hk2BGUWRC0Rhujx+vx83v/1seTyCGtlRJZZKIkxmJzTWUpUKpXMHlcdGqVTHF9DTLBQSrDa8vQLPVxheM0GhUcZoMrN66z3WhQK/Xxe4J0um0qJfy7N19hNfnIX95iHfvgEKhTCAUpnxdIhCN4nb7KBeyBOMxppoRTYGv/uq3dLsdrHYv/JvPr9uo4ItmeH94xtXZGSvr6whmw82OVbAx7A3wB4P4gn5MJgPegI+5vGTQ6eJze2g3msjzCerSjizNyOcKZC8uWdnYxel0YNAZCEZjCC43nXaL6Uy5scarS5KZBNFoFI/fg9mix2M3sbezQ+7yH/nkV7+i1e5gttt5fPc2S02HjMJoNMTv86IzmGjUKyTWNsBkoFypE9WCqEuVSCRMMOglFA7TbHcoldtomp5ao42i6bi8vMQ/npK/ukBw+1A1HeV8nnG/RdNuI5rO0B/0sFt0WHQSZ++PaQSCdBt1IokU2eWcle09dnbWKBfrOBx2wrEE8lKmP5ZJxKP88OffkUplaNYbuDwuTCYz4USc0vUlNqtArVRhPBrRbNbRFBmL1cJsMsditrFkzsn7lyRX17BazFgFK0aDmelsRrlSIxAJ4vJ4CQQDBAIB5uM+gUgAVCOqMoflHE3Rc/ruLaFYiqk4xGwxIUsz9AYddo+PyUxCWcoYLQbarS4RKUAmleDs3SsqhUvk6RidpmIw2Wg3Gvy73/6KwWjBbKEi2GwsF3OMej1mkxmLyUgosYLFbCRbKGO1WtnYXKOQy9JpmljOFWRZw6BXkeYLXF4/zXKdsThlOh5jdzl4++JHnC43er1CvzuiP5rcjEsdLlSdCbPFhMViJZ5ZQ2/z0u71cXo8N99FkfG4BOTFhPfHF+TPzoinMlitZmYT6ab43eZgPupjQMPp9ePyihhtDlQ9zMQxOztbLKciFsGM2WpjudQYjaeMB11Mq2v4Igls5TqrOxF2dnd5+/od89GCuTSn36iwu7eLIs8pnZ+h15mRZJXk2jb3DvaY60x8fPsCaSoyHopc9/vo9DtYzUbKuUuMJgvRRAyT1U6zP8Lu8aOyZGdvh8PjU0wmMzabHd1yQcDjZKqXmYgi7XaXQavJbCGzmM2xmUyk13e5OPyAOBzji0R5/+4daxubjAd9JGnOsNvGbDBw5+ED3jdr9MU+A3FIJJz+SXnwsx9posm4/E4sFgNLaYrd7UNTNKrFEsNeG7NeYTzoYDQIvHj5GovVitdtx+V10u02mEtTpMmNTfzbN0ccnedIxCPMZlP0aNSqFf4f/7f/O8Nunfv3Drg4PMIbjjPoj8hs73L77m3S6STSXCEaCrN96xZLecZ8NsFgEShfXxGPp0mm08iqSnx9C2/gZsy1nE9pN+roDEYuzk44fvuCcinPh3fvePHyLUaTjfFogsXmwOP1I9jsGEwO5nMFm9mMxWRB0xnotkcU8zm+++45OosDaTqhmD1FU1XCgQDlXA5VpyDJMpKsoTcJxONR3J4Q6GA8HlG4vmQ4HNJtVOh2W7S7TabTEYNBg9l8hqKqhGMxVtfXMVv0wM1YZtjr4nTYcbpsTMU+miwzHowYD8dcnx1Tyl3wD//v/5l//S//wKjfYbaEsTjmr//D3xGKhPB6fPhjaRRVx6DfJxyJEAsFUOdjook0o+GY189fotOpRIIBUGWypQo2u51oLEJ/OMbuDWKxOtE0WKgyxfwVteIlG5vrNIt5XA4HU2lCr9/G7vFRa7Zpd3r0RzOSK9voLU5avQm3bt1mPOhyeX5FtZBHwcDZx0M8bi/FcpliuYKiN6EzWlgslpgEM+PZiI/vT3n2zbfMFgqFSoNKpcpkNOHy7ARZVtjYPSCzsYbL48frdmE2qkw7NSI+D48f3MXu8iDLCo1KjUo2S2c0w+ELkMqkiESiOP1hNjfXGLVqWK1msrkq5UKedn/I8fkV7Xodn9+HpKiE17YxmAyIkynyYkkwHEHVjERSGfy+m1J0s9mMVbDhcvuRpDnXV9cUCkVcThc2txudwcxgOEGnmdEZTQgOJ6qiUChUMJrMeD0OdJqMzWZl3B+Rvc5SrdZYYCAQT5BMxvmrrz7FZDJh0KlkkklmkxHzUQdt3GMqDpnN5mSPPnB4dIrL7ebxF1+ws7vJp7/6kslsQb9dQ2/QU6y0MFksFC/O8Trt+DxucleXdJotLo5PGHT7rO3dJZ5IUS7kcHqC/OJv/o6N3QOWOgP9wYC5BkazBa/XxfrmFpFwFLvgIBCOoTdb6I+GxBMpjHqNv/rlU/ZuH3B5dMj52RHegI/cxTmdTpdeJcd0NGI2XzDo9pGlOfc++QV/+zd/xSdP72KxmsleXuCyWYhEY2jygl88OWBla51Crct1roTX58VgMDHpD/EFA3T6ffKlEq1um+29baw2AZNRh16vp57PMuj08QTCCDY7+n+7uHX7gxw8eIQ/nCTitPK3v/6USCCEVafD6/ff7DJ9QaxmM4qioTOa0Aw67H4f7XYXq91JOBpl+9YOt+/epVoqU6q0GIsipUqDgThjPu6jqTM0A0wmU6KpVVKbO9gFM/FkEovLi8vlYmNvn2L+mtWEn3t3t0FdMp9rmC12Aj4XXpeNeMhLZm0Vq93JbCaxf3Abt81MOhXFG/D+pDj42QMvEY/x9NETVjMpurUyrWqFbqPG6to6m1vrmM0GIsk0ZsFMp90if3XJq9dHNBsdJuMeRoOBQbeD4PTSazUQxyLD2RSr1c7tW7cIBoIYTSZGY4mj85tgrdtup1kogA6KxRIvf3yHz+/HbjEzn0ksZjKaUWA6nTEatAj4vSgaGAx63C4nV2fH3H7wmM+//CUOQSCdzvDLX3xKIBgikV5hZWMbo9VOs1mj2yoyaFYZtZs37i+xz0wS2b9zF7PZhNFowhsOIU5mOJwCd+8e0G5WiW/t4o2mWah6nKEY9VqDRu6U8aDNbNSlWq9wfnqEx+On3x8QDPvQ61SMFic6g41CNksoFODB40eYjQb6jRp7t/aJhLzkrq7ZufMAo9mKw+tjpqgoqobN7iR7dYbT4yO9tosOPVu37/HVv/9bMju7OH0BVlbTBOIxZnOF2XhAv9ukV6/Q7w5pNttoioym0+Pw+VksFug1PVOxh7KE1UyccMBHs9lkOp9zeX7Fd3/8mvjqFrKmxx+OsJgvsNvtBIJhDCYBq81JPBYlFYugTIc4BAEUHbXiFf/4X/4Lf/iH/xf9Xod87pyJ2CcUCCNYzBzcOSAaDhJL3ohrfV4fylJBsBhxOe14PD5G/RGCUcfG5griaMB8MiHoduH3uPF4vVitNhqVMs1Gm5OPH5lPBjgcHsLxDAf37rH8t+thl9uL121HsBhRlzNqtQbNegNZvRlJNStFsvkCzlCMyWSM0y5gFWz4vX5cDjsum8DD29uMWjW0+QRVb6DdLIPOQMDvp1avkjs/JZfN8uP3P7CYy7jdXtrNOgY93Lt3i939LXrtDp998pRq4YK//PFfyJ5/AHXBQprSarcwmq2MxRFnx4f4/R5sbi/jyYhus0K7UmI5XzDut8hsblMqlJgMO0wWS/QWPYFIHKvNzcrWPvF4hpV4ko3dA7qNBrlCje3tfXxuD29evMEf8LGysYmiLBnOlpxf53H5AlgEJxgEHE4P8mJJKB5nc3udYb+NtJiwsrnJ5fEHVGmG3WLEiIrYaTJoNQlEQyhoXF2d0Om10Ruhkr0mmVrFpNPx9Z++wWC10h0O6XS7eENhHC4XqfU1bj14xJP7e/x3/8N/QFNl5mOJ8ajLydEhM0ni9dv36NARSqSYzSRC4RD7jx+xd/sAry/AUppTK5dQMFAs5Bi269gEK8p8Rr2Uo12vU640OT8/Zzjssra1w+r+XRQ0EokYfq8HweZAnUt4nQ563T6Hx0csNZl6q0Wz08dktRHwO5lPJ/QHAwxGA6gy6VSKz57cwWkTCAUcaOqM3NUlDn8Qm8NGqVknf3nCXJqBzog8m+FyuYit76IuZXbWVxC7TQq5LN1Gkz/+7g+8f/uG6WTMcDjEarMhyRrT+RJ/NIndLhCJR9ALTl59uGYgTuh2u/iDPmaTPmeXp9S7Q3zBCILVisv109oSfvbA63WGNJotgqEQwVgCi8V8swuSJAwmE+9evCSazDDodxH7XXRGHbI2Z2N7k4dPf0Eilcbr9SPNFgzaDVyCndzZNcXcFUudjuLlCZm1PRSdhbdv37Gxd4vJdIrF4cRuERBsdvqtBq1ai+//8meq5SKheJz5YsnV2Qmx1CqD4ZDucEwoECIaDt9c1ClwfHaBVbBRr9T4w++/weoKMBhMOTs5IpVOoy1ldvdvkVpd5dbdh3gCIfyhEILLC0YT42EXcdindHWFy+HE6fEzGox4/NmXBANBLo4OyWfPcTgdzKcLMtsHxOIJHC4vNrsbTZXRaUvqpRLhWBK9yYzBoMfutCFYLYSDYQJ+P/PZhO39O0gLjY+HZ8ymM2bSgmG3hSzNcFhNbG+v0us0qZYK6NFQ5jM6jSYfnv/A0ftjIuEwoWSKkw+H6JYazVoXncHCwZ19fvHrXxCKRNHpjYyGU4JeDwadnuFoTLWQw2QwEQlHUZYa/lCEze1dfJE09UYDg8lCKXtJLX+N2Gvx2aPbKPKc24+e0mm2aFZuRq6iKGIR7CzmM6qFAoIrgCcQZufBIx493OevfvkJL55/zzffPadeqWERHBTzBU4O36FoKsViBVleksvmKRTLmEwGUskEmrxkMp7h8vjQjCbK9TqqoiMWi2G2WNGZrAwGfYxGM5PJlNFgwHQyY7xQyefznJ6fYDKbWCo6hqMxWwcPWVtJsbG5hR6Fne1N0ukM+csLhr0+brsLfzBEo1qh1ajTrJSYSjPKzR4zaYlgseN2uIknUuQujqjWqtRzF2xurLOSSd/8AcszxPGIYbeNqsocnV3R7I5w+YPYHR5WV7f59IvPWT+4y8PHD3n66A7+QACTzoDNZqM3mNDs9nH7wghOHzanm2A0wUySiCVSiIMhpycXBCP/fynxTebu8uKSN2/f0mo3ODs/plwqEI4nkeZLfv+vX2O2CDy8d5tmrYqGDrtgo1EuYnc4qZezvPjhB2rVMvPZmMxqhpnYBzQGrSZTcYjbaSOcXKEznLJUNDLrq8TjMdYzCUIeN9Ggj2goiFUQsLndjEddPC4bvkCQ1PoWo7HEcqESCYQZj8d0B2Py19dcX13y3bfPePXiNcNum4WqoNfp0KlzQn4f0mLBi7eHqDoDqk7jD3/6M9/9y39Fms54/eGC3HWJg+0NQk6B5VKhXa9gMOnR61Wi4SDegJ9Bt4c0V+g2GmTPjlhbX8Ht8XD04Zh6tY40m92Ifk06lkuJ8XCAyxemNZzylxcfaHb6CHaB/X+L13z77Ef+8K+/J3d+hNWgw2a2MOhPsLt9eIMB0ukEsViM5ULh7tOnbG2tE07EmM0XiGMRWZpjMJiwO5043B5UPUTSK7jdbjrVIuPhgFy+RD6bRZPH/Pj9tzc7y+EAbakiiWMsdicuX4hep4O61BFNrbEYDtBpKouljk57SLfb+0l58LMHntXh5P3b97z48QMH958SjkeZy0sc/gj5bBFpOsWg07G9s8Pf/P3fsbmzR7tcRBwNub48ZzJs8fTzJyymQ/bvPcAf8GKzGrEYVBbTEXptQatyid2qw2ETyKQTlC6vEHsDJGlGtXTN3t0DBt02nkAcm8VMJBrBajXRrZXQ6YwUr66oVyocHOxyfXGCtJSwCgJLZYnDZmQlFcJoc2Gx2TFbDFitAplkjHB8hUqpQu7iiEq9Rq/ToZzP4XX70GmgqRohn4doOMDu9gaCyUCr2aBczDEVJ9y+tcPm+hpmZBqVmxBos1xCWc6xOW3c//xzdGYLd+7fZWt9na3NVVwuO3aHHZ1OR6vZoFgqYjJbEDxhxKlKIVdAcHnw+r0INuGmA9Ng4vrsArvdQSiSxOvzYrGbSa2tsnXrNk6vH4NRYG8liRkFq02gVMhxfXpEMZ/j7PSMYvmKhSzx4Ol9LFYLBhQmvSbV/AkWu0C1WudPf/gjJoPK9uY6ufMTvIEIyZVVNvf2sJjN3Lr3CKNJYDFXWWpw+84ewdBN/OHls2e4XD4sVisaC+LxBMpColYoUC7Wefv2mPTKOnfv3cFsEegOxszmCyRxiMVhw+dzYzXpsBh1zMcDhoM+7U6LemeA0+nE7nDQaTWo1up0+y1cTivpZJylPKfXaTIVRVIbu6gs8fq89NptnG433WYDTZZoN+t06mWmswWVSp3vv3+OzmSnP55jtAps3bmHOBljFuz4fT7WdvdJJQIsFxOG/R7L5ZJoLEyv2+Hs7Ixed8jBw08wWh0EwlF+9ZuviKeTSPICwe7EYrWwfe8RVleAhbxkJZ1GkRXevnqL3W4jk0phNZp58fIdr98eYRFshMJe3C4bgk3AKjgx6nVcHh0yaLewW020mm3azRbzpUogEkfRdCxUhVI+x0oyxle/fMLTL75gOp6iM5ox2VyIowHSYkqrXuLZ9z9yfFVgdXuX0bCParQSjGfojyakN/f49MkD/vbv/x07tw+w2ATEQR+Xy403FMHp8hALhxiPBwyGA46PTpDmC27du8X+wS4Oq4nJVOL2/bs4XXbsxpvO0lqjyfXVNYNei3L2jN6wDwawWizE4knQGXD5vID+ZuTrdDDqtXn8+Zc4vBFUTc9yNicW9NNt1HC4naxtbGBz+nBZTKymIrgcFt6+e0ssGcHuchNMJghHwyRjSW7t3+LR/VvMxwMq+RxoGpFwBL/XwfbBLWaLGf5ggGw2y/fPfqBea+JyewgHPUjjIZ12F73OwKjf5iqXx+JyEg1HSUVDbB7cYzpX+fb7V/jDYVqNJl6HE7dNoFqp8P7DCe1aHZ3OyFQcoSzkf3NJtrHa7BSzVwxHY548eUTQ42I8HePx+9nYucWDB/ewGDRsgoNPv/gSn9eHxWxm9859BoMBOoNKNXtEpZjHoDegyXPisTDBWBSP24FRz7+B9Kc9M/nZA6+YPaGWPaXTahAM+dEvbzooK7lrNL2ZT7/6CrfDgsthY2MtQ7fTB6OF6WKOzmDk4eNHjAc9Bt0m/+Hf/xppMsHndvI//F/+J/zBKLcefsKXf/23bGxuYzGbkOQleouZ1c015IXE2sYWbrcPRV6g06sk1rbIZ3NMxTH+WAJPJIKsqMxnE/7wh695/sd/pdtsMeoOUaYT7DYzV+dnOBwC/qCPXrdLLJlGHPRx2C3o4KaUVa/RqNco57LMxyKDbpfy9SWVehNVr6cnjlhqGunMCiaTFavFQr/fx+Vw4PO4CCfTeIIRvJE4Toed9ZUY0kxiOp0xni04v8zx6vsfCEYSTCdzpkuQZBWWKv/p7/6aYa9JtVLAZLZgtlow6DTG4gh/NMXbt6/p9rts7W6TWl3HYHHQavfZ2N7mN7/5FXaXi3a7w1ha4IuGWFlfJRhPEIqnScSTyCoYdTqU+ZhGs8Vfvvkewe7AZLHi9Hi5c/8B0mxMMBrHancync0xG83I0piROMKgaiRjEbrtNn/+019o1Eq0u21++OEFtx894vbtu6xtrqE3gM8fZOfggNu3tzGYLfQ7LXLFMt8/+wEFiIZDOGwWnE43vXYPt/9mfzKeTEitrhKLx4km09g8bkrZc+TphHarSa9aIB6L4XQ5b6YNwQChcBCf30tqbRWT0cio12U+lzAYdOzubzOXJKKZNcKxBHaXh0dPn5KMRQiFYzg8DsqFHNnLAv12i73tLZT5nEIux+VVnvGwjzcYI7W6RWZrH4/zJiYQT8TJZFKgV3n74zPq5Qq5sxM+nl3w7NvvYDHj6eefM+j0aVSrmExmHC43C0XD4bSzubeLpNy0uoRCfsaDAQp6FFnCoIfpQiKaTIBeByY9Lo+bWHoFNJVf//JTbt1+gN5gwGYTUBSViThlMBI5OznCaLKQjrgJBgME/GHsdjsmgw6/14czEMZgMNDt9rl7e5dHD24jL6ZcnbxjJnYZdJtkC3mGwyG9Zo2lPCW9kqJRrxH0uZlOJVrDESarwK39XaKxKOXsBfOFioKJfKVOoVCg0exi0hsJhsIkEkkWsxlmo4nNtQxer4+Pb15SKpeYjoYsphIzcchsMqFRbyDNZfbvPsTp9910jQ4GXOeKGC0O+r0OWzubzEYT0rE4j58+5MPRGR9Ps3RHY1S9iVZvStAfQpYWVEslup0u2WyRiaTwyeefYzToMAlWBoMhr56/xmg0Ic9nmAUbqArNWhFFp2Cymnjw6An3Hz8hFI0yHUtEo3Gujo84/3iGUa+j024wn43QVFBVCx8PT5BmU2RFJb6yRrfZJBQIYLfbOfnwkVK1dbO3VmRCsTj9/hBFg0G/R1+coOoM+N1unn72BUaLQL1/ExlpN5u8fHmEJMmMhxMajQ69dp1EKk3A5+fWnTukN3dwuTxY7U5u33tIq9PDE/DS79aplco/KQ9+9sDzBiNsHtzl1v4aC3nC6sYmrkCA8ajLoNdjMpaoVus0W01evnqLXpWJJFc5+3iK1WojHIwjOD2k17dotAe4PS6a3R7/+K/f8PW//BM6nZ7jo1Ny+Txmh8DH9++JJpIYTFb8fj87W7tYjSaiiSROpxODzki/12TUa7OxtY3YaxEKBvjVV1+QXMmQXN9ib3eXjfU11rf36YkLCsUKfoeAMhszn4gcv3/H6zdvGQ1HLJcKHl8ITV7i93pY3dxmb38bg16P0+skEgui08PH9x+w2Rxsra+gUyV2NmL0200sVivPvn2GUW/AYDSTPX5HKpOi3mhTzmVRVbBaTGg6A25/CMFipnJ9zrDTwOF0MpbmFKotfF4nRqOK2WbGbjZitwg4HE7ikRDaUmYxX1CvN+m3yjgcFrrNOifHZ/z+j39kORsTjSX4+OGMZrmI1Wwkf3GIxWHnulylUcmTTK9y6/4TFEUjGo2ytpJmLZNidec2S3nBUhJxeDzIClTqNWwuJ+FkhlA8Q6vTw2AVMJtMWAQnqY1tVtMpBv0e33/zPf/yL//MxckhwUSSi4szSsUSx6dZcidH2N0e4okU8VQSt9vDdbGGNxJHbzDgdAsINgGH2Yw8GSDYbSyWEu1GhcVMwuUOsL69x/r6JpndO2AwMR2J1ApZCrkS716/4uGTJ5gMBjSDka29fTqdPoNuj2QkQK9ZRRyNKNQanJ8f0+gOMZr0nJ8dM2h32Ts4YDoZYrE7GY9nONw+BMHETBqjqRqj4ZBOu8No1OePf/qG85MjZtMx/cEIg0HPzq09bu2skd7YQxwMWaga46mE1WzG6bajLSX8fi8+twPdUqLbqnJxcYY4GjGXl7x7+x6DxcJSU6mVCrx5d4TBbGc4EBHbDXLHR+hNFta2d1nd3mIs9vn49iXyXAajCb8/jtVix+G0Y7a5+OH1IW9Oc4jikH6vi93uwGgwMpuOmQw6WMwmvA4r33/3jFani8lkwxeK8cknj9Fr0K7dHOcMen0sRjOhWBqHy8327h6TYYdmrUXu6ANvXr6kXinj9wewOT38+OItx+8/Ig371MpFxPGURqtDMJYinl5lqehwWq2srG1gd3rZO7jPzu07xFJhfvXLX7C2us5sJnJ8+AF/wEc8GmbU67CUZSZjkVwuy6jfI52Mo6FjJE65d+8eFsGCOl+wvrXLsNXi9Q/PKRdz9GoFUBWSmQzSXKVcbXJ0eMrGzgEHDx4jjkfoTDY63TGjfg9xOODeg0f84jd/y8GtW6jLJScfP6DIcwadGomkn4ODW/gDAQwmPaFohFa1gjrts7W7QfbsLXOxQywWZjIa4HG6kKcS9WKJ+WyM0y3g8jgxmm1omobbYWVtYx2b083bH56Ru8oy6naYz2aYdAqDfhPBbsUfiaIzaNQKF2xub2MWbJitVnyBIJqy5NMvfkGz0eTq4pTDw/eUi2XGIxFNUxl2erjcHow/MaF+9rGEpWZgZ3ebUafNMJvD7Y5iNFhxBiMslkvyhSKraykW0gK7004slaHbHSLPJI4+vGYmjqiV89x59Aknh0fcvr2NVdjnd18/486d2wSCQcbiBD0yHruLarkFgM/jptWuc311SfbsgmgmSWp9k26nA5pCIp1Bb9DTqdWozJdU6zVm0py927cZdNtcN0/Z3N2j1++TWd/B7nLi0uvQ3b3L5fkV0kREcDoI6PWMBuObwPh4wHyp4Q0EadZrfPLFV2jo6A4nbG7swFLl7dv3pNa3Gc9U6rUa3YEIOgOp1Bqt/hDNYKXRmWEyW5iNRzSWoPh9DEZjfKEw86WK0eYg4nLjdbuo5q948cMPKEuVrZ19FFWhUSrR74/wB3wMxQm+YJBYNIaMGSGzykwUQQOL1YrY6dPXBlhsThwuJxajl5jfhzsQYTrq0dXpGFSr9CJJ3IEI0mxCp1rDZjVhstgJRcwMJ1OcHi87GxlOjs/pDQcM+20aVQuV62vcfj+zZQibw0axdIHJ4eT6qoi8VIjEEugVGZddwGyxIM0XjLpdSK+xe+sAu9POb3/xhH/4pz5TSeP05BiP243eIGAwWrlz/z7yUsHh9pDJpOkNh0zHr9HkOfJihsMfoNFpsdQ0Mok40tSLsphhtBgwmowoCwkDGpNBn4vTUwxmE+FIkrlmJLO1R6vTYy4tCPhvRmKK000yFMCaThAIhZgOxzSaZarVKhNxyNSgR1qo6A1m5KWKPxQiYYwgz2fEkgm+/m//TDiaQhqMGIzGuJ0idufNVe7Zxw/YPX7OrnPYbDYMZjMmq5VyqcFk0MQZCCAvllgsAidHx4jDPug0Nm/fYVjLI8tLpqMpy6WKIxDCH1yg6Q2YTTranR7ddhOvP4AkTel0GqgLFZ0RpsMBkVgIaamn32xjNhm4On2HP5xCWSqsxBOoQHcosr6+yevv/8zx2SUWu4n8RY4fX5lZKAoH9+5zfpHH6grS6YzwB704vW5KrQ56owmnx4UvksJktnLvzm2Ojk84Pjmj1agyl6Y4AlG6vQH2hUo5f0l0dQtNWSIOekynPUxGG8N2k5OP73E4rGQycer9IUsVEukthsMuhXIFh83Bv/vyMS8/OJjNZQS7g+zZR2wON0aDmcMPHzCbjLQ7Xe7dv4/d6aBeyhFJJLA5XIhBL06nC3E8w+110M3WKGdPmUxG3A98xp27B7x//ZZmtYIrECOdSeOw3ZRhhwMe+sk0L559hyscweELsFRu9EE2i4V4PEAiFiazuspnnz1lOL95w00kE3g9Xj6+e4fD5SSzs818MsHlspPP5XA53QjrFi5OjxhPxqAz4fWHGY+GyJpGIJHk8P07mo0aYq9Lo1QgsX2HxXTB2voq40Gbbq3O5p17mMxRuo0WAa8Xj8OC07nKxeF77B4f9foEi8FAtZgjGImyXPy0xvOfPfB67RZ1l5NOo4dVMOEPm/G6LIyHCup0gMFpR5otqJRKDDstwqlV+t02bm+AaDTOTJYIBn3sbib5/rsiv/vDn9GMFqR+l6d//3ccn10izWc47Hay2SJ2p4OeOKLdnuP1uVlIS1a3tgiG/TTbHY5fv+DO48e4fUGGvQHBcBwFkKQZ0UgEm92GslTZCIQplms0GnUEh5Nvvn3GcrEgklrF6fbchLabDfbv3iV7foXb42G+kNDrNPxeO7I0pd7o0aiW0ZlNrK2tk7s6x2jUYXEKlLJXmJxO3L4w0XAQaTKlVSsRiCVoNOpMxD6f//o3tDsd/E4Hf/nTN8jygo7BiEUQ8HiclIsF3E4nOr3xxkY9nXB++B5FXbC6d59Ot4d4dUVyY4vpUke9fE0stXpjL1cUxsMhs5mExxfm+P1bxuKASGqD3339DdPRgP27jzBYLDj++u/wBgO8+fEV00GbYCiM3x/g7ds3uN0OxpMp49GI05NLSvksnnCYze1dNtZWiITCWG127A6BZ9/+iF5vRJEWCIKJQbNCMpViZ3+bsbSg0xthd7qI3IthsdtRRkPiqRQvPpzR7/dxuALY9HaK1xcsFIVgKMr54SFmqx2Px41ONVC6LmO1OzELDtJuF2txH6/f1qjk8qiyxnI2QKfXMx7PUDQVTVMZjUWiiQxbO1tM5zNa7QbXl1eUcnncgQi+YAidGmZ7Pc3x8SXzhcTm9i7NVotA0IOqV7HZ7OzsHXBdyJJYSXN1fMTJ0RE6vQlpPGDvzm1evXxFMBJiZSXJ6++/xesN4g34ODu/ZqFWCcairKZXKFUqLFUvkjRFmo2RVRmT3YXXH+D47TtS65usbe/Q63TxuhwYLQKyoqDKErI8o5w9p5Y7JxAJY9CbuTy7YDmfkshkkCZzoh4nkqzQrpRJR7ycjUfMZxL+QIRCrkPA7+XBk09x2m384fd/ZiiOCcRSaL0W+UIWk2AjHInSH464lo/YWMkgJ2PMFjJ6nY7JpM9UHFPMX3Hr3l0atSoejwejwYD737KH7cEAo9UE2hJfPEO/XiYc8DKazUnG40xHA0aNMv/df/o7jg5PsbncLDUTet0eer2Rhary4fCcQNBPo9VEU3S43B7K19egNzKfL+l3mgRDQVwONyaLHYPNjsMo0Or2QKfjkycP+fjxkMdPPyEYijAaDhgOR4jdDt7bd5EWS7weN6nUBnaHk0GnhckgE4jESGWStAdj2vU679++Z2VtlaU0RpyITCdTgsEg47GEslDotPtk0hq/+bu/5/LiCr3RRCKzwun5OV1RplTIotdBdzCh2+vgCfvpdvr4fH5MVgc+f5BYyI/BYGY0HCFNJWKxEMNBD4sgsJSmGHUqgtXKg3u32dvf4Y9/+Jp0Iopre49Os8FI7CGOZxROz3jy6WM65SIvnv/AcjEntbGF0xNkPpVwe1wIFjNO501lWSIR4/t/+ul48LMHnsthpd/tkFpbxet2cfjxI4FIiDuPnlIuFRkNhwzPL2+KpMd97ocf0K8XmY9FjDY7i9mYp599RiQQwGQysrq6QqXVY25xUWv0OH79knBiBbvVznDYRTfU0+8NMek0wpEotVIWr8+H2WxjuZAJh/zsb6/x/uiaiTig1+thMFsYdloEvB4Kl1lMgsDO5ibNVgd/LIbfF6RRKdEZVOh1mni9fvYP7nJ2esrHl6+p5i6xeX1YLGaSiRgXV1cILiderwNp4qBWr9Fuuun1Ovz27/8evaYijUQwWFjICv2RSCwUYEVJkMik+OG75wgBO/VqlQ8vnnPvky/wBiKEomH6/QFzaYxBr2c4GpBMpHF4Q7g9DvSaTO78mG5PpFoq8fjxI7p9P7K8YDybMh31sNt3KOdzZFYTmOw+xk4bqbU4gs1IKOCl0R/hFFyk4gNUWeTjmx9JZtLUSnOmww4bu7vYHH6G4xnBcJgvPr1Pq9nlu+9foDdYsDk91PJZBg4X5UIRvUHP6voWp8cXOOwCLrcPm01gKIr4ExkObu8yHY/pNhroDWaujw/Zuf2QTr9Kv1nD4bCRvzwjE4/y4OEB//CPv0PWDDjcbgxmC/JiSjgcZWVzlxev3tGo5NnY3afTrNKeS6QzGYwGI2azFYtJj2D20O22MAomxH6H3qDHbNin3mijaQua5Rw6wY7VaMFiMdGu5lAWM+bzOXpUrk7eYTabb+zR8pxkPExyY49mR+Ty9APR9AriaIJgs7N36xY9UaJavGYsjpiMp9gCAQ6Pjhj2arSbNQqFAv5gEIfdxv379266SJ1eUPUoMoyHN4cIhYsT1jfW2N7e5N3rV6zu3WE2HePx+jEbrSQzG9y5d0Cj2WXYabKxvQMmE8PeELtNoFYuolNVHC4HH169IJxIY3XYsLo8eAIz0lE/kVCAfq/PaDKhWm3i9TiwWvSMBz0alTxrG1sMAZfNglGvJxWNUI2nqFVK2BxO5nOVXqfDwd09au0u1UIJZalhNBqpVctoej3hdAab2crp4UcEh0A6mqTX7VHotJn6AixmY3rdOolUnE67z0W+Trvd5Ze379AbTjn+8B6Hw8l4IqIqMmaLGXk+x+v1E08l0BsMDAcTRiOR+RKqpSr//X+6Ta14Tf7qEpvTTSt/xhuznlg8iShK5KttvOEYtfdvcXsDKJqe06Mz3F4fg06XYX+AzmrC6vZjd7i5PL64KbiP+FEUHZPpmMurPH6vE28wiKbpWd0IYLKY8XncFHNl/vD73+Pz+WlUiuhRWS5l9rcyHDi9TGdTeq0aX96+jSxNUBdLUtEw7z+esLO/TzAU5urqEqvFRuHyjMzWFhhvsotmqxVZXiLLCxRF4V/++Q8YrVY0TcdClikVLmlWSqzv7CMvYTGdYTGbefjoPq3ukHK5SrNaJZJIIUlT5tJN0bvZrKNeq5JcXf9JefCzB17Q78flC6EAi8WYXqOML+gjd3GGpjfh8wVptxrIyzn7j55gt1t49Pnn+Lxevv76Ga1Clr/Ml/zXTp27D+6xs7tFPv8n9vb2abYHeEMJosk0aHo2tveIxmLkiyVGgz61SplGtUi1eE0hl8dsNuLxBcjmq8zGPTxeH+gNGK1WbBYTiqLSrFaZL8ZIU4nC+SHxlU0G3SaTyZiN/fvMFxPW1tdQ9XoePrzD8xdvWCZWWdndpF5toGCklr3G5nRTyGdhuWB3f5/zo2Ni6TSlSo38VY5YIobb6uT69AydDhoaHOzvEwt7qNQ6xGNhVHnObDrj/OiYlfVtlpIMypL06hriaIyymNMb9qi02jdhZbMFXySC1RNCU1TkxYJGtUpmfY3i9TV6vR6ny8FSlvAEN9HrTeRzecyCwGIsMp3McPuD5HI5nt7bZi2TQdWMSJMB4nyBKsssFgua2StEcYjDJvBKsNOsV3F6/UjyFFVZsnNwh9Gwj8PrpVoo3oSLp1N0NguLpYLYqNJt1nEHYhTKTd59+zXhWIrEyirBcAyP247ebGAxsWO3u/BF4gwnczoTmWA4imOu4PF6KF5fEopkuPPoAZdn58wmN1mvGwVOlFq5xPc/vGA6nmB3Crg8bnTKnPv3/woFFZ/jF2xtZPgoOBFcfm7vb1OKBJlJEppmIBQOEQn6aHV7FAoFEvEYs8k2lUKBX/zqV+TLFexWK0aTGaPJwEwcgDInlVzh26O39CIxWr0RFpudeCKN3ebF7/fQHwxJbd3m88+f8rt//G9Mx0bGgw5uh43uQKQ/HGMxmek3q6zvbiMIdj759BMSqTR/ypfZv3OXdCZNtVJmNpsynk0IR0NsZeLMJzNu377N4wd3+Yf/+i+MxiKqFmKpwmwJ3VoZVdUYD/qE4kneHR7hsDv513/+V2x2AU8wRCQeYy4vyBXLdAZ9pFIVs1Vgc1Um5Pcxms3p9kdYhRl2b4BcPo9Rt+ThZ1+Qz57y5vs+zmAIv99PMhHFZNbRqtdwuT1MRJHD03NGvQ634tt0W2102pJgOEq3O8DhdpO9uOLhJ09IJVPImoHDN284Pr1EsFlol6/w7N9lfXOV4nWWxXTKeNDDbLIgDkYM213MdidWwYJRp5LPljjNVzCabw7jUukVdPMF4qiHxSJgtdm5OPzAfKkwbFdZ6nRI0wn+oBuPN4A46rN39xal3DW5q0tQlhj1RvrtHtFUkgf37vLyxTOmM5FhZ0rHbkfT6Tg/OwNVxR0IM54OsducjIY9dEYdvU6TTz//jPdvXjKcLuj3+vjcbuw2E+hUev0BylLDoNMxnUtIS5nxcEg0IpDc2MZqNqMtF5j1MB+LpDIZotEEaGbEXgeMRgbAqNtlY3sDjEYUnQGbw0GtUuT3f/qOxVREbzDg8Ydw+QLoVQXBaiUSi5G/zmNzOjCYzYiD/k/Kg5898MTxiMTKKjqDicvTc/yhIG6XlZMfP+IOJpnoNeRpH7vTx1KBr3//e776d/+RfKFENXvG7q1b6PR6jHoFRTPQ7s0wmQU0DbJHr0hvbLOYTajXq+zeuc3J6SFWwUU0kUZaTPFFo5hNZuZzhUGzRCAS5sObNww6NVLr22RW1/nw4R23H3xCOXuBIxDmwdYnSHMFlhIHd+9Tbzfxh3y0qm36rSb7BwcUiiU8HjvF3BUWi4Veq4U0HnLv3ueAht3lotNssrqxicFgwOVxsZCXdJoNGsVrlosFsjShW68QTSQIBsIUSk3evPuANBGJhHzUa1UePX3C9s42H8+umE6nTEZdpkM3Oh0Men3279zl/fu3mLxBRGmJNxQhZbGQz5V49fwZK7t7BAM+itc6BEHg+z9+Ta/dYbazgyLPmI8HWI0Z3n/8iM5gxhPwsZjPeXOk4/nrD6jzOV/99m948eMLEukkHo+ThWrAG00yrOXRmYxUS0VWtnZwezwUL4/xBd34Aj4OX70kmlrHH4ogSRKCzXrjlGvUuPvoKeJYwu8LILiDpLd2ePfj9wSDPsajIZeXV+zfvoM0leh1Gjx4+Cm1Zoe5ZqRRucJk3mBje4Nms43Xc2Ncr5by3LlzgChOmUzGKEsJg84LeiP+cIJOr0cmGcMq2Pj49g1HHz4w/vIr8pdnjGdLhsMhmrpgbW0NcTLn6rpAPpen26yiN1s4u84z7Is32qnxmMMf/sLtJ5/RaHSQpBkufwib3YlqsGK22rBYTFj1S65Oj4mFAowGAzrNKo1GDcHu5PyqSGpzB6NJ4PjDaxrdHoqiRxwO8aYzZNa36DRbdDsnGNUlme07AMRSaZqNFrKqYrYYGfQH5E9yTMQxZpMNl8tBvtxkOp3eXHjKc5ayCujx+4JoyyW3DvaxWsz037XZSCfQpiNsDhsjWaGYyxOOrqA3mDAazGTW40RiUfKFPOF4ktZgyKjbZTYdk9nZw2J3EPC60WMiFE9Rz19jk1XU+Rh5PmfQG7G7dweL2Yxmc2DS63A4HBSucnz65ZcMR2NG4gSdFUAjnNlgOJpjd2o47GbCqTXmswmP72wj//VvESw2vvz8EReXGTr9Mb5AiHwuB3o9ZqsRUEgk4qgalLMXfHx7yNr6Cp1Wg069hd5s4t7Dh1htbs6Pj3AJJvx+D07BwELRWN/aRhz06LSqmEwGNEUhGk9Qr1SQxBFmwYLD4yQaizEQx6iaiYP7t1BkhVKpeFOLZrNTPD9Eh0Y8GqRQqBBJrWCy2xBcbnweJ2sra3z77Bl7t+/y8e1H3r47BlWjcH7Kxv5dvD4f5x/fYzKZMRgFjBhw+wJ0O208/gCrq6u0m03MmoxgNjHo91GWC8aDPjNphtFkol1v06w22Nx2ktpaZzAcoqISjsao5LPUinm84Shel5O1TIbL6yzzyYjsyXssDjtWq/CT8uBnD7zFUsdsvqTTrDARhwQjcQoXWT776q8JhmNcX1/x1Rf/PcPJgrfvj0itrKHIEy6OjwlHwnz1qy948foNvvAe0nxBuVpnfXONbqfHZ7/8FaCyXCyx29eJJxKcH56iw0okbOX66A1Gm4NwYoXi6SHhRAaHw0UklcQf8jOZalQaDTSMZK9y1It53KE4pWKFdq3Of/rf/UfyxRyXp8dYHQHEfpc7dw/IhN3UigXKpSFWu4PlXMLldNEq59GrMk6nF3E8we/zEo3E6HX7hOMZVMCo1xNOrhCKp1EUBU/Ax8H+FucXWWRZwe3143E6mYlDsufn3Hv4iF5f5OOzr1m5/RC7J4CKnnq9gc3vo9YZYdAb2N/doVhtYdQbGU+m+EIhpOWMWCLO9VUefyjEp4/vcHp2xfXFBWuZGPO5Qrtawmw1YzYb0el1TIY90pu3iceilPJXLKQp2XKFUv6K/9P/+X9Puzvk8PU/440kuXX/Iaqm4vb5iEY8CIKdza09Yqk47U4Hs9GI2+/BqFeYjXoEg1vkLs9Bp7DUKcymU85OjhHsDvR6E75InG6rTCi1AsslbocTVI35SKTXbTMVR5iVJdFIiHDYT6veYT6f0R0OWSoa/miKZquNy+tjMuoSCPrQG600GjW6rRaTYQuPy06t3UczCQRjGQb9MZ1mC6vdxWomxdXlGflcDkUBaTbBHQwz6LawOVw4HQJeIcT11TVGg4nV3Qf4fSEMxhnF7BmBQIReq8d4NCMcj+EKhqg3OxzcfYjD4WShqKwfpCheuVhfW+Py6oqr8xOcngCTQYd208NsPMYq2DCbTQwGIt3OEJcvgtfjxGY1YbMHmM2mpNIJTs/PqFYqjHpDbC4fBsFDKV9Ch8QSjVa9TCyZZiZNGXYbTKJBgv4g+qZKpVTCardj0Sukk2HG4wmddotOpYpOpzGTRNqNOovZmPD2Nk6Xg/xCRZTmDDsdbHYLY1Gh36hj0BSGwyGFUpGxOCGc3mQ+nTMatMlVKngCQQbtJt1ujcVSxWCysJpZJRx0s7O1yrMf3uDxegnFopQKJbq9Dmgy0rXIoNfG6ggwmE44y5botIZs7UXIlduUinWGE5FOp8e410IcRxHsDu7du4PVJlCuNnF6giQSEfb2tig6rdzZ2aBWrfH23QemswXyfEp7OGI19BCxUiYaiSLPFaKxBNFYjKOjM1qNLuOJiLxU8AcC6NBAb2AyFXEIZvTqnEohj93pQRJHhGIpxuL4pmos6GPv4ACj1cba+jqFcp033z+jcJlFU2WMBh23t9boVssoSwVfOIXTX0XTVBKpVfRGA4FgELPZyvX1FSown8/4y+//GYvgwmyxUmv2MQpVlvIUp92O2WLG4sjQ77aoVqoE/T6e/+VPxFbWGPVuCsItW3uYzGYEe4xINMZMmmCwWrl37zbDQY+RKOJyeQilYrz94//3J+PBzx54s7nMq++/Ixjwg06lVsox7rdJrq5zfn7GeDpioZmZLSRqpRr79+7g8fh5+PQLXC4zRpORmSgyW+gYDtqgGGgbdFit5puzfosVUezzf/yf/kc+frhgIo5Jr6+yupLk7J0Bj9OG1QDLqcjm4/tcn5+zup5B00I8/+E1RiHO9v5dZGVJKOjG7TBTKDeZTkZ8+/1rOu0SE3HCaCARjkQIhYL0xBGj8ZTr81MiyQyYZ4jjCds7W6yvZqiUGrgcdob9LvlCnsO3b0mvbSHOJlRy1+zff4zeoPHx1TM+/eWvuLrK0m41CCeSVMtF/OEo1XIVu9uLPxxmPJmQWN/CabPhCsRp1WtMhn3Wd3cZtprIiyXFSo1er4/d5UKnLFlbWcEumFAXS5q1Ksl0motskevrLA5flKPTHO1ahXgyyUKakFhbJ5POcHl2jqbTMNutuN1ujDoNi9mKyx/m7LJKKOhnfXsHj8+HYDVxeXnNdDJDmms0qlds7G1jNlqolo/47Ne/Yb5YMBbH2JxewuEQzXqVbqeOy+NjMpKIJWKMR0O6zRpep5VE4iG9Xg+THmqNFnqdyie//JL1TJrZXKVaLdNqNrm6uMTl9aPp4OjdWwRXGJ0JjBYb4ZCfTizO3u4uo8kYs9XCfCYzHfa4vrpkLCk0yzmi8STJVILRoENqdR3QYzAa8YdCqKpGt63g9TsYh2MYFJlGpYjdbOFXX/2aF8+fMxpLVAWBbrvF3p17ZNJJrrIFxNGEfruPUVXR6Q0MekPGkkqzViJ3do7HZSeTWWUuazz49EuS8SjieMBYnJDNV2k2GixVlcl0gMGgQ6dqFM7PWV3fYa7IWATrjbFbUdEwMB50MJhusnXqfIjD50WcznB6vcRTacTJHKPZhtFkRlrIKJpMIpVA1gyUSkX+6Xd/xuMPUizmiCZXKF1dYBNsRKJRxoMeojTHZzDgdvvQlirReITLo0O8wSjpVIqJJCGORoQiQQwGE/VKkVQqiTio0u/20DQDqt5MKBZiqUhUckUCwSBTecHv//QN07lGNZelUm2gLGcEIgkioSCoCrKssL23y9vXL/hweMSk2+Xu/TvUmy3Oz8/Y3dnm9sE+X//5+5sGGEXjT396hjcUoFbI4/MF8ARDvH79nlL+AkGTcfgjuIIhPt/dJFtp8vKbP+O0WYkk11CVBfu3NqmVKxwfHjGdzem1G6RWNxmOxihYmI6HuBwmUGWsdi/uQIh6qUA8GeX0VZGFJKEuF5j0KmKny8fTK3Knh9idLowmE9OxSDwWwRtMUS3mOHx/yP7te7x+9Y7paIDdakJeSMznYwadJp6Al+m4h1Uw4/L6cHi9zBZzrFYrBpNAr15kMh4TCoe5OHqP0+1lfcdLsdshvb6DwaDHYnfjD4XZ2tnn4viIaMDPWiZFpVFFp1PIn58RCEaxWi2Igw6RaIROs4469/2kPPjZA8/jCzBQZeKpFBgtjEYjMk8eUxvM6ItjDAYDLz+cMJ+MmE2HvHz+PW67ha2Du7Q6U9687vL44QOe//Aaq9lOKXeNzeFiqCzotFps3bqNKxDmL3/5gWouz+r2FqPBkD9//SccHheffvkFjUaHB59+jtFiwig4sNp8FAt5DEaNZjGHUa9Hmk1IxGNMJnPk6YjtvS0MJieaIYbZ3GFj+xb5y2te/PiCJ588xqjX0Kky3VIWt8+LcWnF4Ury7PkrTo7f4/JHicXDKEYTmb1bhP1++kcnGFFwuARm4ynBWJqw38dcWjCfz5hPb67y+t0mletzjGY7tWqbXO6SX/zmt6BofP/tM5KZFdrlK0JeD/mzU1RN5fDVj4TjcTSnDb2mEosGScYj/Pnrb5iIQ7r9AYvlkkAoRr3RJGAIEAwFKGaz2N1eVCBfriLNFyiDIdenZ4z7bWKpDO9fvkCnLSmUKlxnr3G53MxkPXT7GDQFRZ4zGoxR1SXZ7BV6VY/D5UFaqDRLZVrNBgtFpVH3EY1GMNnt9DpDStlrZmIXr9OB2K2zsr1DKh4nry5ZiEO2VhP8t//8vzLf3GQkzsldnJBeWcUbiDCVNTY3Nijlcrz+9g/c+uQLnG4XJ0eHlIt5OvUSZpMBRW9kMZ9y7/59rIJAs90iFAuh1xSU2QS/10G/XWcuL7FYrYxHQzZu3aVWqaJpYFB1qPM58bVVhrM5bpedtZUk7f4uP3z3HYJJwyaYef7tn9F9+Wv06KhXs+jQuLw8ZyyKuJ0edAYTNqcXqxEwWzjLF5guZjeHW6KEx20jHAhSKjXRoTKbjEHTSEZDbO/vUywEaNTq2OxOep0uzUYdn9vJb377Fd+xxGyzsZqK0m8maFSL6PRGFtIcv9tFu36JNB1g93iQlzLRVIZKtY4/FMXpdmN3ulFVBcHmIB728dnj/5EPp9fYBQ9TcUQ5e43OoENvVEmlEkymMxxOF6mVFZrNFjNpirZcoC6CDHsdBKsZt9eLomq0KwVMJjPzyZDS5SlWmxWvx0O33WIyk/D5Aiy6XdZ3b+Hx+bg4P0adD+k0VdrtDqlU8qYg2+7EajJiMhhRl0vSyQTlaoPrfIlgPEM8c6NvUhYS9eJNr6nOZMRkBj0KLtfNGuTZj2+wWi2MhyPMFhtTaUo0HGZ3Y5U/f/sDGC0YzTbmsorF7sRktdCaDTGZNKRxn3ZTj6LM6bfHRBU9bp+PpbzE6fEhL8Dp8XPv/n08Pj/lUoG7t9bBJCD22pwdH7J3cEA0FkYcj3n66SckYgGGkkqh0sLp9eDxOjAY1zEbIBwOYNZv0e4O2L93wI/fvaA6qbCymsGMhqbIeKNJJv0OBp2OYDR5E1lQ5rQ7Q+yeAIVcFpvdgzSbUik30BSYiFM8ThdWh0DrbQ2rw4fOZKWcv+JXv/iEujZHVjR6/R6nHz/8pDz42QfP49Ew61vbrKysEXI7MBkMLLSbp0CrXSCzunojzTToufXoCTqdgc+++JJbO5t0qhXqhSvcHh8en4/ZTGLnYI9gNIXV7WH/4UPWNjfR6UxUK1XSKxkSiQSyPEdwCDRrTd68+UC720MDXnz3jMFQpFisYXV42Dq4x87+Hol4BJfDTioZpdusoi7nSAuFy7P3RLwCqbCPW9spSpeHmExmOsMJ7d6Qr/7237P/4AGC08Pe3TssVDg7PCKeTGIVbAxHIoevX9Jpt+gPe0izCWs7t0DVkb04J72apjuZcX2dI7aygc1mx+PwsL2W5vbdx7hdbsSRSLdW582rQ77/y3co0og7+5ts7t+jUqki2J0EEylMViforJgMJsqlIheX51isBuLJMIFgCLfXy+XREd1On/Gwg83hYHV9C3E0QrBa2Nq+hcFoxGLUYzdopGJRfMEoNpuA4HDx6OknfPn5Y7qNKtPphNL1MacfP7BUNFbWVnHaLcQTSQ72b+Hx+BDMJuyCFW8siaxqWEwWPE4XzVoNlnOGjTrLxZxYLEIwFGChQrvT5/mPr3H7AqA3gt5AKBKmXioR9AVYzCXq1SrZy0sKZ0fU6w2ajRp3nnzK5vo6o24bq9WK3mjG7vLRbrUY9YdMp3MuL885/fgadSnTbrXotpoEYzHa3Q52r59IIsSvfvEUs95As1rAIdjwum8Kx0eDHnNJIhkN8/b1G7754Q0nRyfoDUbimQwWwYZgNSMIN2fjdpsTvd4Eqg55MUccD7FZDdy5tc1oNEQcjhn2R4x6fRRVR6Pd5fDojLfvD5FmQ1QUxuIASVwQSSQZDYfMxiIun59YapX0aoZb+wf4vQHcThdOj494IoXVpGM8nbK6cwuPw43T7aXVE9HrdRiMRtKJKPJ0Qv46RyQSBVQMOo3lQmI8ErFYzGjoqNdrpOIBbu9uEI0nWd/a5P7eFoLVymjQw2GzII5GZE+OCMciCA47KjDoD4knV5mIInq9iWAsw8r6FisrK0hjEb0B/MEofr+fQbfJeNChUawQjcZB0+g1G9isNp48fMyDu3tEk3F63S75y3P2b+0zGY9xe7wcfnzP69cfaNXqSNKUSnuA3mBFU2Umgx6xRJLFTMJqczMajlBUPfJSRySxyp1HTzHZfdz75FeYrXZW0iliqTT+gJdbt3cZdRtMxQGjfhe/18ne/jaJlXU2Ntd58vmnhKM+vG4H0+mUSrnMu9fvqRVz6JQ57VYDcdChmM+iaArNdpsPZ1kcDheZ1S3mc4hGInz61V/z5PNfEo4G2dvZIX9xxlKWEQc9KsUKzVqVwXDE5UWWi/NLLBY9q+kk8WSKQbuGYLfw69/+FrHTROzUCQR8yNMRBmSsBpUnTx8QiwYY9QZYBDvBcJStOw8JeF34XBY8QT9/+P3vef36iGGvT7teYyqOUZYqS1nB5XbQ63aQZgsEt/8n5cHP/g1vuZjhFMy0ugNCXjuavKBUKtEq5ojG46hzP2KnRfBgH4PRxHImMpktefb8HcPRlL3Hv+A0X2ap6VFRkVUYDLo4nS729m7x8cNHhv0uD58+olqqUMhnmYynpFIrZNZ3kWYyGgtsVhfR1Ba1SpFer4VX8yLLMh63m3w+i9ftZzhd4ArFUTpNRr0RiViE3/zqS/rDCZqqkV7dxGF3UCqVqZ5/wGbWo6gwHktMFzLZixPSaytsbGyQLZTY29/l9502036PkjRHVpaomkYuf8V8OsDnMJFMxvnw8uX/j73/iJVlPdMz0ScyMjMivfdmrZXLu+3d8YfkIQ9ZZBWrpJJauFLfhgYNDRqCBGgoDQRBE2kgaChcQGjVLaFkq1uqUpEsHu/32XuvbZa36b33EWnjDhbRQM9auGdE6B8nEj8CmfH83/e/3/tis5goplPIJju94Zyr8zNcgSiCwcjKzm3WVpZ48eIFscU4OsDjdTJSusQXIkgWK+XUGTphQi6dwWAw0eqoPHn2ilw6w8b2Lsp4gibomUyHWCwSc1HH6fkVPr+X3Zs75LIlOpUqkn5KOBQmfXnGwsoqRrPMfDqk3GjRbLaw2u0EozFGE5VBs05oaYFms02pWGF5dZmnT19Sr9SQrDZS2RyzyZCVrS2atSbnqRwzro2m1xKLfPsNWGwuPvzFfyOyvE726ozEyhoGo4HJdMoXn37K8toquw4r3V4LbziGqM3w+ENoCNjt18nRo8mYRq2KbDCy9egGmjbnq48/w+P1U63X8fsD7GwkGI3G6PQSk7mGThAoF0s0GnWqpRImk5nPvvoauy/Eytom3372CQ6nF5PTTXxjl6lmZD6XsNjdaLMp4ViM7OdJ9vb26VRK7N65Sz6TZTJVee8Hb3N2kWT/xXOMksT27hZms5Wd9SWS54eM5wYSMR/DrpGj00tUZYgjECO8kGA56uH0LMlwNOIwl+Hp0ydYrFaalQYOjwe7w8PxqxdYHC7EuUCmUGMw6FN4kafTHzBW+lQrVYx6I+PRiEG3yc7tXXL5yrVSc6hgMslIZpnsxTlXJwcE4+v0ez1Mkh6DUcbqdNIf9LhIZaiUrxNKms0W9XKRxbVNXD4v0YUw+askJtmIHh29dotYYpl86gKDyQQI2K02luIBguEQlXyM7e1NEESODk8w25xogyEGo8hg0KPdalBOnRBb3+LJ833sTi/j6YzxWMVi9SPqQDI7EY0y/ZnAqN3izr27PPvmC/affo3TYafdKOAJhHnw6A5npxeY/SGMxgVki8T+/ium4xEupw1tPqbTbSPoBCZjMzs7u+wfXXF+fkE4tojD4cDlDXB6ekYqnaFeygMzJMnCSFXZ3rmB2enj4vQEs8OFqBfRpiMWFhcxW+04LTLKoI/e7KBYqvLB598wVkeIujmffvolpWyKaCyO0fSAdLqAxWYnFvai9lrUKzVazTpDl5tGtYKmadi9Xr55+pxOq47dZqfb7XE+UNB0BpYTMaKROKdnHmTZiD8e5yJZIhwMYTKKdJpV5pMJDrcLdTjEKEURtBkmWSDgd+FwP6RUSuH3e/EHI3z88ReYzCKvPXyNJ9/ucXb44jvlwW99hXd2fkWz2aFSzvL5Jx+wtbFMtZDHYHVw++49YiEf0cUlvB4nS3E/Drudi/Nzuq0GuatzCpkiZ/svyKYvEZkQCAQIx2PYHTbcDgvTsUo04GExHMQkS5wcvqJVryLoDbh9PmYzBZfHSblcYD6bEwjHiEQiGEQoJM+ZjhT0aFRrZV49eYLP6ye6sMj2zjpGSeaP//g/MRpP+A//4T+wvLnG0vom/XabWw9f4603X0ObjNDUJisxPxaTCYvNRbFQ4NsPf8mTx88xmu3cuHcPu8OF3+fHarOhF0Tuvf4W4ViCy2yFtd1brCQWcLpdiEYDJtnIoN/EoNexmohjs1tJp1P0GlUEvcTXT1/SqNe5e/8+VqcLt9uBJBmJhvwkFiIYJT2iQeLy/BKrzUE6lWKkjjGZZDZv3sBqd8JkRPbiCI8/RipfpNFqkVjZwO2JcJUpkslkkSQ9DrsNk8nMfDblxd4ekiShFwUKl+dM51CtNsheXeCPRpHMVtweP3aPC6tZxCTO0c3GPLq1Q9jrZNxr0GtUmCPy9NtvcdpNBD1uvMEINocbXySOZDbR7g/InB9Tr1fIZZIsLy2QvLykUixitjp4/NknNCoFlOEApde9bsu5nEzVKWNlRNjnxeNyoDfK9Hpd8rkM6nhEp91DNMoYRInxdI43GCQWX2RlZY2dnS1WV9ao5HM0qlUi4SDNeplKqcp0NGI8mZBJX4Eo4vP76PW7GHRw5+YN7jx4yGQyYWFpAavZxnAwJBryoxMgvrDE2ckZMwSS2RJWX5C3f/A2d+/fY2ljk0dvvM79N99Cx5xXz1/wF7/4ENlgxGS2M5lrmOweNL0VvUFHIBTCH/DiDfgZDXo0u03azSbdRo1qIcPl5TmKOsHrdhJZiiAIGvPxgE67Qz6TopK5AmHOsNtiogzpNVu4/EGmah+LbGDU79JsK7x4fkit1mI615jNxjCbYpRkPH4/qaszXuy9wmK2EYgvkEznmc3h7qM36Ha6RKJRJuqAfq9Ft1Wj1mpRazSYzuZYrQ5cLjutVgWdQcd8ptFr91HGMybaHE84zsraBoFojFarjmQQKaYvSV1ckckXaTdrWE1G3C4bVpsNQRCw2B08fO0ea1vb3L77gNWVNaq1FuFImEw2Q6NZZzIa4Q0GgBmLiwvcv3+bzNUFjXqNarHIixcvaLV6qKp6nXRRqtFsNBFFEzpBxuGLU8wWKGQyDIcjzk5PaVWKdCtpOq0mkUicxZU1TLLM7voyk9kcl8eLxWpjqmnIkgG9qMPt8xGKRgjGEog6kY2lBfTajELqEmXQZXNzHQxGApEwiytrRJZXMbucrK9vMBnNaHc66EQdfrebfqdFaHGBg/0jPvnkE4aKgk6np1aqcXl+Sq5YIxBdZHP3FpJsxOWw4XDYabXaBH8TgjyZDKlUi3TrNbxOE2GfmXjYQ7VYoVSqYDCbCSz8jzm8/65lsTrIFSv0uw0m7Tqm93+M0+Vg3uryav8Q3XyKzeOiN1B5+eKI7//4ZzQ7fSrFIitbO7jcdvqtIRhElpfXmU4mpE4OWNnc4etvnuDxOogubfDyNIvR5OSt772HOhpjtslUSzlEbcJCLMjB82+RzXa2b94km0xjNAh87yfvk0nnkWQLbr/lOvrn4BCP34M14CIci1ErlDEaJOxOPwbJzNNvn1C8PGZx+ff47NPPEXQa3//J7/LV10/odBRGlDEYROx2F/16Gf/iKqmrJP12i5X1LQKhEI1qA4NB4qMPP6OnjAlFwjx7+gJVHbB76w79bgen83pgXFFVvD4PgubGYpGQ9JAtF2k16pTLNZRBD6fPT2LrBg6/n9Pjc9z+EMFgiGG3TTgS4uLslFqtgkk20ql3KaaLiMh4fQEKuSzTmYbJLKMXwGa1MNXcIEo4XB4MRj2r2zcZdDvMpmN2bt/F5nCQS6exO2yonQ6dUp6T2RS90Yw6HMF0wPqtO1gsNuz2LdQJ5Asl1tY2qNcrGNA4fv4Mq81OKV9meX2FgTKiVqkRX1zBajVhc3kJxxcQDAYOjy/RCyLqsIdeNuELhHC7HQRDPtKnOlIXl6SvUqyt7eCwOdh7cYRkdSNLZowGiX67QTrXYDhUOXn5HIPBgGy2MlTGvHr6MV6vi2qzwaDXY3FtBbPZgtLtYXV6QDQwns3xB+wEXR72nj1DttgI+f1043E6nSa5TJrpTKPWqOGwOzlL5oiE/CysbuDz+WA25vzoFV5PgNxVivlU49RgpNXqsLi0RCjgpVyoUCrmMYVCzAUdjUoFEOk268SXVpgrNsySlZcvXtHtdElsbJLNJjHZzdx47XUmX33Ng1u7DNUZ6UwWvcGA0WjE6gtzlStTq5S4ceOn6I06PviLPydfKOP0eMmlzlne2EU26rGbzQiGa1Vr/fwCTzBMu9fBpNeztLZKrVxhaW2Lbr/P8atnCGjMKzX0RplANIjTYUev0+MLhBH0IqIk8vLpM8KJTRBNFIsl1MmQZrWG0eqkU2tg0OuwGKJYE+vUihmYw2QyxmqW+d6bD/C7bXS7fSxWO7HlBKPpjHA0wpcf/JrRUEESDVTLJQbqnEG7xs2795lN51itFjBIuNweZFlmqg6ZzAUazS52uxnZZv+NQ82Eo6NjFpdXcXn9nJ5eYLPKlHNJ7J4AWzs7KKrCwfNX+LxeKvUWOlHgjTcesLAQJV9usBCP0G43yCQv2d69SSwc5PjwGE0Q6VTKSMwJBMMcn1zh9XrZ3t5g7/HXXCTz6IwW9GYXuUqHmMlOOBah1+7SG3bpd7qYTXYk2cRIqTCbzdje3WY+G2M0Ghl0x+j1JlxOP6PxmIvzFJLJzuZOkOTFGYJOxOt14/f7cTldqOMphWKB23fuMdJEzo8Or/0yBQNvvfEao/GUuzdvUK602N97TmR1jVa19J3y4LceeJFoCJfLTSp5STjwDgenWfSyzPaNBeqVEomVHSSrTK/VpFbJEfC9y/On3wI6VtY3yObS3L57h3K1hdvnJ5nJYDTbcPuCZFNXyLKFzOU5VxdJ3IEgar/NZDbHaDBgkUVu33tErVLD4nRhNDnQGURiS4sc7x9jb107CzTrFRzedWTJSDWfxeFyYjLKnJxesHvjNocHZxiNBpYWohTLdabRRfQ6yJyfsnPzJiaTTPLiCl90mUa5iGSVeP/3fg/ZamNv7xXT6YTxZExf6aFvGukpfQJ+JwH3PX71qw/od6r0+z30op5vvvwc2WJl/fYtitki5+cXiHoJpdfi/qMH2O1W2oMh3lAEbTbHEosyn88QDRKZTJ7+UGVxw8/F+SnT6QRBFLFaLajjGZu7u8w0HYvrm+gFHUqjxfLKAscHpwTjQe7eucXByTmZVA6jJPPZZ1+jDns4PH4kyYTTH8Bis2HQG1AGfVbXEni3tsBgRJYlZtMpsWiEXruObLGgqCrdTp+XLw4oZlL0hio3bt3Cbnfg9IdYXFnDHwhgt0gM8zkEpmRyOZrVIqo6xOmP0um2aXW7IGjcvHsfQZtgc7hYXFljPgWHJ0Tc68RuN9NqdDGZjeSzGZqVEmN1k061jDcSpdmoYzfrub37Gpe5HGhzzGYZf3SJt958SK1Rp1Kusr29QdQfoFoosLK8zsnhK3q9DtHFRXSinnAsjkWS6Lb7dBtN4u/F6XU73Lhxk+fPn9Pt9nEHbHz66Rc4XXZMVhvVah2v38PNG1u0mk2Mop52u0/q5Jhhr83a+gaNUh6b3YEsSdS7A2xeH65GjdWlKBsb2ySzDvxuD/V6jWGrgsm4RdDn5eXTPeZAbCGOLxim11PQNNjYWmfY79NttQi4XVz2uhSLRRqNGmaLBaNJpFlrkVheYXl1mS8+/gizWUZvsFErF5EtRqxmiUh0gdzVGZdnh3RbPUSjGb3eyKivsHH7FtoccqkrMlcpVpdWaHY7LK6sUW80GfRUnE4/Lpeb/SePmY2GxJYWMdvdeFxuBE2gXszR6fWRzRqjyYxOq4PJZKFQv+QymaTeHlC8Omd500SjUsEXClMqVVDVEdPJhN2bN3j2bA/JbGM21zg5PMDucFMuFRh22tTrFnSSmelkitJp8tlHv8bj89GulenpZWYThfDSKp1un/lUZawMCa/fw+dxMZvrUCdTjHoDC7EwhVIOs91BqZDH53WjkyyM1CIvnr9gps2xmk1UKyUGyhBtNmB39xaNWoVuX+FuLIrf4ySdybO9uUzQ+yN++YsPsDp9yHodZy+eMRlPUNUezVoNg0Hk9bfeJV+oUC6VubmzQaNappxN8d4Pf0CtWiV1foQsWwjHFjCazBTzKXwh3/Vzd3nRBAG328Nw0OGTX/03QtE4dquJvWdP0eZzFlfWiS9EyKezHF+kSV9e8dqbb6A3aATDfhZjMfKZzHfKg9964CnKGEUpgiZwenyMxWwivLhAtVzBZLMjmSXU/hCrZGTn7n1KtTZ6k4lCJg0GA5VigQu7i163hYZG6jJFYm2Nfq9DrVJhY32JtTUnnUYVAxNmBgMGg0CtmIdggOevTmiWM0QSa4zGE5InJ3jdbtZXl6i32jRrFXyBEKsrK5SKZSbTGSaLnUqzT6GQw2SxkTx6we6Dh+TyOTRtzuadh1RKBV576y1++sN3KFQbeLw+xqMJot7MUiJBZHGRw4MjlOGQQDDCeNhHEHWc7D+j02hxdBxiNhlx485N5vMZp+dpvv/e90leXTKajum22hiMRiRJh93hYP/ykK8+/QyLw0WjVuDOw7eo59OoQ65HF/p90ATGao9itki7XsfmtJHL59FPZ6DpaPUURsMB9WoF2WKjUS1w4/YOGxvLoNNzfpkhd3XO+s4Og8GI+Wx6DZ9+F4c/jMFiJZ3JIhtlup02ycsMhwcnzOdTIrEFVGWE1eXC4rAyUqe0O212NjdRhn0yKS/DToNiOkNeFBn2GvR6XWrlAqtrKyQSyzRrLVaXEzypl9BmcwqZNDpxzqA7x2A0YzBZyV9d0W7WCS3EqKWuSCcvkCs27C4XNpebYrWG1WqmX9dYWfCytRHn668es7qyyuVZg8FkQrPZwGq1Ieh11EppXjyXGAwHeFwOnFYHfo+TB/dvsPfqlHajSrtZZ9Bd4/zlMxBA0Cbk0ml2H7xNqz1Ap5eotzqIRjtzpY1B0l//xjMZjGsGhopCpzPgydPnFLMpXn/3h2izMv5olGA8gmSxYLU7MDsdJFaWODm+HrnQoyFKJi5TaV4+/YZHr7+J3iBgdrqJR0L0nWaS52lsThfdvsK3Xz3GYrdjd7s5v0oyGk3Z3t7E+JuYIBGVUDTMdOjCYTJTHxVQ+1At5GlXy/h3bmL3eFhcjFAs5ohEopRKFVbWt9je3kAHPHnyAr0IOzdu0Gi08Ab8eF12DCaJRqvFSBnQMRjotdssJJYZjRR8ARcOh4k5cwqlIggaVqeDwWiENxJClCR0oohRmCEIGpJswu70cn6RIhpPUNQbGXRayEYjk/GEkM+NLF8Lopw2M2/e36U+0NhvNzFKJlz+AJ1Gme1bO5TSGST99XypyWzB7vJikC3IpiHheJx4PEa12eLi5Iheu43daSOdSTPstrh7/z5mi8yXn3+F0+VGUcYEozZiwRDVaoWbt2+jDnqcvtzj9fd+Qq5QYf/wnOlEZdAo4rLZeO3BHT788FMeP97DJOuZjlRyxRp6vYjN7uPOndsokzlPvvqCTq2C2+9noK/h9XjQz6fMpkOS50n0Bj2iXkcoHmcw1jBaPezcvIfZIqOOB4TCEfKFCd16kejSMumLfcwOD5IlSrVaIbGxwebODtlUhnZnQCwepdVRODs6R5JF/H4vrVab1FWK93/0Hn/2335NuVRGL3y3PPitB146eUUkFmN9Y52XL/doNDrUmgeMxwrhcJTj1jP0kpXd7Q1ME43nL16hqiM84SjqsI/T5cNstjJXh7QrNfTMGY1HnDz/hrkG6VyZk9NLVja3abf7NFJp3vneWxRzGcaaQK/dxepwcWM9wUI4yL/7P35BPl/E7XZiMVk4K+fpt8qIkoH02THhxXWU0ZDkZY5oJMTiQpRbu6tUKnXmQO7qgm6ny6jfZNgx8sWzQ/L5AonVJU6Ozmi3q3T7IZ482UNTe/z+T95h/yjJ7u4ubo+H0sUFwUgEn9fO1ekpE1VBbxQppC746CMDJsmIXtYT8Hm4Ojtn9e49zi/TrGzewON10+oN8fh8SJIRn9/PZx/8At/iJkq7jcPjI7G6iV6UcVltBAMuqvUqe98c4I8kWPA48S9H+PZxF5vHi0XaIJ3MICDi8fu4SqXIpS658/A1CtUmxWwOt8dPOBKm1W4TjkSwWKx0fvMy29nepNXukS3kMUhmRtMW7WaLTqdLsVJh2CiDoEMyykh6Pe/97CcoM/jm8VMsNhc2hwur1YrRYKRcKBIOhTCZjcwFgTd+/FO63SH9Tpub64tIJgsff/olNqebxMoaDtlMttdmqnSYGo2IaCi9DpftFpVSkeDyJoVKldlswvrmDpogMBqNKOSLqL0BaqeLUa9Dm02oFjI4XE5yyXN6/TbP9yTG4ylml5elrR2alTK7G8s0y3matTLT2Qyz1U4hnaJZtdLv1bGYTRQKaXSSjVqxRKNSRNAZSV2lkaxWwvEF3nh4k19Mhjx+/CX1XBKz1YHJYmHYHaIzGLE73ew9f8Wo1yS+uIhRt0i93kE2yUhmG416i1azgToakisWqJTKiDo9k+mUXqvDm2/cZ4bAq709AtEorWqWw/mIwaDPwvomkcVFLpMpJIMRt8+PX5lQb/dx+HxEl5YYNBu8fv8uL47OkGQLn3/yKXqDjEEHylDFancy1+YsrKxQLFZwuDzMRJkHr71OqzfEJFtQu20u0xlGoxEHz57g9nvR6Q2EYktUK1UkiwyCARGQBajU6jjsHoa9AU5/mF6/i9XhQC8K6PQmypUSiBJzQc/6zi0kScTptJKJxHCYZdx+P3qPlcFZCkmS6HS7zHI5DHoBdTDEYLzOnnT5wyw7bGxtbDCZTfiz//PPGU1nKMqYfqOOPxBFtruRjAYCoRDzQBCLZCYS9OF226mU89jcfmST/VokVamQujxnNjfgcLmQ9Rr9VgOv18fi8hLtRp1Gq4EraMAbDjObTPD5g0xGIzTRAEaR8aRHuZxnfW0dgwhbO7foKANEcYHVtVUqlRZbm9t8Xq2SyxVY2dihkMvQ6R7QbXdQ1TE6vY9auUi72abb7LAQjuL3eAlGozTaPRqdLgurCeqVBseH58gWEzb7te1hKL5Es9ik255yKicJen0MlBFDFSSjGY/DSuLdt/j6z//Nd8aD33rgVVLHhENekldXKIMRCxvrDId9KulLJD2MZgLMxnz66efUqhWcviCT6Qw6cww6EacvyHw6R9DpMOoNPHzzLUajEVmDHn8gTDQS4fDVcxrNDvVKmcLVCV8ZjXg8TmSTmdzFCUvbd7lM5ynVulhdXqZTldXNTdDmGI0GLLKekSaSms94/cEtPvrwY9RBC9vaEvuHB2xtrDIR9BQrdRweHzq9SGghwVAd8+zgiO2NNWKxBV6+PMTp9pK8uqB4us9b3/seU03g+dPHJLZvUm+2cQXD3Lixi6BphKOLBMMBBpMJx8fHzNEQRIHtrQ2urpIUk6e4PG7q5QITi5lgNEjl5BB3KEG3N6SSKxGILWB3u3A47cymMwDOjl5x8+Y2zV6Pi+NTdu8+QJAtJC/PqZklHj66x9Pn+4hGPYuJVU5eHaFXFCrlAvfe+j6CTo/X7aBbLyJZArS7PXrdNjb7Jo16k6kyZNDtkUxmGA56yGY7qjoAZhTy+d/kaBlQFRWrzUoulcPlj5Artyjl0zCf8db3f4Ao6jg5PiUc3ODyKs2XH/yK4OIStcwV+4MustnCYDjkUj9ja3ODTiWPyW6mN4Tj0wuGwwlvvvcTXH4PesFAuVTGbrFQL5WZjhSaY5FWKYntlofiVQGL1YnZamLksqEoYzbW1vG4XZitdhxOFy+fPWE0nqGMVHrNBu/s3KCUT2GQZTLZHDq9HpvLi8PhQkPEZrMxnUCn06FQrDEdjxh3exi8XpROjUhiC0k2kT07xm53c3KZZTTTcHq92BxOeu0WwXAIowDNpg6bLKKbjZBtTo5fvUTp91jdvY06UvH6gywur4HBSPrzc17sHyPpdHTbVTxGPwajjrN0DqMAoVCAoN9Dv69y/94NTo5OEAQ9Z6dnjMczGsMqU0EkebTP7bv3EGYzZhhxej2cnGeoliqYzEYWEsuYbC46jSrTYY/ZXKDVauOyWhjaZMw2O6VSnU8++pide4+4uErSrdcxmEy4XR4sBgGny0mz0cJstRFNLDEbz1CcLibTGRaHC5NsxefxMFRUnj99yr3X3sAoGxkO+8gWK0aTCdlkQjLLVCsVYtEI6miMqg45Pzml32uxurxItljFEwxRyhfxuF20mi3mc4Fmo042m8XjctJqtijW2rSadXz+IP12m9wcGoUsI1XF5AjSU+usrm8y6HaotTq0BirjqcDtO69htpi5TKfRG4zYvSEMkkwwEKHf63C0f0AoGKRcqVIpXxtiGExW0uksSrfH7p0bTKYa6miExWrCoNOxdeMGtUqZZq/Pzbt3ef5sD4PJzHDQYjyZIVts1FsNNJ0EOh06Uc9gOMZsknn/vTf57PNvKKfO8QbDFPI5JIPExekJ9e6QYX+MQQdjdUQmncFrt9JXVUKRMOPRBLU/ZHtzlfFyglwmT7XWIBiIkC0kOb+8RNLpSF2csLSx8Z3y4LceeKvr23i8YZ59/TmCTsc8FiV7fsT3v/99BK7/pBanB8HkQGd2YDLqUZQ+i4lV+s0G7f6AWrWPrId8MY0rEORkf5+Nm/cJ+v0MFYWFhSV2Nlf45rGKx+PFJpuwWqzs3FinWsxTyF6f/gSdjkGrwerqMs/3XlDLXvLwnfeQnU7Onj3n1oPX6AwUdm7cZjoesn9yQbdexRcMMxuNMWsj2tMJzUYFk5zAKMl0k02KzgqyyYZsdbO5vsJVOoemqJTqbU6SWUx2F7FogEImz3gy4+wyQymTJLywhEWZk8+kuH3vPn1lwnw6pdNu4w/48YRi1MoVHty/w+cf/hpBb6ZVa6CXrGgjM6nzUx69+31q9QqhUBibxcrJ8RF2j5urVAqrw0m/36fbabPo83K6V8C6uobOqKeST2J2+DhWz8henhPS1ujVKwjaLs/3nlEp5tm+fR9N1NPI5LFaJFwOG9lUGofLjdGmMJpNMFsk/JEg2WwOgygSi8f55tOPSWzfgOkC6csLAtEF0DTOzs/Q60XWtrax2eykMxmuTk4ZDkb0uh0evPU277z7Nk+fvyB5csiPfud3efHiJfv7RzQ6Q7Zu3UWdjslnU2zevE0o4OLs+BDORBqlEonNXdSxiisQJBJfoN/rMVM6+MN+okuL5LMlLBYby4k4BwfnDJUJ89mc5USEk7MryrkkwcQmSqfzfx0egqEQ47GG1enCM1a5PDwkXygw6nUIBe5QKlfRG/S4PV7m8zkut4vRWMGoW+Hug5sMBxqT4YhOt0+13vuNKbCe4bCH3eXDIFnIZdNsb62ythgjly9cKzPnGvn0FZVcCoPZQrfdZml5BVmYwmyCziBftw3Xtrl/e5t2p8nLl0f0O10kk5l2b0itVuezT/s4PT661QrxxBLNeg1hauTG5iq9Zp2Ax0U0HODzX3+Ax7mBzWHD63PT73WxOWz0ej1SJwds3Nyh262h08u0BmOGozmtdoFoNEalkCd5doIvGKQ+HzFVdGjzKX6XncTKEtWnL3E6zQh6I9VOmUGvzcVRi93b97h17y69TptWs4UsGXDYbbRabaqVItORis0XZjwcI8zGtDoDSqUib75+mwf37vDxBx+z980Vs2EXqyyTrZboNspMfE6i0TCVag2zy0+vP2R7a5uX3X2y2Qx2m5XhoIfD6Ue2WeiYLMyY8d73HnF2mWY2UbFZTSTPL9Dp9RQySSbjMaFglOloRCmTRG+Q2FxbwGqV0eYabpvE/Ttb/Nc/L9LvdWi1uxhEHcuJOL1enf29V8wFA8NBh8l4hsMqUa/Xeeet1+koI8q1FnrZjMVmQ6/XUSkUWFrbopTL4naYqZWrpPQGBr0G2bNXCHoDgkFmbWcHs8lGqdLk9oPbdNsN1LmA2WIjebLP2to6N9dusX90ynQ+ppRL0usp6HXwF3/6pwQXlhj2OmiaSLnRoNPqYhCn3H/ne/T7HXTz6XfKg9964D14/Q1Okzn0koTV5WE6HaMMFNrtNplUGr3VS7lQpFUrspBYxiIZqZVyNBpltjZ2ODu/xGQ1oZvPQTQQC3s5O9RQlSFHB/t0Wm22b91m7+UBsmxk89Zdrs6u2NrdJHV2fq3OUnrotBneyAKSXuDuw0e8enVI6fKAWOjam7JSyqEX59TKBSYTAavDSTlzgcPlpVTME49E2byxhb9U5+LiHKvVSqVWod8sYzOucn58wHA4ZKiGyJzss7SyTneo8s0X37K8us5kLtCfTDGbZRxOG/U8NCtllOGI/OURO3duI8xmMJ8yGI4xygLRxDZm2QS669idGzd3ybp9rCxFsdktnL54RvryDG8oTC6TIZ5IoCgDRL2B8bBPtpTH5lvAYrPgsJvZunkPh8OFMoHQ0i46HUwmI/yxKDpthsPjxeJ0s2CzUCtkGXTbpDM5ZtMJ77zzEyJBP0m7g+fffo1vaQ2j2YLf7WJzdQ11MOa48JxKrY5O1FHJpJgLemrlNCa7C6/XT2RxiVoxz2Q8vq5oBbBYbdeG4h4PTreLvb0DLs/Oeef775HJX7cPHR4nVqeHuw/ucXZySrtaZzW2QKFcxmh3YbVbKOcyeP1eHC4XSl/h6vyUQbtBMBpmMFQ5Pb7E6XGRyqQZtOqEYgtcnByhjhQ2t9Zxmk1MlCHifIwkCiDJtLsdirkM/mAYWbKgKipLa2sYLB6kUIRYOMhQGTIY9HC4HGSTF3RaNQyyxKjTAk3k1cET7BYHLpuXQq6A0+5ma3uNRqPKxfklk/G12//hwTG5XJF8KsnaTQ9mmw2DZMYTjjFV+/TnNWwOE17PFp2Byng6o6H2mUwmnCYz1PJpTJKEPhClWauyGl3CF4xw+GofnVHGKJsI+H3k05d0alWO9g8pZjM4nB7GmhGdwcx0LmB3OLg8PWM0UvB7PZRKxzicDuxWK2DAbtUoFctkMzl8LjNOuxmBGZLJisftJZ9LYzJL+P0+6uUi57/4FeGFRU5ePMPk9uD2eLE7XLQaNaYaZC8vGLRaRBPLFGdzTvafY/P4kCQZh9uNKxBkPJxSzaWRjTJ6gwGrrKdY6yI7XLgDYSaiheWwn2ZXpa3Tc/R8j+WtHZKHr/BG4wjMeLW/T6PRxOl2ohN1SBYzJosBvfG6fT0eTVEmU9weF1arGZvFTLnsQBRFfOE4Op2OaMCN0SiSPNxDJ5l4eXzF0pKK1WHl/OSAyMYWZrNEv1dDE4xkU5c4bTLeQJTMMIPL7cXitJC+PMHjcaOXRL59/pJKqUyr0cDq8tDrD9HmMyxWJ5PJHNnkwKQXmE/mhPw+4pEgn9Uq1MtlgpEo3V6PYqmG3Wbhkw9+TWhxBZfDxng6YTqZMpxo5Cp1RJMNpz/CsN/mre89QCcIHL58gdlsZHklwYd//t/Y2t7CuBwnmb6iWC4yns5wmgzfKQ9+6+fwppMBvWqO2XTKbDJm0Gny9juP8Hoc+EOha4unyZhgeIHl5SX6gzbbO9v0Wh0+/fgjMhen5DIZzo6PcTicnJ5dIRotWB0eXG4PynBIs93j+PAIj8vJfDbHbNJjlo2E3Xb++h/+FK/bwc72BtXMGUq/Qy6TI3N1xb23f4DJJNOulTHrZ8SjERLLa7QbJRxOJw9ee4N3f/Q+48GAwVAhX67z7Mm3ROIxNrY30WZTVnZvYrXbEfUSaqvKsF5jqg45efEYYTrCZjaSSCwwn4652H+F0SCRvTjDH4niDwZRul3sXj9jVcFmdyAIIolYiHqpyKDfoVIrcnF5wevv/AB1NKbZrKKZTLw4OEUyy2g6MAhzRsMexXwOm92J024nHI1itTuw2qzsP93j9OgCnU7H5cUxyeQVjUoBn8+Ly+Xm5p07/PBHbxNNrJDKXrc0br32GqsbqzhcDoLRGBcXaT776msk67Un46TTIXNyyMHeU5LpHNmrU7Z2tuj1etx57S2+//7P2Ny5hdMXpdtu0axWKKZSGAwyms7A5ekJ2YtzNnZvEAq4sTltWKwmCpUapWKecr1NPptnOp9y995DipksBycX9IdTRLOd3kDB4fJiMdvJXaawOJ1YbDYm0yl2mwW3zcJ0NkWYCyTCEbTxhNlsznIiRqfVQrZYSKwsIEpGSo02JruDhfUb3H3wGrJJwmQy/Gaw3cDe199QKOfpdzu89vA2brNENpXjJJkhnUphMBgxSXrsTjfKYIjHF0IQdAzaLe7ubHB58opOb0i30+Bw70tqjTrqaEajWqBWKzFVVfQIxKNxltdvIIkaXreNeDxEyOekVioTTazT6Q/44qvHuIMhfvqT93j46D69Tpt+t8ccHdnLc/SM0aYKklliNFFZ2VhFJ2jMxnM8DhfLa9sE4wn0ujk6IJNMYjAaiITc1Gpl9o+OqVZLrG3fRJ2C3mjg/Z/+hFhkgfTFBf12h1atgM1mpdtu43I4WFhc4vzgJY+/+IJ6schY6dPutOn3uoQXV3nj0UPWt25QSWWxyAYCfjf+cAx1NEFVx6xsbLG0mCAQW6TdauD3+9AJOobdIfVSFZvDicVqQZiPCYaCfPTFU7764isMBiOBaBSzxcIXX32LNxAksb2D3RfEZLGwsHmTxOY2ZpuHyWiMw2GjmEkxn06oFkt4PR6ajQpGowmvf4H+cMJwPObV0z0++/hzzg5eUisXQZtRreQ5vjhD0+tZvfkQXyhGfCVBMBhElEzIDgdz9OzcuYfF4uAH777O0soKykBhPp3RKGbotau4XC4kWeLtt94kFIwz1UQW1zYJLq8jiEZk2UA4FsMXCDBS+nT7fWrNFiO1Tzp5hTKZY3MHiS4usBCP4fX5cTvt/OT977O2skI1fUmn2ULQCbz7/g+pV8p8+tVT9p7tUSsXyZyd8HJvj5f7h3TaLVyeAILOhNMbxmq3sHtjl1h8BT0C/cGYzz5//J3y4Le+wluKhkHTsX90hWCQGA46VCo1stkiG1tbTKclioUaZtmCMlDY3NpEkiTmmkCp1sbo0+N2WZiNxrjdLr79+nMMJgetSolyucTthw+p15t4AyFEg4TDaWUlcR9BFFn5jWtDILpCMLxApdZE7XcoVBu0W3XODxSa1Qq1Sonbb/yI87NTPB4nP/+rf0Cnp7J0Z5t2bwA6Pdp0Rrc7wGqzsrwQ4jJ9xXTY5W/8L/8zn3z8FdGIj5//3g+pVpv0pxpWWWR5ZZ2nz16gl/S0eiOcbgcWm4VMsks4voQgQL/fJLSwgNfv5/LqivDSGupkisiM5fUVUqk05VKVZruNWTaRuTxCY85EHWM0m1lbX0cv6IjEF0EnUK+3mU/HRII+jCYbXp+XdqNEpVaj3VNolctIZiu9doOr0wMGvS7RxDJXZ8d0uz127tzk9PyS/RcvEI1mllcW6bebpA6f8uYPf4wyFTDIEh6fE0nSMEgmjHo9JrOZq/MLZLOT54+/Ibq8Tr2QYzabEYgsshwPkbXbmQkio8mEUDROo1ZiqI6onRTp9vtUXF5ko8RrbzxiaSHCUBnTKBeQJQmTScZolBA1HTO1T3c4oFwpc7n/jPjqNunTA1qNBu16DclowGw2MWhUERYXOb1MMRhNUUrl69gUo56xMmZte4WrVJqvP/0IZlMiiwkQBYbKEH9kiXSuzHQ8I7a8jNVmw6A38uEHnzObTMicHqGXBZReB03TSCeTVEsZbE43I0UF0YDVbsfpsGO3O1F7PZwuN7XUKc1qlWqljjCd4nP56NeaBOMxRrMJ1XIes91FJpVBNOiIx6IsJBYolAsYJSOCJnJycMyw26VcyGKxyfh8PoqpK2KJNX73d37Et09f4LY7MBmNCALoJSPHz17w6vSSwaCF0+Pmzu0b9FUBk2wk4HMwTCwzS2eJL0TIXR7z9JtP8MeWuXj5FI+sx+JygyDQqld578c/4uj4imxFYf/0imary6jfJrC5RadtZGtrF6vNzCtVIXN5RjDgp1opEUksM+iPYD5Dh0ahkEUT5gzVAXuv9kmfHbJ19w7qZMx0JhCKL+ByOihV60gmE48e3MPkcGG1yBhkM+HYAo1ag2jQS8/jplIs0R92sUgi6ytLHJ9ckDw5wqg3wFTP9q3bmG12nC4P3kAYu83Ka4/ucn52SbPeRJIllLGCbHNgtZiJxMLUyiUCwQCz2ZxyMYtkMmHU6ZipY46ev+BML5JYjBMN+Dg/OWIy1tFrtWn1FOwuD7FwFEGyUCgs0mpWsXt9CDodr/b3sVgtdFttZpqBQbfHaNhj9/5D0skLRnqRlbU1mMPZ+SWRpWUq+TyzUZ+11SWyV0k67QH1SgGH00mhUsdoMrG9u0tfmaHXBPweLyeTA2Zjhcl4gtXhwBtdwmAwsLu7zecfFXny1Zf8/K/9de7dv8O33zzDaDQg6jScSwm6zSzNcvY75cFvPfD+z19+jMcfxOX10hkoOP1hdPMxzDr0xnMK+SJTdXjtop7PMVZGuB1mGq02GGTanQ6LCxHmwHA8Rm9xEAyEqJUrOB12dDojbqcLQWfn+f4+Rr3E5Wmf8VzjW4uV1NkJuw/e4OLsnEFvSGxpg0ang93l5r3vvUF/0Mfvsl1XSeqIB/dusn98gTLs0+u0SWeLWGxOBtM5hasL7ty9i9cXYjLT0a7WUdUZ89mc1OUFzb7K+avnLG9t4ApG+fqrb5DsFrK57LXg5u0fUK1WefDWO4RDARRlSLdVZzadYzbZEADDfMzLp0+ZCTrUqYCqKKyvr7K4GL/OFdvYIRANcHR4ilm2Us5mcXv9NJp9SsUMIGC2u9l/8ZJQfIFWu8F4qhJaWCafPMfq8RCJRLi5vYZeb+Dg5QvWVpZRR2M+/ugjjl4dUsqmiS4m6A8ULEYdJreT436XXC5LX5liMJpZTCxyeTrBKJlwe1x4Ykv4FkW06YQpU0x6jU6zxFBRMO5sMxj0SV+ds7x9m0qlhN/tAv21hdji6hrffPiX2BweHHYXI6VFo1bndH8Pf2yBs6srxtMRzXoNRZljNpvZWFuk320DOsajMaJBQicYuP/gAdp8zkyDQi7D1voKgiiw922eSGwRbS4gmezIRiMfffQ5bqcXl9dPIXlFPBpjoKgIOgPdTod6qYDFZiO+uEg5l78On7XbSF5ecO/1N1hYXqXVbONwu1GHCudHRxhNNhKLcSZKj1cHBwiCAXU8wmowMB4pLO/cYnkxxkhVuHv7RyQSi3gcZjLlJn1FodOuozfJhBfjVAp5crkSiAY8vhBGswNaXWrFHCazxEyDYbtJy+pmrmlMELjKllDHGqoyot5oUCkVsTldWK0Wet0mOp2OZqlEyu6k22rQNxj4yw+/pNUoY7fbkSUJd8DPbDRmMRZiPr5BOpMnJJiYTcc4fQEUdc7d+zfotSo8++oLgvEEazfuYJAkBJ3A2fERaxvrWGxOdEIak6Tn3r27/PrDj2lUS2hzePvdd/j4g4/RdDp69WsxmMlqpVIoEgqGCYRCTNQJqqJQy2cQRAPPXh5gcbgpZlKYLGbmkynKYMjh0QkO57VVWTy6SLNWYm0xyGiscnlyzMbNWzRKWTJXFyytrdNq9zCYZNTJBONszmSs4PR4GI6GNFtN+v0uHpeFKXPGkzGSyUwoHOX4VQWjwUCn16DXqSJbLARiyxzvv+T+a48wzQWMspOLwyFffvwZosFIOZ/i7oPXcdnM1AsDmvUGstlMr99he2eTTnfASOmiTSY4XV5G4zGhUIBSsUA2lWQ8mdGslEGYMxgM0NdbbG1vUqq2mWlzlpZXOHz5nKEyQRA0nBYDW9sbfPrhxxiNIj6fm3feuMeL588pNzoYDUayqTKxaJRAOE6zXkNkxt2dNb744Be4vF7e+eGP+OKLL7HabGzcuEs5uf+d8eC3HniNchHJYqWar2D3Buh3moz6XZbW1qiXSxiMBlbW16/vGUwybp+JWjFHrdHE5vDQKuTIewJMZxq9bptAOI7BoMfm8KATBWbzOcpoRLWUxe7z4LQ5UIc2drYSpJNZrvYVRG2KL+AFTcHjd/Hq+ddEYnFqnQHHr454+OAOHWXKvQf3OTvPcX56zvbNTabanMTKMi6nm3K9SbNS5tXLA0ySROrykoXlNbKFMju7G0TCb/HN02N0ggAzmKhjOs0W97a3efb4a2SjmcW1dYbdLibJSFJRyaTOCETCBDxhJpM5vU6HgaKQvDxFb5QxWy3kU2f4QkEuLi45PThgY3sDnz+A21tndW0dSTKgzWfMBWi2qphkA5VCjtlIYTHkJRrx85e/qrEQDVHJphgP+lxdXtH3eykXcoxGKiZblU6nR3xxCYNswWyxEY8GyWdzhMJhrpIZXn/3h9h9AQ6ev6B8eUzWaaFazDOZzYnHoqSP9gmtrHFxdMDC4grhWJzOYIg6HGJ32RGNEibZRPbijNFERTcZ4A3GqJar7D1OMhPAFwpRKRawWqyU6x0a5Tw2pxdfyMdsMiRzcYrZYWc2mXJxdoHdZiW0sIymN3Hr0TuM1CG/+sUveeN779JqdxhrOsYzHepAwekL4/QF6faHKP0Opdwl2kSl1Rmj112fsLOFClTqzNBh+M08l14HXq8HsyzxYm+PeGKJzc0NysUqF6dnqJMJncEQATAaDaxs7zDURGSrA1GYs7q6Rq/XYzbuEQlHqFfr1Otd6rUaSrdFW1HInJ/h8kdQRyOWb9zF4XSiqiq9Thd5QeD2nW1+8Ytfc5JN06pV0Is6vP7rNrjf68bjCzGb63C4rIgGI9PJkCdff3rdTtNgNply684dRJPEyfElgt7EVG9gYWWJQbdLNpfjxs07VMslnj95xnw+x+OPY7M52d1cwyCZOL3MMJuM8Yej9IcqvX6XyPIqVm+YYj6HIOhw+4I8eu0+n334ESdHU/r9Lktrm5idbur1Jom1dXw+L68OThgMhywsRDBaHdy8ucN8POajDz7FEwjTbTWJxiNUSkXMsonv/eA9Hj/eo5DNsrBmZjqdIgoaaq+Fz23n5DTHbDYlGAoTicW4OD3mi8cvabdajEdDpoIemzuM2SKzsZrgiy+/JRjwU6vVmUznlPM57G4vM1FHIZXCYJSpNdpsba0gzjVePPkWn8+PUS8yGk8wOVzMNVjbucFUENBEA5WOgmwQMZumzAWRO48eYbHYSKVTTEYqf/DT73OQiPHy8AqDZEUU5xSLeabjISuJFfoBDy9f7GO1OFhejuFyO7DZ7WQyBdrNNkZRxuA0oNddm3QbxQn1Ug69boE5IharGYPRRKmQIxJX2b6xSzzmRzTIrCXiuDw+fvHrz9na3iKdzvDVpx+xuLZNpzfkP/zJf8QfCmKyO1neusHxZYGhMuXBow0m0xmf/pf//TvjwW898CLxJabqCKXXwe6y4bAYcYaWiS8t8fiLzxEMEr7YAtVSmTl6BorCFB3LmzusLy/x0S/rzLXx9eVyp45rNcFkOmc0mZA/Oef2ozuUywVm4ylmvYH00Us8oRB6o4lqqcj/6//9v9AcTphPpoTjMUSmrK0kUMZzDg9OCAS9fP1kD6Yzbty7RyaToZg+weK0YpYtaFqdYWhMsVglGI6SPDvk44+aNNMXzN74PoI2o9OosnbrPlfHJ7z+2iMWVjfYPzzFEw4zUhTMJhP+UBiH3YTdHKHTG6COxjCbM5/OqdYbZJJJPAEfo/EIf2yNpeUlVpajTNQx47FGrVym02xwdHJKPl9hZ2udbrvO+UUSjz9Es9Gk32mwvL6BJNUJxjdx+4NcJQu4fUEWIj5am5s0ijmWlqN8+pe/xiibECUD5VIBtd/n7e99n2dPvuHRw3vsPd3DIOowS0b2nz7l7utvUy5XqdfKvP2z32dtdRX1k0+YjFS2ExHazRWqjR7T4ZBGOc9oNKJWLBBNLHN5eoqo07O8vslCyMvz4zNCHgdmu41iPo867GOyubDIJhSzmaHSZ24Qsbn9BAI+dAaZcDxBLLrAoN/k/PgEdHrWVpZo98e02m1cNj1v3L/Fv/vTJn1VvZZn5y5pba6z//QpBpMFQdRTLxexORzcffQQxirfPtvjne+9zdPHz9h//hSTxYrX58Nl1nOSKWAwmciXi/TqDSTJgMftxGKWCYV89IZmjp4/ZzjoE0+sXUfFqCrqZECz02d5ZYFMLseg02J1bRW7zYbSVyhVasSWVmmWC0SDUZInJ6wn4lSqDXqDAWgCzXab8WhAfHWJgTolHItj7zRplXPM0TEcDKiVS6xtbWKU9fRaRQTRi6L00LQZW1ubjOfQH4xBm9AfTYg47YiixkwTGPYHtNp9Br0+U6XPHB0Ly2t88cEvWdncQJZ1HB/s894P3qLR6VFIXdKpV0henKPXCQiCwGSssnPrLob5iOdPvmF7ax2Xy8XCcoJwKEKlViefzSFbPBTSaYadMtKdBzhMRs7Pr7C7XKyuruL3eblM5tm4sYnL6SGXy7H31RdYnB5EgxGnzsNsqmKUTcw1HUZZRlUUnL4AktFERFEwWyyMR1NOT0/pNKocHeu4fe8+SwOFZjnHVB0zddj58psnFLIpptM5RklClk0srN9Am45xe33kLQ66zRrhO3eYCXo0wYDb7+VH779LsVjn17/4FZ5InEF/yNXFFZo2QRl26TRb9NBwmiQWY36uLi/xBSIMe10qswkX2SqZUg1Z1uPy+qk2GmQrA2TJztllimg8hmTUkU2dMei1sNnNmGQJySDisluRLCYG/Q7rW1sIop7JfEy5eoDADKOoo9/tEIt7CIfDDNURhWKeYqnARFF44XYxR0/y4gKTxQpzHSabF6vdRTCuJ3W6z/rqMm7XHb747DM2tm+T1QTmc5hr2nfKg9964MXjS5ydHbN+cweH24Mg6LGZr+9jLL8RBYwnKvVyHn84QrNZx+XyYjRJpC4vWNvaQZ0L9HtdZkzxOE10u33SJ3vcu38PURQZDVXWN7YwG+ekRwo//MG7dJQRw8mc06scJ0eHrKyv8+DhXT789QeIeogvbyIWiuzsbKFxQvHqnIWIB1UZcPBEZTQYUU2lMNsc6ESRYvIUu9tLLLGCbDXx2qOHvHF7h0wmw7/+/3yD5ArTGw5Q5wIvD4559eQrFjd3yWSzdAcqo3KDSq2OyJzVzW0qpSqB8AI3b2zRbPc4evGU9eVdbA4HlweHCBurXKXyiEY96mQCCGzcvENsIcbx8RHRaJRUNnudgDAaM1UU6tlLEivLxBMrjKdT2p3OtWuEOuLl8RWNehWz1YLdZmf77l0i0TjqZMywA1niqAABAABJREFU0yWXy/HJxx8RX1yg2uqysLrCbKphc3lZ3rxJfCHG0ydPUNsN2s0Wf/of/zMzpcuP/+Cv8/EXT8iWq4xHM3zRJdZWlpkzZ9BtIcxnjEdjGHURFpbIlNvMxgImm43peIown7Kxvc1UkJnMpmiijnw2hTcSx+b14nK72XvymMhigl63TeoyidsfIZXOUyqV8bo9mAM+kqk8pUyG4RiUgYJeAK8/gM/jxWJ3oBPmtGp5mvkUNp+P49NrdaDR6qbRbjPTZvzop+9Tb/YIBQIsL0WYzOYM1Slm2Yxq7DKdKEzn8O3XT/F5vTjcDmaTMZLdwXw2Q1VGzCcjVpeWKKXPOX7xkqWlFWaTMZF4jP3nLxlpImZZT+ryDKPJwt7ePpOpRkcdMp3P6PY6RF02hJFCp1bn5PAIQW+mUszj87nR6SEYiRKNRakU8mhzkXgkRLMWpVZrYna5uSoWGfS7eP0BKvk8Lm8QZTjg669OCcTiFDJZKvk5tWIOu8ePNp2gTcdkMi1ki5V4LIpBb+R0/wVffi0znmto2oyde69htTvpDVWYTlhYWsZilgkHPLx4+g1ff/ohzW6ffqfD8soaUm/AdDTGaNAhmSTQfITDIcxmiZNf/AVTbcLXXzY5PPDQa7fQGWHzhgOrw8lcg35fweqc0un3cbqcDLoteq0qaxsb9HstZtqcp0+eMJtOWdtap5zJYjDIhBOrLCaWWV9ZwqATePXiOTaXg0Gvi89pZ+jz0a7XGaoquXyJ6WREp1FjbfsmRpMFm3vCaDpCHIgcvNhD1GmcXuaoVOqsb6xw585tfjFS6DVrvP3DH5HOpLHaXKDTU+8PkfQizUoZi8VCPJHg4nCf6WyGqk6Yzce0W3XUbh9nIIA6vH5eenkNp8dHNZ/B5XGi6QSUyQy9ZGY6m5FPXjKfwyflT/BG4ugNBhyeADNBT2RphdFQZTIZozeaabX7jMZj7G43S8tr5PNplpcCTIZtDp5+xc6dB7jsJkqFDKGFRcoWMz1FQZTN6PQyq8txOsqYyVSHqn63wPutV2l6fC5sLi+lQp79Z0/ptNs0Wm0a9TrdoUogGKZRrBFfXMZlNbO1ts76xhqyKFDO5ymVS4z6Hd568xEmswVZNGCRjEiSnoeP7uGx22hUCvQHKsp4xsr2TTRBz+VlHovJhl42g6CjWi5Rqzew2SysrK6RvrikVSlQrjZp1uuEllbJlWo0Oj227r/G7Tt3mSOijYf84OFNEokVwtEYeqOJ8+cvaNZ7JHNl9l685K//rb+Fx21DkvWoIxVVGaJ0Wzisdlw2K7JRj8UAw36fdrNNv68wm6jUqhVOL1Kcn11gszpYWk4wFUR0ujkjVaVYyJFYWsTntpG5Omao9Emlc4z6XSr1JrV6E7fXRyAUxBMMEFhcYXEpgUmW2Fhbxe20UStmqRczpC/PKGWTjCYjLpNJBr0Bne4ASW/EYrHh83oQdDpGkzlOh4vLyyw2u4P9/X1kWY/VZsfpDRFfXcfvdiLJMi63C4/dgNvjACboGKH02qTzeb787AN0Oo3ZdATajLVbd+mqE/rDAcNBk//yn/4zn332FZ5gEKvNxnQ6olqtMhgMufPwNXTalPGghyjOWV1bRkDHxvoq0+mE4XjEaKTQb9VZXFrEZLMxHE9oDeaM1SmtRofpXOAHv/NzXA4bOoPxOmbF4eXWaz/A4fQg6PQsLC0yHSns7x8y1zQC4Qg2q43zqyS/+uhrmq0uXr+HUCRMMLqA1eZBJ5qQTBYalSzCfEavXsNsc2LUaZhMMqIkUyiWcXm9LC4voYxV7N4wBlkmsbaC0u9js/vQJjNa9SpzQJJNTMZzSuUi8XAYbTJneXUVm9ND8vzsWjBjNLOyvMTu7k0sdhfDYQ9BJ9AfqZxepkCy4A9H8AcCiIKAyeZga2ODWCxMPnlMs1pCVQaUSyUkSWJlfRWzzUo2eY5eslErFhi2a+hFgdlMI12qEFrZwOZ0o9Pm6CUJ2eHBYL5O+2hUy6SzGQ4O9qk2u8Q2bxNb3iQSCqHNNBrVKssLMTTm9Lpd3E4r/W6dwXBAOp3F4vbhD8cQdDr0ej2j+ZTMxRmnB6/otttMRkPsDhsWk0S3N8Dl9hP0h3nnzUesJxI4bA7cNisOj49+u47DYmJ7Z5PxREWWJdTxmJcHJxRLVRwuFybZxGg6RWcwYpAstDtdItEYkWiYB3dv4XLYuDw5YD5RMRoM9FotKsUistVCZPlaSIZOpK+M+PjTL+l3O+iYUirmqZbyVArXyQnFfJFyrY3DG8Tp8tAfDBgqAwJeF2+8fh+n3Y5eFOg2ymRODuhU80gGEW00JuDxYne6MdusgA7ZYkOyOTBabAg6Hbfu3SeRSFDNXSKbTUyGQ3qNOg6nA9lqIXlxRfL8GJvTjKqoNMtVhv02ufNT9KLI+tYWfp+P3a01bt17hNfnYzHqY3l5iWq5wvlFimq9xZff7pFLJymXihTyhe+UB7/1wGM+waDXodcJGA0io2GPfDrJsyePQZvS6Q+oFbIUcwXK5RqiwcB0PIM5RJfXMTm9dAcKf/nLXzKdTql3ejSVGZt3X8didTCdztHGI/Lpc5KX5wyVEX/0v/9bHn/yMVaPn2Ihj8tp58233iB5lWGsjNBm4PG6EUSNXK5AtVqj0Wgxm8+p1QosrG6QvjjBIMLKzj1eHJ4TDId48+EdZtMpw36bUjnPf/4//oxkMkNiZRml38cXjmC2O8ml0qzuPkAQDExmGvHFBVY3tgiGY8QTy/R7XWqVEpf7z9h79pRao4Em6jm/KvLq2T4bu7fR6XTY7Ha0+ZRELITV4UG22lB7LQbdLmaTAVkS2VhLIGhQqxVZvnGDfKVGqVSlXqujTQVCC2skVle5//AektXBRDDQqDdxON1Uy0WePnlMo9nEFwgQisWZCyKVZodKIUMmk+Vgbw9BgEq1TLvRILayiToXgBl/8Fd/l5VYkJkm4Ha7CUQWMIg6EssJEivruN1OzBaZbrlIwOOinLpk77MPiC0ssrJ5k3A8QTmfp9NT8DhdbK+toBd0xGNxttfX6TcblGstMtkcbz66hclkZDKZMe218Pj96CQTl5ks3371OclXT5CMIv1eB8lswun08GLvBSenl6ytb+AOxEmnc7Q6HTRBj9Vux2ixEQiF2d69hWx10Wp2WVteZKwOGY0nqOoIm0mmUW3QbrdZ272BpjMwGqn4QlGCwetgzdlMw+l2025UySYvKRYKmGUza8uLdOolpqMO1VqNRrOF3WrDZpYIRML4/EGcLhsup51Oo0kwFMFmt3B2fEi72WHnzl3+6h/+PjptynQ0ZDAYElvexOMLMBdNGGUry7EogiDQrlfptBrkcnlm4yHj6YRcqUyzVmX3zj1+52c/Y3F1nW69zHgyptHqEllaRTZIrOzcxOoNsbZ7G9Cx9/Qlucskg2aLfDZPKV/A7/OxEI9xfnSAOuziDoRRBi3CIS+JhQjadITBIKIOVHqtGrlikdZghCcYw2Ixs3vjFrGlBMVCHrfHjd1iJx6JIcyntJtlHDYb8dUNQsEINqsDi8OL0+shEAxSyecZKEMmzEkXalxmc5wcHdBuN3BajUgmE7P5jMTyEka9geFIo91o0GrU6bSaOBxO7ty5TXghxvH5Bd1ul267icFoZC7A0cUl7nAM2WIiHI2hTaf0W00cDhcuXxCHy0EgFMRit6GXzFgdTgLROAarH00zsnPnEd12l1q5zKBVp5K5REPH5fk5/V6PWj5PtVwkVyrRaPdwOpz4/F78IT8P3nqL+No2Xq+XyMICyyubpC6v8Pj9NOslslcXKGofu9uFpgNPwE88FsdhN6OXjYxHfZj1iYc96IQJg1YZk16HUZKZz2ZYzFYMgkYqmSKxtEBie4tMtsCzl/ucnxzR7fQxWWz0uh10ujlLG1vIsszGxjLHr55j0P+PwfP/rnV6eoGAhqZphFdWGfWHRBcW6bVbWC0m0M1pVPMsebyYLVYO9/fxBoLcvnGDTDpLLXXBzs2bPH38NZHEOifHZ3R7He49fMDe/hHlXIp33vseI9HMq68/Z2U5AWEvL/NJ2rUKw1aV2/fvYjQa6LTrbN+4xdHBEaraZ/fOI6ajCep4gsMkow5U/E4nAaeDi70SDpeT2WzE06d7vPODH1AsVzh98S2+cBS334/JbEHpNklnr++F1EaTwXBIs5QjtpCgU6swVDok7t3hyTfPsLhcuHx+5uMpZquDle3b6C12ytkkZrMFEMhfnVMv5jBabazvbGO12Pjy82+YTyd0u21WlhaRZBt6UcJmd+L3XifB95t1spd61NGIUbOOzeHmaP8r3F4n77zzFidnadrVGnaXD4vVSjabp1ErEVvexO310e026TZrOHxhTo8OcHvdLCxFWV5dwedxUC6V0E1HnLx8hSsYod9u8eTlKV/09tBLRiLhMAevTgjG4tQbTdz+IHdv7TCbTRgOJgyGAyaqgtLvUS4VWVlO8PVXj5EMoM1n5DNJLGYJm8vNXIORBjaPn8lsjqiXyBdrVKs1bFYTdx7cJV9q0qhU8YeiOFx+nF4fwUgUwSDRa7aRTWZkaUY5X2CuzQhGImS6Lew2G6GgF7tVotmqUcjkaXcH9FoNnFaJz09P0InSdUu21+H0/JJQZAGD0cz50SECIqNei4V7N5nr9UwEDdlkpqdMsHoD6LQZ0/GYOQJG2cyNWw84PT3BaJSZTMZkLg4QdTPKpTx2b5RiqcKNzVU8Hjf7h0ccvXiB2e6k323RqhSRTHrmUxi2y/R6EfLFS2w2O1MGtBoVKuUKCJC5PGf3zgN2t9Y4scrU2x3Q6Shk00wFA+OxhqIq/OEf/j6lapeX+4fXwqbVDUJBH5fpFLPqhPFYIRJZoNVoMer32H39BpPpMs+//QbZ7sbtC3B1/JLbr73ObNxDEiZYDQKz2Yx6s4HBIGOSLXgCQcr1CrnLY7yu+xydnTAYjYl4A1SrJWRZj8/l4NadO3z12af4fF6SF0lSgwF2ux3JJCMaJF48f0a31SC6EMFsitAdqugkGbPdRaXcYKqBoowoZQtMx2O6/TYGs51Go43bYcPqcNPpK8zmGm6Pj7OXL/idn76PyShwcXaGy+NjrA4Y0MLp9iOKImaHB6fDglE20Gk00MYq7UaPbrvJfNjjxz/+HSqtBgdDBbfXTT6bx2QyEV3eQBRFkmcHrK7EsVustHoDdu++zunpPg1Fo5g8xyCKPHr7ba6SKS7Ozui22uh0NzCZJPyhALliEWGmIWoCol4ksbBEu9PF6TBTLpWvvXynVwjzGXcfPODy8hyfy80bj27zyz//r9jNMrd2t/j0o49pNIes3XzAZDxE0ObEY3F+/csPCISiaIg8+eYpdx7cJRSJEAgHqVTbXF1e8fC1+yysrlEp/o94oP++JUrk86nrqf/uELXfQycI6PQGApEoJ0fH3HvjHULREHarky+/qOPyuCnVagQCAWK//3tMVYX5TMNstmIQjYjalHu3tviTP/4TlhYXcHmDfP3tE954511u7m7x4vCcd39/gWKuhMHqoN1XqdTOaJVy9KILDDotRkqParnMyfMnhBLr6AwGCvky/oCT0XjMz//qX0Ov1/Ps1TkmswV/wMuL5y/Ri3D3zi3sThcXV3nCkRgn51lsdplIJEa33eWHP/05EwTmdgvtlu7aYcFmYzwcYDLoqdaKlAtpNm7eY6xO0MYjEjdvM9dg8/Y9hsMe3b5KPlumWW/TadRZ3dpgMBxyfHKE1Wzni48/Rp0MUEZjVHXMrde/j14UOXy+9xsBiBmL3YSm0/Gf/uNfIOhEEpvbOGxO9p9+hjNy7R4xm4Pa7VMpFMmlLqmWygiChm9xgXq1TrvVYrqxRqlcZzybYXY4GY0nrOzcpdYc0q4Uef3NB3g9fs4Oj6lVSrSaTQyijmq5SiQaxRuO4Q34ESUj3ugSW3fvEPN5KRVLTOcaHm+Q6WTK8eE+6mhCs1Undfic9372u4DIfDrnKpmhWiljd9hpdnocP3vM4sY2gkHHSBly+/59UldXdFt1HE4fmqZRbw8wCBq37t7mxs4qojCjORiiN5nJp/LMtQlunxedaMDtCdDt9qmUS2iiyMrqFr1amcl4Qr/bYzKfEVlcwWm28PirT7lI5QgvLjPodlB66rUJuN7I6voqB0+fkjqvYzAaYK4RX1nDbnFgXFihki8TjETo9XvMplNEBM6vcjibPS4uLmgXM9x640dUSnkEQcfNG7so6hTZbGZne5vRbB/GPTa215AZky9kkWUzFouVQi5PIhZEMFzPoY3mcxZ3buB2B1DUMcpoyieffYOijJFtdmbMQJth1EsMWk2QZYaNKoLPze7OGmdnJ8hmAygaNrsNWS8wGgwJRBYxSDKecIxMNsPunYc4bFaQZKbTCVa3G4/bw1jQ2Lp3n2a/TyQc5eDpY8bKEOZTGoUc5eVVOt0ejkCc8NIKkslCvdHC7/PQbLZhMsao12OUZFLJJJ16lVBincnMyWQyJRpfQjQaKGQyHB8dEh4uM59P6FbzeH0B5oh0+32UQZ9Wt8t4fO1D6XU58LpdZFJJEsuLtBpNtOmYUCTC6ekVBj2kzs9ZXF3HHwzQadaIxpeYKD1GWEiXSrjdPtweN6VCjsWlRQqpOQZRR6lUZDSaMJ7NGY6njKcjAvEYVrcLu9NOu1LA5LDi8TgY9K4t3KajIZcn+5itNmSTmXqlhCAKeL0hStkMV0oas0lGNxeIxxaR9TLdThedeUY6X0RVJ3z95Vf83l/5q9x+531SxRrvvfUIZTDki8++wO5yEY2Febx3QLczYDKZYbJacfrDVDJX9Ls9bA4vqfMkHq8PoyRzcnRAfzihVW98pzj4rQfeaKyyvXsHdTwil8njdnsoFVIEwxFqtRq1Qg7/vdfIFerMphXWd29isch8/emnmC124kuLHL3YY3XnHk6Xl16nyVJkE70OrDYHoVAUwWCk12qSLlS4vCpisso8enSHYr6EPxDCbHaQTqZ4+Nb3kc1Obt81Yreb8AYCNMsl3E436csTZpMpvnCQ05NTAv43sJkt1KolYstreNwOtra32bi5TTzoQ+0P+TSdRrJYKebT+Pw+ptMJU01Pu60hGvXUSyX+1t/8a3S6XQa9HkbJwNbWGhajyOXRS7T5hLHaR5hP8bltfPrRR/z+X/l9coUSX3zyGZLHh6rqiK9ssLu9QaVUQDIaSSwl6LRatLpdOp0BpcwlFrsPs82BwWBkYXWbQrlMOBxhNpsw0ea0GzW8Pg8+r5fspZvd7W3qvjpnB8fMh35cHjdL69sYZIl4PEqj3CCTqjKd9jBmi8zGE4wGUNQZvVoRl8eFKOrodbucX6XRRBOS2UIsFqHc8tEqZtjaWCNXKBMM+qjUanTqZeaikRfPD/miVuTtt97A6vLzfG+fbruD1WbD5TEhGiV0epnnL/ZR+73ru7r1XaJLS3iddnyBAK16j2DIx9pKDGmuYTGbEUWBRinHu997l1w2x37yjDuvvUGpUiZfqtAo5jG73FQLOQbdPm5vELXbYaQNCYZDZE4PkEwWDCIYjSIjpYfWEtAbJLTZlHohhclsweZ0IZtMFHN5lP6QtY04t+/c5unzfcIBP+L9e3zw5/8VUSeSySSRZIlyvkS7VsIfCRIIR8jlrgUjy4klkldXSJKA026jdjmgUczh8bhoN8ao6pTjl3ucXVzQ6w8pF/KEImGMoh673UGj3cXl8jJSFRq1Mo+fPsf2G4m6bi5SzeSIRBZB0KF0BLzhCOpkijJWmTHmwYN7zNFjMJiYocMbXaJUrXP/jTepN9tU603K6RRnr56yvrHGrRtrHJ2naHf6XL16wtrWDqlimU6ng9kywx9Z4PToFeohrCbiDDtd3IEAgk7G5Quj04lEF1fptHrk8nlUZUj2/IRus4bXF6RZqzLXaQiaxg/eeIeL8ySHhweEYkvk9GaaxQJzRUEdKVylLtje3sQiCQx0czRBhzbXsXnzNptb6xQLVY5eHaLNZxSyefzhELLTx0dfPqVeLuPyBhnNpqjKiBvb6+iNOiZqi8F4hmSxM1YGGE0WOu0B3b6C2e5C6HcwmcxcprJoaLj9AaYIrGysY7Wa6XY7FJItGuUSI6udo5d7rOzeRq834jSbWFpc4mL/JSN1hF6bs7i4iNJpMFAUfJEwvWab23fvcHF6hGI2YdBrpM6PWL/1kPOzM0wWM9ocEitLXJxdkM+n0DNDEEX2Do4pF0rMZxNOr7L4gj70jFldW6E1GJJ5+QKr1cpsWOf5Fx+ytHULq1nC5bCCXqJU0mN1ukAsYrJaWN68Huw/+eYX3xkPvvM7vOl0yj/6R/+IpaUlTCYTiUSCf/JP/gnz+fz/+oymafzjf/yPCYfDmEwm3n33XY6Ojv5v3zMajfi7f/fv4vV6sVgs/N7v/R75fP6/ez+Zq1OazQbqQEGHAaMs4/QGSKysIptMWF0OBsMBpXyWcjFPtdrgqw9/xc72FttbG1gkHf12DXUyIp9N02nXMTk9fP30JU63m6XEAno9aGoPtAnDQYOleIRep0cxnWYyGVGulmE+YTSb8fzlHvPZGJfHw8unL9F0eoaTGZooYrXILERDGA0iB8cnfPjFY3LJc4qFFP/ff/NHPH/2lFq1zbevzvnmyT47t29QqxQx26xcnR1SyGYo5zIcP39Gs17D6nCwf5Lkk48/xfYbwJ6eJdl7tsfv/N4f8NqDO2xsr7Fx4wZ6USQQWaCrzskVykzUHqsba0QCfhr1Fk+e7PF87wWg5+zsgu5wSGJ1FafTislkxG4RSZ8dMBp2riuZep7Tk0OK1SadZgOHzYY2h68+/wJPeIHJeIYy6KPTS0wmEywODxhkBr0htWoTdTIjmzxEGXZRlB5Oj4c3332H3Rvb+P1+ZuMR44lCv9tmNp1SK18Ht5qsVsqZJAbZQrc/pFLMM1FVQi43Xn8AcaqyvbaKzSTxyz/7M168eEHq4hXqZEy33cYs6ei1Wuh0OpwOD6H4Mt7QEjr0+Lw+DDqBP/uP/5FiLkmpUuaDj77g/CpNLl/BYDYjWR2IOo1I0M183MdutbC6ts6g36daqWCyujHbHAwGPWbzGR6/j2a1hN6gZ33nDomVNW7cf4ReljG7fPjCYbxBH8XUCYN2HaNkxKA30KjUqZVK1HJp7DYr+4enzMYq2VyRfL7I8sYmkmTE4/EiCnO8AReCXsfF8T6VWhOzyUwheU6+VGY+11DUKQaTjQc//B088RAzUceb77zN7lqMlbV1XA4X925tEgsHOHu1x7OXpzx5uofL62U0URiPJyysb+CNRshmUvR7PfRWCbvLw5OPf02tlKNTK3Jjd4u11RX8/iCKqnJ8keL4+IjJYMBCPMbK9jZ33niN4bBHqZBDm2tM0OEOxJCMEuFYnOlYwWm3c+PuPTLJC7qdNhaLCavNis1mwmyz43H7cDncrK4kePr553z92adU8ll0OshkMvSaNbweJ3cf3CUQWwIdhKIh/JEQpXSGQXfAN89e8PTpUwadFjazEZNexGA04Q+HsVhkuvUaQbeT7733Q5aXV5B0GrOxQqvR4+oiQzZ1iU4UsLu9tNtdBgMV2WxCGWvMNB1TZYDNbGU0GfHLX/wF/+VP/xRRMtEoZvF43Ng9AeqtHjMNZrMZmgatRhVBA5vZQrevcHV5wfnxEWcnR4zHI3zBMP6ldUTZxBgBqyeIbDAQCPhpdXr4w1HMVifT8ZRytcHR8RlGiwNRb6BWLjGdzhgqCnanl6WlBdZ3d/GGokhGgZ3tTfSCQLlUYCbAzRs73L51i7/5P/9NVpaXOdl7itfrQ+kPKeTziHodHr+f1x/ewuN2M55M+PGPf8j/+r/9XdZv3cVis2FyeHi69wqdIDBSFF48/hrZYODw2R6np6c0GrX/f5H0f1vfeYX3z/7ZP+Nf/at/xR/90R+xvb3Ns2fP+Nt/+2/jcDj4e3/v7wHwz//5P+df/It/wb/5N/+GtbU1/uk//af88Ic/5OzsDJvNBsDf//t/nz//8z/n3//7f4/H4+Ef/IN/wM9+9jP29vYQRfH/8X78kUW6vR6p41fMNR2T+RqtYgar2UI2myUSj6I3iJgsZiaKymisotfpiYTD9AYqzfaAzVv3EQwyFwcn6PQGnr84weaQ2F1f5uXROc+ePiGydouJOkLUy1SqHTrtSxw+L6FohEwyiyzLpNNZBr0WX3+e5NtvvqVTLbP92ptosxGyUc+7P3iPi8skSysJSpU60+mMR2++zVXyiv5owh/8/u9ynszy5SefYDPL/Px3f0g6dcmgr+J0e/CHY3Q6PaaTMSsbGzDTOHp1yHQ05OHr97m4uKBSuRYNHB2dUWj0cNjNhOMLfPnZp9i8EaqtNm5/gO/9+Gd4/SEKuTwmixkAp9fPUFGpVcoEw0F0BiO1apVes8q9e/fQdCLTyYjbu9t4Az4KuTxOt4fDFxXAwngGSr9H6qKLJBtJnhywfuM+NrOZQV/BYrNi1EGlVGJ1Y5Ptu3eIxRY5ePYEYarhsFupFEq4nRbu3rnDZ19+QyQWQxJ1BPw+vq1X2PvqE8Z9hWz+Cr1BTymXwmh3I5kkVje38ATCiAaJxeV1FHVMMBxiOlXRG0xomkCuUGKkjjBKEr6Al167g6ZBaCHGfD7DFwpispjY3L3FYmKB5Pk5e0/2MBol+u06Xq+H0WTGeDonurpJq99jkkzSq+YRBY1hu8T65i71Yg5RN2F5ZYv9p49JHh+hE40YZQnZbsdqseH1B3n9jQfkCzUCoTi37uzSG12734iiyHQ6RpgpKDONSrnCoNdihMbpk6+5++gRE3VAo94gEA+DKGC0WNhOvEYg4EUZ9pkXs3S6XRqlAvOphtGgJ7G0hdFk4vGnn3Imgtvp4Onjb3G43ASDPnorqxy9eo7FakYn6ilkM8RX1vD7vZwfvuRHv/8H9GohDp89ZWFrl6kgsLi8zMM3H1Eu1kgXqoh6I/VKlbkm0B0MGHQ76JgzGg1wud08/uYZ88mInd1tNtbXqOTziDrddfrHWZLZbI7RaCQUWKFYrF4LvnQyok6P227F7/XRqFSpV8poMxWHx8vaxg69bpdhv8lrbz3kyG4imyvT6Q5QFJXNG7cYKRNMkokf/+Q9CsUGnU6P9e1t0hfnKL0eq+urtFtNjCYjw26fxcVlKtUO2XyW1a1tVhMLFIoVPvvkawySzAyR4tUx0eVNBgMFq8OF3W5n2B8hmcwUr05ROi1WVtcYDIasJCK4vEFkScbhdqDpJGTJhNdlp1HKE11YoN+sc3p2yKCnYDRb8PhC1IoZ2oMRX3/5FZpOol4uMPR4sdhdmM0mqtUagtFMuVxkrHRRhgMSni2cLi+CXsBqsiCbzYiiSK8/pNloMuy3+fabBuvbu+h1Im63D2U2Z4pIdCGBxWLm+OgUtT8AvZ5yvY3J6sTt9WExW0ifHfCDtx7SuHmTX/7yIza2dokvJtg7PMduszMYTrixFkKbz2h3+rS6Q3RGC0OlxA/ev4fL5abZKHL3wV0++vffHZ++c+B98803/PznP+enP/0pAIuLi/y7f/fvePbsGXBd3f3Lf/kv+Yf/8B/yV/7KXwHgj/7ojwgEAvzJn/wJf+fv/B06nQ7/+l//a/74j/+Y9957D4B/+2//LbFYjA8//JD333////F+rHY7Or2ML7rI2tYG5VIZ2/LGdQxOtUQ4HORk7ylL6+todhfJizOW1tZI50ucHJwQX1nGYHaSvbrCE4riD0XJprM0a0U8dhfpVIrpaILd4+HkxWMc7gDqVAVhxvrKMtVslulkztrNu1SKeULhEJvra9TqDb7+7GMC0Rgui4kXez1Eo4lKsYTd6SB9foFBLxK6ew+L2YwwHTFCQNAbcIUiGPUiL05S2N0RBLFJKBLi/DjJbDbie+//CAT49suviS2uYLHJTAUd4XiCWr2GxeJEVYaMJxq5Yh2jroVoNNNs1BgqCk6bjZFJplLdRyfq0eZzlGEPry/A8uoKxVKJs/1XTIYqy6srdOplLtN5CpkUP/rx+4xVhWdffE54eZPRaEootoTL7abZ7OANRZmMJrg9AVyBCFanE7XfR1FnSJqBcjHP7du38QV83N5ZwyRL5DMZxoMOOlGk0agQD3oxGkVqhSwP3niEy+1k78kzfv6H/xMriQWSuQKPv/iC7bVFRsMho06Dcknk7p072Gx19p4/pV0q8P7vvM/h4TF6g4jb6aTRG2B2evFZ7HSbDRKxBfqOBsVCgUG/TaeuUshm2bx9n6jfT7XSYIKev/E3/pCTyzT71SKGkUil1qRaLGOz2Yn6fbzaP8QbXiKyYmFhIUDyKsXm1jZbW2t8+tUe/vACd+7fQx1NSKZSdLs9iq0miwsxFsNeLs9SrG7v8PD+bX71wedcHJ8QS6xRKeSun+dUYD6fsri8jMXuohlZJFusYRAbFJPnqOMRJpuNbq2GLElkM3mazRa+2Ar8/7j7j5hZ9vS8E/ylj4z03rsvP++Od/fcW9dVFVklsaehbhCiuhvsljBNgCtCXgsJ1IIkpIVEgMCMMCuhoREgNMlmkRRZVdfUNecebz7v03sb6X1kzuJwCkNJ0zOCaiHUu4vA+0fEKn7xj3if51mAWqvFHw0ylxcUCmXiq2vEVjY4fPEYs8lKKBbj6TdP+N9/oEOqFgivr2OymbB7vRgFHetLYSrVJsZ7D7AYDQg6A3qdgMNsZSA1sdicnJ9d0W21cfj8NCtVpqM+o/6QdivFsNcktLKFoLcgT2c4nU76gwHThYrJdIrb5yV5espiOiYS8vD5j/YIhkO0ZiPm8hSby02jmWQuzzGJAmazSDaVweJwUC0UcXm9jMZDMskzVtfXsZkNhKNRXr/eQ8bCZDLi9dOvmQzHmEwmnHYzNouJVOISs91BYGmN4bBH4eQIeTri9nvvElxeppQvo1CpkRoNSsUio9GQxXzOaNjCYl+lVh6hN1h4+PAuvd6Qy3QRmy1Ms15FqVig0+uxmEWcTjvHagWo1LRabZwuJytLEYrlOlmpzLWbNzg4PMJoNGB3BRkMZjSbNawKCJkiTKx2WvUyWo3Azs4GOs0uj75+jMtmZnNtlU/+7N9TUaoYz+aMBkNUygWn+28wmswYLCYWdistqUE4HEXQG2lUJVY2wpTKOcwmkVv37nB2cYGqaqDbbrOYyyjVWurlPKNeF5PFRCwS4EUxSzGfQ6PRYXY4mbPA4/dzeZUhFvYTCrj4f/zf/u84glGUSi3JiyS713b56stHZFMJjFYHSo2WerPJcCLjDwRw2K0/Uz79zIH37rvv8q/+1b/i4uKC1dVV9vf3efToEb/7u78LQCqVolwu893vfvena3Q6He+//z6PHz/m137t13j16hXT6fQv9fj9fra3t3n8+PF/Enjj8ZjxePzT406nA8B8LlM4O0ReyLTbbVqVEu+//zGFcoW17R2MRhOR+DI2p4fRcIhiMWU2m5FJXdFsFFHplPS7XRrFAtv338FgEJHKebZuPXgrsJQXbN19yEKe4I/GMZntDHsd7EaR61vrHB0ecvXkObLi7Y9yeTJlPOgTCnoJxOM0W12yySsEvZ7T00uc3gBep5NOLEa3PyQa8jHuNNgvpPniy2dkkml6rTL3Pv4r1FsdhrMxxVIBQacnHo9RLBbwOO1cprKM+xKCeko8EueP/+gH9IcDbHYn99/7FuVymVK+jNcfwCSaEPQGKo0Seq1ANBbh7PgQqV7lWx9/h3y5jEIxo9vtUS7WqORzXL91E5UC3rx8hjsQRqXQYDSYUKtVnKcLdDodpskE/XYLj8+PRq1h1G/jcNnpD6ecHh6g0Ys0W03K2RSBYARBMCJaHdS6HUazGc22xFyeUiqWMVmdvH5zjMMb5uaDW1iMRlY2Nhh1OwS2Nvm8UaM/GPH66IL9Vy/ZuX4dhVaPxW7D7nBQLuS4ODvnvXfukUkkSB/VmM6hVSsyHA3xB0NUc0l67TZ6vRnBKDKYjmi2WljMVnxuF+OJzItnz2n3JxRzBaqFHKu7O8zVaqwOO2qNnvVrt1mNRzDqBUqFPNsbcYbTEWfHJ7BQUUxdMRj1UKxskMxU6LWahONLjEZDEmeXmBxOVBoluVqRrtSg3e0wnc6IuYIks1XanS42txOFUo1SoQEU6EU9KKBZyVEqFOh2u5gcLqJrK2j1hrdv8ioVUjFDvZCB2ZxqMYVKNBMORhm0mohLSxRyeebTIa1GHbPVTGTjGjPUmE0m1Jq32Wpnkx6degM5FEWqlRioNBTdrrdG6jevM53OkJpd7r33PqJoQC9q6XaHjEdTquUyNruVa9trvHj5Ck8ghM1soTcYUm/WODk5hNkUjWBAbzIzm8/45tkbxpMhKq2SqTyhP3oLOK/Xhc1i5vT8lMzVFWsrcfafPafX74JiQTAaYTqZolSqkFHT7fexutwc7h8imG0o5DGL+Yy5So0gmlldiSLqNXh9AdRKsJot1BpVTveeolKLyPM5dpebwXhIsVRFFEU0oh6FTo/F7aNydMjLZ69wuD1Mp3OG4x79QYfJdEyp1sJsMuF0ubBarehMNsa9Fo5gnGSuytHZFa1KmSfZFLHVLXRaDWfnVxgtFmZzGYvVyLe/+zHHZ1eMx2PMNgvh+BqNRolmo4rD6aLf6yJVCiT1epweJ4JRRG80kCuXMbvceLx+uv0hhYFEdHWFYHSJ6VSGhQK1Vks4HOL1q33m8pxqPk/ifI7RYuVsOiUcX2UwmuBzOHB73ew/f0w+dYWgN6OQp2yuLbMAIktxisUsofgG6Ys0/9u/+X0cniAGq4lSvYpWp8fmC2Gx2JhMp1SKRdqRGFarlXwhR2ApSq8bYP/Na1RakdPDDK+f/1eelvAP/sE/oN1us77+dkRWlmV+67d+i1/5lV8BoFwuA+DxeP7SOo/HQyaT+WmPVqvFZrP9Rz3/7/X/Yf3O7/wO//Sf/tP/6HzE6+Ds5QtEs5mFPGHUazGZTVgoNbg8YSrNCrfu3mIBFNJ5YqvbOJ12Wjotnd6Q8MoKi8mCssnMtevbtJstFvKYdqdNNZ9mdWMNq17Ns8ePcQdDSM0608mEgC9OTWpjsruIL8VY393lU6nJeCahFfRYLVaU+RqNQhGYMZwMKReqLK/EWCxk2t02gfASoqDDaHUQXdlCJegIRXzslZMkLk7oN8rIM5nllRVW12Kcnl2hUMFsMmEy7BGORbl+fZvBWIloMKFUKtFpdHTbPQS9HlGnIRp08/UXjxBMVpgr6bRalOoNUKlw+QPkixW67T56i5FgMEy71aGUSTGbq9FpNEi1CrcevMPLZy8IhMPYHRb2Ty/ZffAeZrORg2dvUCtlcpkUw14bxSKC0eGgVhwSi0So1hpoRJGG1OT8+AhPfJNOZ8isP0ChAI1Wx3I8jFa0UKkUKaVT5CIRJm4lNm8QnWpKrd7g7sP3WMwWZHJFmvUquVIN53hMIZ9BVqlJnp0y7L4dsNAbDMQ3N8hVGnjCy1htVqazBWazDb1Ojc0doVapkk7ncJiNuDw+HHY73cGQO/fvkrw4RtA5EPVaevUqf/T7ByyUajq1Ko8//SHN+h2a5Ry9bosffqYEpRa7x48SBbFYjG5bgsWceiWP3W5h2O/h93hw2O2U63VEs5XxcIhgN9EfykiNBvJsitfn5fz4CIvTTq/bp17MoTPp8fp9mC0mzl4eEdy4iVIrYLc7sFlNnL0uEwzHMOpF8iYb/kiYQCCE0aSn3mjj8noY9iTGnQZev59yPkPA6ySTKzKbzqg3JaqVEjs3buG02JgMxly/cZMbuxucvH7Jxf5rTFYzOo2SN3sHKFQqDFYLrW6XZrNOqZTHHYkgK+YoBBMKwYhWrUGt1DBHgdXpwiMIKBNweZXAZn9rZNBs9Rj3BijlCdmrBNPxjGImRTgax+p00G51KRarONxuorEIeoMZ0SgyH08YTad0Gi0C0RWU8ylSJU9tJuMLhlGpNVRLFVZW4ijnc8b9NovpGLfbjdtu4pvHL4itvo3KmS80hKJbBAIemo06RpOFXHpC8vSY7374IerZjFqnw2A4ZtBt4ovG8IWDLOQJivGEleV19Hozs7mC0WRGpZimUshRLhZRqBaEltbQ6LSsRba4f+8OJ2enePx+jvbOSJ6dc+3ObUxmB1dXabZ3t0EBqzvbzGYLnC4n8n6LcjqBddfEYjZh8+Zt1EolmWyJUjZHt91DpzdgNAmsxsNU6126zTo3bt2m0++TK2RQKtRYzBZGkyHyAoLRJVQaLcXkBUvrq0i1BrVyBa1SQS6RIBCJwHxOIBSg3enTHMkUymUmkzmd7oTo6g6iwch8oWQ2n7NYLOj1Zjx/+pKt7R3kyYRSPofDG6TdbrJ/eIRO1GM0iswnE0wGEWZzfJEAWr0WNXMOv/kvY9L/Z/3Mgffv/t2/49/8m3/Dv/23/5atrS329vb4jd/4Dfx+P7/6q7/60z6FQvGX1i0Wi//o3H9Y/2c9/+gf/SP+9t/+2z897nQ6hEIh+uMpnlAI0WJHb7QQWV1ld3uZp69OGY4G9KUGxUqNfPKCXmeIJ7LKVSrHaDRgaXWdYbtNKZNkeX2bQa9H8irNjYffpl5roDeIKBYyrUYVjU7A7/dyuH9Er9FAtbnJi9d7OFweVre2adQbmAwGDCYLap2eSq3BX/+/fMyf/vgxqJT0+1OS50cMuz0uL3Nkr65wOu0cHB+QTub5q7/0PQ4vEvS6Evfeew+dyco87KPf6qLVG1AqlRRzadweH8lUhkqxyMbuLnvnGbq9CZvXbqFSQrc7ZL5Qkbo8w6DToBcFFMg0KkVim9copc6YTWdoBQGdaGQ4mlEtZbFMHZjM9rcDEbu30Asi08mIQHQFjVqLcjYlcZWgXJcopi/whqJYbA78IR/f+fAhXzx5iVEUCDitVKU+WVkmFg3T7vZxegN0ez0GvSHDZpm5aKRQLXFNvMPO1iY5QUShBHkxYdDr8/mPfoTZKNCql7j7/kekEgk2VuPEonEa3R7Lq8vsbK8wnikw5/Ko52D3BVAbrbw5PMJmMfDxtz/ky598QzaTwhNcptOq4fH72d25h8lo5ogFtXqTVq2Cw+EglcpTLaYRRIFrN+9wfHSE0erkzv37XF4kkJkzisXJXJ2g1ijodSVG/QHVaplmqcj/9Lf+F16+3OfRF5+xtLqGVq3G6w+QzubRqDVUak268zntXotKucBkPMbpD6FVq0hV89isW/QGI2xeD/G1Tbqdt7pCvcFAp9+lNxjwK//zrzJZaHn85BUmo4jDYsLr9ZC8OCUaX0aj09LutBl0e9RKOSIrW5SLBSbjCeZYjHK+hCAaEXRaLCYDtXKJoD/E1cUlDalLud5ANZ/w7PFjhpO3qedL126wtPJWsG93OOiOhtQbXZTIrK1toxVNHLx4BGqBTqOJEplBp0MmcYVSqUavF7HZbDTrVdRKJd12k17PhtFqwu1wMB31SSYTON0R1ChZ3dggkUjx4ulj9AYrVosBQasjnUwjy3PuPXzI/uEJw3YDb8CDWrjO/pPHaPRmDCYjC3nG7s4mJoOA2eOl12kRjERo1Otsr0Zp1Ksc7R/giy3TqZVx+oM0TWay6SxubwCzzYVKqWE5HmWhUHL1xRc0GxLdehWTxUa9UkUrCESXYlRrDRbyFJQwno8x2WwsZhNi+ijjqcyo30OWJ4yHY4YeN1arg7AvwMXRJQazFcNfhCWXCjm8bi/p83O++4u/wFxeUKo1WN3Y5OlXX7AaDyNqNWRyRaLxOErFHIPVyaDfQzSaCAUjSI0GBtFEv9Plj/7w36NQq2lXMqzs3EYxn6IXVPSbVeRAAJvNSl2jxm6z0axWmU9GxMIR9t68wmo0oVVpGA6GqJRqNGoV55cJtFodhewV8mLGeDxmNBq+lR447HQ7HerNDu3u29zRVq9HdHkZeTFl2OthMzjpNcvo5nNC8TCfffIZo9kEvUFPPpX8L6DRf1w/c+D9vb/39/iH//Af8tf/+l8HYGdnh0wmw+/8zu/wq7/6q3i9XuDtLs7n8/10XbVa/emuz+v1MplMkCTpL+3yqtUq77zzzn/yujqdDp1O9x+df/b1I1a2b9Ko16hmLvjO97/DVTpN4uIEm9uHzelEo1AxR403FGUyHnH5+hGR1S2cdiuVQpf5bMT9+9f4P/7gT5jOQC6VGPT7eNxuAn4v+XwOk8mCwWTFYnUybLUxW80osnOyV+eU8yLdVgOXz0MykaUr1YnGV/nxT75iNJ0TDUY5u0jgcnu5//B9jk6OcHr9BHweZpMp424LnUpNJVtgNu5i8MRJXCUIhyI4AzEEjZLpbI4g6LE77BgtdlSlEuqFTCObJFuoMwgEaDWrzGUZlUqBy2Fl5/o9SuUmWsFA2BOmLzUY9VqotNBu9SjmMhgsVmaKGVNZJnFxRq8lYbdtIs9GpC6O2Lp2nePDI0rlAna3l2g8hnIxZM4CjVbDsPtWIN4fTFGhYCpDt9tD0IuUKlWkap5oNE6r2USt0eAJhum3JCbjIQqthpdvXlMp1lEKRtrVEi6PBxRgEAW06jkBlwOvxcQf/+EfElrepZhPc+v2dWxWK59//giD0YxeL4BCgy8YpZC+wueOEQkGCUZCFHJJRL0SneDm8uAlJoOI0WynJUlUixlGvS4r8V9EqzdQLgt0uwNm4wmDdptyPs9oBnqdjvGox+rWBsuxEJFoGJPZhIY5o+GULy/PSV4lWVpeIpdJgjyn25c4O3jBXKXBZHZQqUsYRR1rq2tkk0lqoz6iXsBlt3A0GaJaTEmcnaITNBh0Oqqdwtug14US7QLcZhMv9w5xewK0awWsFgPj/gCNSsvGWpCd7XXMBh37r19i8YWYjif4Az4cNjOf/fmPmKPB7LBTLBapNlqk0lksNidet5dyNsVk0MVkNnLnwbf46ic/pFYuMBoPGHbbnOzt4XR7GYymtPs9mo02ZrOFR4/fMBz0cXiXaLcaTAcd4qtL3L19g2G3y0yhRGsQ6Y6GqNVqVIoZ3/r4u9SrTbrTKcdHJ+g0SnweF2a7nWQyRbZQpFTII4h6RLOBRrVGOpHF5vEgVSsY9HrCoSBPkhecnp0zHY9wBJfx+v3IswnybMrlVZJJv0U2k2b33n1MWh2lUpmTZAnBbMepUBOOhuk7nVQLBXrNBkaTkXz6EtFqRyFPKTbbpPJV1jc3UWu1fPonf4JWCW6Xk+O9N3hcLpbCQaRqkbODPcx2B8N+j/X1NTQqBaVKDZ1Og8XupNcfY7U76bYknj5/w2IxY9jvcXF6gkYnUC7kORcNCIKeH/3Zn2G3u2k2W6g0KkLr23SmMt2JzEReYDIa2Lm2w6sXr7E73WxsrVIt5sklL3H6QihVambDAVqtAGqR8UyBTbRiswnEIgO0LDAZBRZTmWdffoE7GCCbusDn87J5/S4avQF3JIbT6yYUDNDvLPHqxUscDgd+132ePX+J3e1l9dou+bMzWo0yd+/f5PMf/pBsLst4PGY67qEAHDYrkjx9G0smWumNRqzZbXz4nW/zk08/w2GL4PC4f0Zkels/c+ANBgOUyr+sdlCpVD+VJcRiMbxeL5988gk3btwAYDKZ8OWXX/LP/tk/A+DWrVtoNBo++eQTfvmXfxmAUqnE0dER//yf//P/rPuJxuPYbRaq5QoqrZ5Of0Q+cUStWKTZ6BHfWCWfy6NS63G53CSuEljcflz+IJVKldF4RnR1i1q9hdHiwKA3vLXhOsrTrk/oux2YrHa0IlycXFLJp7j74C4X56foRAP3779LQ2rykx/+GQajDZ9PZjLpMxiOSF+l2NhYpt9ukr86JbS0wnnqkpPD1zjcIaTulG6zjt7hJ1tpYnU4ePXkmLnGSE9qUxXqKJVtTHottVIZjWDEaHWQTmeQFwp8Xg92u5XRJ58iaucsbHZEUU0+naZalzg6viSXvsAXDKHXaakXUtx95x5j1LSVOsLRJTSigeWlZeqNFiaTmYHVhtUokMvk0Wr1aHVaKqU87mCMBw9uoV2MyM7neMJRDCYzbVmmOxgxGQ34+tEXvDJbiawuE1+JM53N0Gg0GIQFfp+LYDhE6ipFp93i+sNvoRUE4sEwzXIdi1lPLSVRLk4Jx1fod+rceu8D7t3cJZlIYrVasHvtjOQZmWyJmVIgefwaZzCCSh9lsZihVavQqmF//w0aQc/58RmixcHGjV2ylwkW8wVGkwnRKNCQqkwnQ5DHZPJlut0uc1nmzjt3qZaqXL99gytRT71eQ2F34nJb0Wt0fP35TyitLvHy+TfcfvAtqqUKLq+fuVpgvFBw7e49wv4A7d6AYb+LSqdn0O1hNesZdZrcvbGFRdSStZmJR4PkszksTg8KjRatYGAhj7AaRYbdNhq9iM3hoFat4PW6Gc8X6EUTy5u7FAsZJuMxPp+fbr/PWSLLoNvl/oP7lOoSaFSkM1mkpgWtaGChAJvDzunha6pVK6mzA5QKNe1Ol0LyktsPHjJnzpvXbzDaXXzv+9/hy69eMBqO2NlcZa5QodJpeP16j+mwR18xp1KqoJyM+MVf+iU0yhk/HDRRq7W8PjxFbTCwsRJnNleSTKUZz2TcwTCNbof05Ql6m52Qz0UxnycUjRGNLzEcTShkc+h0KvqdOW6HDUEJ6xubTKZz9ts9rpJJ/MEIofgaSrWGzqhPt9kg5Hcx6jZBoaA1mDAZzpjNFlycXuFwOmg3qphsVmbDDshTpGabwtUperMds92CVmul36oxn06QZQU/+fwRosFEOpHH73NjMoiYzBZ0agWLuYxCpWG6AHcwjNZoYXNthcffPGbvxQuuXdtB1Kq5vLhiMBjQbbXQKGRQKFEvpnzvO+/z4vUepXyGzWsP6LUbXF2e4A9F8fv9CKIZpVqNaBRBpaFZ79HtjZlMZvSHE3qjCWqliq2tDQbDMVq9kcE4g1Sv4g+5mcxd6AQDTauVQjrJoN+l77ETikbo9sc8uL2DzW7n8x//CKVChS+2xNnZId/57i/S6o1ZyAtq1QpGs4lWo8ECQKVjDFhcAcx2G2aLCacvhFqhRi8K6HQC89kEtz9EPnnBuNvA67CSujjD7LShUMicHh/T7Q/RanX4Y8tsrMYZDPp89Qf/RUj6S/UzB94v/dIv8Vu/9VuEw2G2trZ48+YN/+Jf/Av+5t/8m8DbT5m/8Ru/wW//9m+zsrLCysoKv/3bv40oivyNv/E3ALBYLPytv/W3+Dt/5+/gcDiw2+383b/7d9nZ2fnp1Ob/vxWKxahUGigUc6yeAP0h2D1hnP5lOq02o26Lq7MzHIEY6Tk0KiXWtnawOp0c7x9gMgjc2Npl/9U+tXoHbVCPVMvh8nvw+4NU6k0GnQ4P37nHC6lJr9Wk3R1QyRawupy82TtEqhfYuXEdk9FCMpHE7fPSatZR63Rsbqwzni0Q9Ab63Taz+ZxK6hyj2U5T6jDqTxGNVs4u09TLZSIr1xiNR6hVKkwmKwoFqOYzZtMJGpWGYqHA2evHOAJhnh6cMJ+OWL9xk0F/Qu0yyYOH93E4XXQHI7Q6M4JeYGk5xvt3dvn8C0gm8yiUahqFLMH779Ns1ulNZWx2J9PJlEB0CYdFx2g0wu3zYrfb8ASjxEJh3G4vZtUY7bs69k4z1PMFdq7doVpvspjO2Nxcw+4OU2yUKddqoFDgCi1xcZWk126xfe0Gy2tLHL9pIk9nSFKPT87PUC2UrMQi2MwiWp2A1B5z/vopUr3F5eEJhdQlH3z4AYLdzvnxEf5wFKVOh80fQCdoCfqDKCZjRoMh3mCU1Ok+1XoNtaCmmi2x/2KfQjrFnXc/ol6r000leefBAyrNDkZRj07Qk7q4pNWooFhoqVaqVMsFHDY7vdGE2aRP0LeCz+NEb7XQH47xekMEAmF63QGz6QhB1HF+cIBOo2I+mZHJ5IlEY6yurXJ8lkJq1TEvx+nPIJMvodHoEAXdW3cXmxuD0UK328Ng9VCTOmh0Amq1Cm8wSLPV5M2rN3z0nY/p9kYM+j083gCyvOD05Iz48goKlZZKrU4ln2F99wYnsky7XkOqVplOBiyQaXe6qNRatDodjuASo06XaCSK1aQnnyvQkNrkkhfoRIE//eGXSPUWkUiYQrlGtSZhtttQ6UyIxgluvweP30s+lUXQa3FYbbh8AdxOK1eJDKevXxAOedCLRtLH++gNeubyglw6Q6VcYMPtol6tMJpOUekN6A0CbpeLjtTkwcP7nJ6liUV87O/vsf/mBWqtgVLqHJfHglYvYLGIjEczRoMBNrsZo9nI3Zvb/OAPfp98qYRGo8EdCGOzW6iUymi0Ot69e5PlkJ9PP/8K5VyBNxCkUizSqNcY9TtojRbWdq8zGY853XtDOBTFJOq4vrPM5voKr14dolLrMJlNNBsNhuMpKpUC0SiSTGZYzGYYbFbMTg9evYFSuYbDamFjfY29V69YKFQMWnUcdhsajZ4bd26xu7NOpVZDrVgQjETptSQ0KgWhSIh2p4PX66XXHWIxW5AnAxLnpxjtLlqSRKNRZ46Cs8MDVtbiTIcjdnd2eLN/RL/Tx2gxYXXYKaUvkScBLDYbrXab54dXpBIJ1HojRpONbr+HQqnE5jCgE3UcHQ7x+iNkk0ksJjO9jsRgMGA8nVNKnsE0gtO6wXzap5AuEF8JY7FZUSh0CFotetFIp9tnARiMIoN2h+vXr7P38jX5dIJvffxdri4v+OabbxiPpz9TPv3Mgfd7v/d7/ON//I/59V//darVKn6/n1/7tV/jn/yTf/LTnr//9/8+w+GQX//1X0eSJO7du8ePf/zjn2rwAP7lv/yXqNVqfvmXf5nhcMjHH3/Mv/7X//o/S4MH8PzJU+aLOW5fgG67zZvLI7ZvP0CjAb2oY31jjUIuz3Q4oD4dMZtPGHa7SM0Wg7bE1vIWTrsFQa/HZJHxB32U85eY3UvU6hKX+69496PvsVComI2H2F0eHE43qWSWVq2K0qejJzXY+PhDstkcoqgjEo3SquXptST2z3MUs1ls/hDXNjdpNhtoP/pFnN4gl1dXdGoltEYbUrUKijk2d5DJoIXbF8BoFGmUKvgCPkJxDR63i+l4SEIvYDIZ8bucHB/sM5/JTEYTColjHunU2OwWRLONXCqJYiEzQ8Wbk0smaFjb2aVaqZFNnFFv1qkV0/i8AVrTGY1qlak84uqii8cqcuvOLfKFCq1Gi67TiajXcHaWJZUt0RtNaTaaHOy/oVGrIujUXLt1i1y6QE9q4N3c5fzgFRqNEZVay3whMxhPmUxl9GYnc9QoFWpqlSoajZq943PMRpGHm5u82jtjNl0gCDpkVPRHUyqNNjejK5gtFswWK/VSgXa1yua3v8/l6SUspiwUHRYDFbHlLfz+APVaDa2gZXVtlflURmbB0lKMdPqC1VgAtUZNvtakkC+STV6xffMWarUSlVZFvdLA6Qv+hbarTTbgp92XEY0W7j28xbDXQ+qM0en17CzdxufxMuoOeP7VpyiVagyiwNXpGWq1jkI6hdlqpZYrU7I66Pf71KpJJgsVvV4PtUpNryMxHXRodCW8TisP3rlLoVil0ezSrNYIBnzMF2rKxRIX+89xePzICwWNYoZQOMxoMmGuUjLX6OjPZFyBIGq1gEKpptuSsRgNnB0fMxqMMIo6TEY9ChYIRgHTwk6t3sRsshJbXaeUS9KRJFRqNeFIgFKxRC6bwdjuMBqPKV8eMrt+l0DIj9lmY4qCQrNLo96gVKrhD4Solmp8/u9/hE4v0qwUiSyvEwz4UTBn0mnTaHRodhpotFoK+QK9ZhulQsYXDtDs9mm2OijVSiZTGdFoIBqJUMyvgVpEFA1cHZ9gsVhYX1ulNxxjM1todIasbF3H1uqSy6RplMtMxhPU8oxy9pLHT4K0Ol0UOjXugI/p2MJcXmAxW1jIM64OX9IoF7C5/HSlJm9ePkIxnzPsd3H5g0TiS3T6Q9QGC2qNgs3lCPt7R1TrVQL+MIFQhIuTN0hSi3KhSK9Vx3/7OoKgR6uBYCjAWA7RGYwRRQN7e2d0B2M8Xj8qdDgcDnpSk1wqgTsYZjwec3p0gFKto9dqoRWNyHMlosmAw+9nOpswGY0YtesoF2Fu3rpGuVxl2B8wnc0RzSaMLju2fofbd+7SkCTq+Tx6jcDy6ipXFzLtZhWdaKLSaPHpJ19gtttpV3NMJzOmsxl2h4el9V0USjVut5Fazk+rWUOtuUZ0ZYNU4oLRYMD9B7f5yWdfM53OUDCnlCswsZm4ffMW7eGY0UhGEE10pDrVShlZoWA2B5fH9//7If+fUT9z4JlMJn73d3/3pzKE/1QpFAp+8zd/k9/8zd/8/9ojCAK/93u/x+/93u/9F92P3mjlwd2bxEJefvjFN8QDHkLRID/4gz9gsZgzGMl4gzECIT+FfA6N0oVoMlHKZ7l56wbLG6tcpgpYHE6C4TDMFag0erxOD8nzS2aTAZP5jM8/+wxB0BGIxrm6uMKoV7F17QGJdJF33n+frdUlRqMRh0fHqFCgVKjRKZWE3HYmUommVOf09IheS+Kjjz/kPJGjJTXx+f1YHB7cThsNSSIQDtOVRIaDMbVaA6ViQaNcpN3t4fZ4ubxMcuPe+9hddkwmM06nm9X4CqPZhPTlGZPRlEF3hNerIxx0c3na5fj1Hp1GGZfbQ3Rzk3I+w86NO+jNNjrNGgaTncl8jlKpwGWzotNoabcb7B0cUy1VaVbzvG430MpDdFoNSoUaFkNMDhs7N3e4OE+gZk6318NstlApZTGaDPgjUfSiBYDE6SH9loTJZEOl0aFQ62jX68iTCdHVddQ6gXZvxMHpJUdHe/RaVa7fu0u5VGR1fY3RdMpJIonZ7qAzGKPRKBENItPRELOoolLvojbZyF+d0ne4WAha0okLVtY3MZvN+IIBhsM+7f4Qtc7I118/5e69O4yGAyxqK4OGkXKhRKPeoN2oYne7mExnWF1e1FqBWr2JVqWkXS1RKNbJZ9Lk82XG3RZ600PkRZXJdMp73/0+sUgIr8PEkxcH7G6v0a5XePXsEdH4ClqFTKNSoNVooNYZUCoXhMJRAv4gs+mUWiGDyWzh4ipDKXuFyxdiOh0zHY9QMaZWLeKPxZmMeuj1FgxWJ+PJmEYmRz2f59bDd2AxJxSK4Pb4KJUruFw2Al4P/d6AXDKBw6xHiK/y4z/9AfVQhH63hdfnYwGUi0WsHj/bW5skzhO02l0C4SiFqoRWrWQ3tMmPCkkWkz4Om41Rp0fiIvE2H7HZ5GD/EKvdRa2Yxe11c+3OAy7OThiNxnhcLvqDAePJmKXVOKq6kWopRbdRZtDW0qzXcAUCROJxuh2JbDrJfD7G5/fx+uAAlVbNxuoKXreNrxoVXG4Ht27f4vAiizxXcnxwgN3+NimgO+gx6g/R6PQ4zQ6sDieVahOX18fJm6d0GjVAhdvjx27WsrZ8k821OG2pgdJgRaHSkE+eYHEFyBWKTBcKuu0OavXbyfRsrYxaI1KvVxkMu/iiPsIeL/P5hMV8hk4UkWcy+4fH6I0mzBYHAZ+PXKlKs9lgNpdptdrksmViK0Y6nTaKxRy720e/36fV7dJttSknTnEGopgsb6UWoiiiRslcnhMKBRgNJ8ynU+qNDrO5knKpSrmQRzBbscoyUqmI2+PC47JRKhfx+70sRYN88/U3tNstYqurrK2uMplMqdSaWL1h3vnwI14920MvmklfXjHod5lMpsTWNjGYbChVavqDLjN5wXA0YTxbUK9JzGSwmUwEwiGuLo/pDQeMFwoqlSqtegO3x0dNqaLbbmA2mCil6wRDsf+i5/9/WD/3XpryaIDBZGY6n2E2mXG5XIzmCvQmM/VsgmGvg4ySdCaLPOqztH2dOQrKxSIotfz4zz9DqRVwe/wM+31q9Rq7t29hs9lIX5wSDAWxWEw4vD4ioSD1aoPz9B6xlTjZdI6rgzcEfN/j029e0ut08QaWeP38Oa1GlZ1rN7DbLDjv3yPodXN0esmfnx7y2aef0mp1aRfTrC7HqRbLyOMOgUAQqVljd3MdrU5gf/8Uu8dJp9FAp1JhEFQ0GyUsDi/pbIlu65hILIpCp6WQSbG2s0tvNMXrdrEcjXB40EGp1NCSJObyDG8ghKjR0qxUcNjd1MpVvG4/U1mm0WxidbnQGI1o5Bl2jDy4sc2eLkmlXGa+kKk36qwsRUkl9+g3qxjMRvJZD712m3t3bhAI+jg5ucIXDtPvDek2W9jsfjLpKxwOBw/fvU271+fg8Dm5ywNa1RrOYACFUoteKzDoDmnXa3gdVrSrG3zr7nWq9RB7x+eMZCWJy0uWl5do9WXqpSYffOe7zBcqWgoFNlnFbDJh1G4gLWR0JvGtLyBK8pkkZ4f7BKJLHL5+iTcaQ9Aa+OrRK1SqOavrK9y1Wvn6J19htS6hcoXwBJwMuhKlxBm+2Apub4BOt4lSq2MxHaNkgdkgUO0oaVQlutohuasTltdXedPqsBh1WWiNnKcKzIFwLMLaziai1cbytVucvHzK/Tu7NNtt8vkyosFIqZBjdWuHSrND4uycQDzMjVs3Qank5PVrAktraDQ6WtUKa9dvojMaWVpZw+tycZbIUEOBVqun1+2w9+wpgVCE2XRCr9OiVCgyGsuYHX5maJjOBzj9AVrtDja7jZ7U4O6Dd6gUc5RyGdRagXI6iaCBXr/HuNsgsrHDYDTFE4v/hSONiFE0EIyF0aqV9NsS6csLjAY9OlGP3mwml82xWMDqxhoXV5dUimW84QB2u5Vub4ggmHAFwozHI+qVIjqdiAYlG1sbPPvmG1yBJVrNGtFolEk/xbNHX/GL3/8+Oo2SyUzm1d4huWyBUDSMrBJIJFKEl9d4cO8OP/nzP0dqNRj3RMwWG1q9md5whN2/xLDbwOUNMBpNWV1ZoTcY4nW7uXNjh5NkiVq1SXhli/EMOs0GE1mJ3ePD7zQSiYb58ovH9Dot7B4vyrqSrz/5hOvXrzGZzgjHvCxQUI+vEAqHGc+mlDN5vnnyApVWT1uqU8imiSzFUWpEcukc+eQl4XAMhbpDvztka2WVopxDs7zO0kqcwWjCYj7HF/D9RRZdgZfPJhgMBvKpBHq9hlK1DmoVy6tr6E1G7DYHqtmQdDpFtlglGAxzdnJAf/LWpD2fOCWjmKNQqajXSxiMZvLZAqf1Em6vl82d66QSSa7vbvDq9R7JsxP0RjMo5kwmUxQo6Q9GHLx+xXe/9112ttd58uQ5S6tryKMB7miUVrdPMZtD0Arsbm9gt1v4/If/nujKGhqNnmdf/vBnyoOfe+CNum3OLtPk0+fYbA5MZjPpq0vW4jF+4dvfolBvc350hlZnolYqEF1ZR2aOSqdne3MVt93MH//hHzAbDZhMRnRaTSZTmdl0RigSYPf2La5Or9AIeoxmG6PZAnd8i+BSkFFvwGQ4xGUzc3B0jkajpdnsUCvnMDtd2Dw+Hj95SsDnxeX3M9cY+c73vo9areXw5JzJsIfJ5iSZTMG0SyTyDt3jU05PL3B7PfS6bZQqBbPJjEAkikKrwux0MpNH6PU6kic5DHbH252rAm7cv8sP/+RPqKrV7B8dcXF6jMHupS7VUKt1FCtV7HYrgWgMtFqQZcbyhH6nQ72YQ6PXAzL1Qh6fz8+PPvmaYr2N3RfEZDHhthjoTRVEljc4PxjQljrUqxVEUcDpdfPo2XOuDk5Z292hlMnQabeoNltkL4+5+8679EdzLhNZrt+6Tb3a4OkXn+N2+2C24OTNK1q1Asvr61y/cx+b1YxO1DNTLChkrljevkOzlGPa72FQaTlOnRHxOxEMRo723/C3/tf/K4PxmOl0gNkgYrd7qCQvcVjNbG6uokDJteu7/Nmf/xCFLCNrVKQuT3D5fNTbI4b9LkvrqyzQMBy1iIUjmI1xTl48YdSVmI3cNJot1IKOwVyJymAm7nSztLxKbzxFp9GxsrpGo94gurzK0eUZNr+PbFEmfXnBh9/+ELXOwpMnLyllk6xvbBGMRlE3mownMmury/T6bcqlGna7DamWxxcJkikUyCYviK5vIM/nKFUaoivrON0BXj/7BqvFzKDV4uLwEIvHz0L51ppMKwhoBAOCaCR5dsJoNMNoczBfzHn+/BAUc6bTMWabje6wj9FixWDQsbG7Q7XRQCuIuPwBSqUSt+/dxWzQo9WLjEYTht0OU4ePVLpAPnlJo9siEltCI4iEIhH+6l/9Lp9/+ZhSPoPTF8Pr8eJ0ODHrtPQkCZPRikqtJRQKoBd12OwWXj99Rji+STgSIZvLoFHosLvcCDodHdR0Wm2WN7YpZ1NEgz7e/eg7/PBP/wSrO0SzIdHpvv00rBdUGAQdqVQRrc5KdC3AVJ6QOj0mFDUiVUv0O10efuvb2C1W9vZeo1MpqPT77KcKVJoNspki1VwG0Siys3WNl0+/odNuoNN56fdHb42sRYF2u4PKYGIuq9DqjOQrdVSzMRfnl3gCPqRaCRUK/NEoo9GYaGyJ4WTGZCrjctmIRKLsv37FZK5gOOiTSpyxvHUdmJFJpFCgZtQfMpvNMFtMDLp97BYbx6Uz9CYTJoudwaCHP7RMu1OjmMvjDwbJ57LMVWrarSxawcB4NGEx6rK2s44kNXn57BmRaBT/0iqz8ZjzvdeoBAOCVsNKLMTVtE+30aAr1ckmz+i3G0Tia5wdHhIIBigUsuQTCYLhCA6HDUG9IBLwoBP0+PMBDAaB7/ziX+HxN49oSl2sVju5xDmXyRyttoRGK2C0OjGa3dRL//n+yf9n9XMPvNVrd+gNBwxHY8wKBb3RgOlkhNUVI1/pcby/j9nsYDDo44nEGMljTl8+x+zyki2VmQ1HvPvhR/QHA1qdHh/9wrfZe7nHXDFn1Btwfpogl7xgaes6b/YPkCo5PMEovf4ISepw84Nv0xpO6PQH+L0iRpMIzHE4XPR7fYrZ5NukhXwRqVLiv/uVv0G91kS9GLO9sw6zIYFwlGu3dhiPprh8UYb9ARfHx+STp4TXd5iNJqCYkc6lGU9kHF43lWQKp8vJtNdGrdYg6nUspjOCvgDLa3Hq7Q4qjQa7zUHH1sLm8WAQBJ5984jbD+5iMpp49uwlKqsdq8lKbZ7G4/ayGo8x6Ui8+OpTTDYXkfVdYvElpEaNp199yb33v4PVasYfi6MX3gbQtls9EpkSOpWaO3d2SWZLlAoFbDYTPamKUqkkcXaKRjBzdriHy+2mVshjMIpsX9/l9PgYi9OGXq9CNBvJF3IMRg6OTlrUKmXe/+hj9vcOsDtc2Kxm7E43uXSMjfV1uoMek1GX0/Nz5Dm43R78fi/Vcg13aBWLK0AqW2E2n5PJ5lBrBJQKEHRqArElGuUCKoUKk9FMu9kndXWG3emmIUmUazImm4vvfv97qDU6tGdK9vffMJtOGHTaKGZw7dYtet0GxVaf+XSG0xcgWyijM1jweTwYHXZatQqf/Nmfc/fD7zEeD1EqQVZo+PqbZzg8PpY3t5jPZVQKBdsbK4QCPvJX5xTTSXR6kcUMnE4XyfMTmuUi967/IsVGhdlkhlYrMlcoWIr5SaXzHL2WmQ57qFRalFotw36PwPIGgUicdqtJ8vSA6MomAY+bz394QLMpodMbWNlc5/Iyyd7ePgDNep2w10FLp6Fcb9HrTvCYrHgCLo5NFor5JDrRSjGdRqfV0pLaFLNp3n//PcaDIZ16hdFkik58m/5922bBHQ8hK5W8ef6UuQyFbAZZnhJb+oDVzW2yqTS1isCcBZlMApvdiSdgZjqdkL46Q+p2cNvNvDy+4PIqi9HuJhJfwuZo4XS6KRSKuP1u9KJIr9tnPB0gGC2ISgV2bx+D2cr21hpfP3rG028eE156K8L+5NMvUBms1GsNAj4X4ZCPpXgE5DlDGXyhKO1GHavNwMHLl9SlJVLnp6xt76DUqVDr1IhWA95QkLNXrzHOlW//L27f5sWXn9KS6mjUKmDE+w/v8tnnTxC0elrtDlqNwJ2bu1xc2rk6foNCqSC+tU2zWsNqd2CxGHjx+AneyBImi5HXr9+wvbtLtVyhkDzHaDCQyVxh9S3R7w1hPie2sozUbjNt91ALWq7dukuvLyE1mxRyWcbdHqFAAI1KyenRCWtbN0GjRK8TuHNjh92tZX78+WOsNitbN2/z2R//Ia5KBZ3RiUanw+FyMTebCIUj6EUTg16Lg+MUlVoTwWDCYDAxX8zR6PS4HE5WV+L8uNfk+PVj/PFNBFEPc5lSLs1i9l/50Mp/bVWplelKNT748EPSuQKXx8fcun0Hj8dJ/ukzvG47K5vbvHj6Ao/LTrOQo1HM4Q7G3/rHTSZEl2JIhTzVqkSrNcYXCNNqN9Fp1HR7AxwuF16fm4O9fa7trrGzs8sPfvBDZiiILu3w+PMvcfk83L53g+ePX3Dz3jtYHT4azSY3HnyATqcjdZVGbzCTyRY5ePmMd9+5xdr6Ov/mf/t/MpypqEVCnB68QW+wE4nE6PZ63AiGcPldZC6TiEYjxVyaxXROvVggm0rw4FsfkE5laFSquLZ3SGdzLFQ6pjMFLamL1RVgPJOZyzLzUZ+tW9cw6PUEAkEO9o6YLRRo9CLnB29Tx3VaHVNZwUKlY/XaTbSikWG/Ta/T5Ob2GumTY4rFHM1ymVAkhMvt5dXT54zktyPqVoOOUDzGWCUwVwsgz9Dp9bCYYzSZMZlMuN1+PnjvNodHRxQrEtPJjEalQGRzF406RNDv49pKmHyxzP6zJ7QbFf7af/t9WnWJZCqHrFzm+CzB7fv3CAYC/OgnX2Owumi1OtQbb8fivV4fJ3sv35ofm/VUykVW1jZpdQY063Xcfj+VQgGpUWeh0JFMnOJwumjUm8xRsr659jbEdyozmYwplWtMZlNUKiUBrw+bx0fPYiF1eEji6gypWUetUjHqdekPuszlOdFwkKX4KsVylelwhMPjpVFvMB722bp+C6lWx2U3c/7mDfW8D3k2pFLOYTKZaZ5e4vD6iUVDiOa3zvc+n4+lcIinT5+wd54g5A/RqWRYW4niCfgZjh2IohGp08fjW0FqtgkG/KROD6hkLzFYrEzHU+bTMS6Pm2a7zc6N20yVChp1iUw6R6PeYjSe4PH6CIfCXJ0dMR2PuUJBvZSnWA1iNbuwOX3EPQ4G/SFSpYxSqUKrUeMLBChVqnz99SNUGg3R5XXMJgN7j39CV6oSCEdpNBrcvP+AyWBC6uICk91KpVJ7qwkV9ehUalRGC2U5j1QpE41HeHj/NuNei3K+iGax4Ew+odtqYRAFVCoN0+GASj6FWqHGYTZTLBUIeDyc7bdInBwgGsxkzvaYzTaoVSto9XrE6Yy5Qs14LlOvNNAbxtRKBYxGAYfNynA4xOly0+mPmU7GaAU9NruT3Xv3OXn9Cp/fSyF1hSMQYndngy8+/RFatYp3Hr7DD3/wfyDLc9QaEaPVxcraKsFYmFajy2WmiicQ4Pz0hPWtDXZv3iSdzaFUK3B7g2g1IqVCCUGnxud3cXp8iqDXs7y+Sq1UoVTIsba2gt3hxu/zc//ONR598YREMoFo0PPk668IxFcxmAzUKxVYyDgDEVQaDftnVwxHM0bDAYViDbXOyFyeIk/6RMNLPH/8mPlsgj/kp92SKNeaWO02omtbdKolNm9H6M9kCpksijlIjSZbN+6i1mu5TGaJh/2cn5yQOb9CNBmQGiUGwy4oFOgsDkw2O2try8zlBSjVXL/3kLTdTv7y2c+MBz/3wJsOhyhQoFCrGbRb1ApFEq4MZyd7uC12PvjOB3z61VO2rl3DbDHTarfYuHmfoD+AzWbgyRefo1Sv0u30aVTKvHj+EqZDQrEQGtFC6vVrbt5/gE6tYT4dY7X76A/H1Gt1tna28Tjs6HQquvU6p6cpDl48wxOK0OlMKBeSrN24g81lpCNVWV5Zx+/30IhFUesMyLICs93LzZUlGq0WfamBXjDSbde5OnzBzp17FJNplIoFW9sbDMZ9nFYn4+GY1c1NVGotNoeTWq3CaDqmWs5TTGepVGrMFxNsNjfDegGLxYLd6eH45AilQodKqSYUDtPq9SjkUjQbVTweH4s5XFwmMDkc6HQhipkkdpcHvShyeplAbzZjMBtp1RTc3N1E1Is8/eYb+lKdxKBDNBJmNB5xenyMXjRx/c4tJEnig+98zNb6Kl8/22M06FOqdbB7IyxUOsbjOTZ7gHgohNTpcnh4zLDdwmK14g1F0OjNHF7kaU8hdXGErFahVqqQmk1GYxgOBrj9ISw2Bzq9iX67g9/tIhCOMxoN8Hi8dHpDzs8vUSwUtJoVBIMBqVpk1G8TWrlOq1FhMRsSX9/m0aefcn52QSmX5c6D+ySVc87PLvAGggCEonEMRjPN+gXr1+4Sjfko1RvI8oJOvcag3UDv8pJMphjOwGQ10e20uPvOfSSpx3Q8xmS2US0VUer0xNeWqZWKeIJBprMpLUni8vyUpZUtBnM15USCVrNBexAgUS7TH/TwemIY7Tbc4RgqlQqdVsfz5y9ZWonyztYWT56/Zjae4LLZsN6+w+XJIYvpEIMgYNCp0asUVDpNbBYjD2/f4vf/4Ad02230ej0mi53l9VXW4zHkSZ/xZEIkFudCI6DS65gvZIqpS5r1MhrRjEarIxQOUy2VEA1GDBYrsa1N6uUyagU4bRaW13dptWpsb2/w5WefU5PaKFAx6EnYPA5KhQKDXg/RpUeh1tBpNhn0Gjj9YfQGkdl8isvjYzFX4A6EKOVS6ESRq/3XlAsVdEYbi2kHp8tJKZ/DE15CoxfQiGYEnZ5QKMj5629o18vMZjCTJygXU/yxGNVaFbVGTzgcQa9Vkzo9Qrl9ncuDVwSXVhHNNpq1GqLRTLFYZdB+ax24ff0mycQV6xurKJVKlta2iMZjCBoBk8XKbDrGGwgynfQo5IooVSKCTqDbbdGSJMxWCyq1imZL4trOKoJRTyKRJZ/MMB52qZXrVEpFep02docb0CCarIiGJnPmTCY95nOBfKmKrFBy4+591tdj7NutvH7+CrcngFalp5jK0KrUkOczapU8JosLtVqBYt6nVKqgETQ4fD4cTjdWp5tWo4lSMDIcTzg7OmRlZxe1RkswFsPtdnGZzDLtd/H4lygV0owmfSbyBKlRw7Szzu3793jz8hXybEIoEqdWLVMpFshdnhONx0mlM3RaDeZzGa1goDsY/Ex58HMPPG/AT61S5eIqS7FQxOb0cW1jg6vTQ8KxCIlsgVff/IS7H32fq2QKeT7hxo07dLpdKvUmN995l2DQz8XZGTaHE6vNhssW496dLT77/AvGfYmL01NePX6Exemj119wcvaGhVKFQq0ll82j1+pw+XyEwgG2r9/k9o0dnj1/Qb2UwWBxoJCnaDUaRJOeJ8+fkk8kaDWHZIstZiww2S1kCkVu3X+HWMDH0dkVsizTrEto1QqkZg2p08fpDiHoRDq9Ig/u3ESn1aFAQSwSwmo1YDQsI9VbhGMxSoVLKoVLPN4IRpsNqdkkc3lEaH2bvcNz+r0ukdgSSyroSxLhSJR3H97iJ199hUGvpV4sUEmnAA355BU6QWB5cxODxUwxnSFTapDPvqHdqhNd30SvN7MSD7OzFqFZr1FvtLhIJJGnI7pqFVrRRi5xicNmIZVKM+r3sDjt1HI56o0aTanDeDKiWsgwmUzQKdSUM2d44iso1Gp6gzYWtxu3x0mjkKVYbKDSiAw6EkaLgVq9QvbqktjKDm9OL6g12qwsL2EymdEbjBiNFmbzOQaLGbPJxnwOS+sbbG5tk80VuDrco9Pu4vIGQCmwvLVLpzdgY3OL3qDPsNVBqdEiiEYms9nb/DetDqUGul0JXzDCwmrF6w+QSefQG42EIyG6gy6ixUkymWdlY5N0MsHB3hsMopZcNkcgFOT2/XucJZIIJgt3791BJ+hRKtVU8lnkyZh+q0GzLlHM54gGPWyvxTk+T4FChVKjZ//wBFGvp9/tcXaVpNdpoUJNoVSjWivjDob5zoffotUfYDTqUapUOBxOBuMRFamHigVMJ8RicQb9AemrFJVShValhMVm5/Lyim6vz0rAh9lsJZ+4wGmxkMmmGfa6dKQGg06LerlPq+1CpVEhj8dYglaSqSytRhWH28VFIolWELEZDOgMIms3brMYj3jvw7ucXiY5Pjqm0+lQySfpNBrY/QGKhRqFdI75bML7H73P6fklw/GEtZ0d1Cot+XQStU7PQqej1e6gUmjwhheUKw1GoxHekA2p18PocPPuBx+i05v45M/+lGGnR7/bJBTwkzk7xmo1otVFyF5dYjeb8IaiJE+P2L55i5Wwh6tMjunYiYI51UyKn0htfJEI56fnKNVqhsM+boeVfK6ORrTwzsN7aNQqNDoN+XyZk+MjlpaWUSvnrMajHBwc8PrpM7RaHeNBB6/XT6VSxeVw4vF4+PKzNPblIIuFgmoxz3A0YGl9C7vTwRc/+Qq1TqBZPuby/JTpaIgvHGW2kKk3O8zlGaLJ9DZOajAkvrrGxkoUSaryg//9D7C6A2QyOex+LyqFjUIhR380YzwDt9PNdCYjL8BhszOfz1ELAnqjEUGnx2zUo1KB221jOOySujjDaLNRvDzkC+UCTzCMQqlkdX2TSr3KfA5uj5eAx0+r26GSTaPRGyml08xkmZk8+5ny4OceeJmLE771C7/I00dP8YeXUSk1PP7qG0SDFqVGpFitYnYH2FyN8UWxhEqj5eIySTGbxOP1odUKPH70DL8/gMFmJ3V6RjjwHr3hHJPdzS//T/8j+UKdF19/hUGvJBr10GzkMRp0NBpNyvksN+8+JBD08/zpE1aiIWJLMRLJFDrBgM3pZjyRsThdTOUZ2ZMjvvXxd8mXmxy9eUFka5394zPSZ8fY33sfs9mAzWHHE4ricgfQi2qUKiW76yscnpxTq9YY9hpkSmWqpQL1co2VjU3avQH1Ypml9U16/T6LuRJfIIQnEKKYSaFQKnAGoghqNbVSgeFojNvtp96qMul30RjM5Eo1PC4Xdqebaq7IqN9Cnk0QjRZMBiP1ap3D1y9pFPLYXX5kWUZntKJSapBqVfIGPTpBx0KhJri0zKDfoVVrcvuDd4lEIyzmHxAOuqlWWuy/eoHDasRhs1ItZqg3JaRGDVmWQQHeoBOjbpWDkxP6gxGtUha3P0S5VMPrDXPr3kO0Zidvnj2lK0mE43c4fPaIolbPeLGgdHWKIKhxum2Mex02tzaR2n0a0px2p06v0+Cd9+7SbXep12ts3LxFKVdBNFpxeTyU81k6bYkFSjRaFb3hALfJxHA4RKXRYDSZ6HfbuBxOelKNUaeJ3+PlaO+AYa8L8gSTUeTN00csAI/bRb/dwuZyIwgiHrcHQb1ALQicXybodVqkzs4ZdkdodGrk2ZDljTUquRImm52t9RUW4z4K5YKAz8vh0Rn9TgOrw8FCoyWfTsAclKgxWuzkzk+4EnSotAKDTofHz16j1Kix2hyYzWbePH+KxeGj3mgTWlklGI3g9vvp1CtMJmNGgwE6QWA8GtPuVEChAIWC8WTAZDYExYJ3P3ifZ8+eYzQaef/990lnS5xfnGGyWZAqRWq1KqLZQavdplGvEh3P6LclFLEodouZkt6IVhQxmww4HVZWtjZwe4KUclk+++M/YNzpMbaNqBYzLCZ9VldWcDptHL+WyKQzeINB9Ho93U6fXr9LrV5Dnk6Zn1zSrldwOhxU8kmUaoF2vUqxWODGtWt43C68d26jUmsYj2csrW7QbjaJhMNE13bwh8J0ux3adgcuj5+ttRhztcjK6hKJdBGDxYaCBasry9TKebLZAgrFgsdPXgAqbHYH5ZpEt92gnM/ija2jUSvodFt0pAYoZDw+N/3BkKk8J5XOcHWZRCHP6JtNXL91j4A/BIAvHGUyGhCOhHn3/i3KleZbofxsTmzrGhqFgsV8Tr/TIRIKYNBryZwdoFzMiEYitJsVmu022UIFi9WM1eHE6fXh9L812va4Qrx5+g2S1EOBguKwi0ZnRB6OGGtVhLwuark0mVQVVGpkeYzX6+Xhg2ssmNMf9FldW2Us1ak3O0xtU7R6kZPjI1DAZNjnm88+JRBbYzTooFGDy2ajXjGgVavYuXGD/U9/doF4P/fAs1utRP1eTkQRFlCv5innEnz4vV/i7PyCxOUFyxtb5PI19EYzSpUCj89LJZdAqpXQatTkU5fc/5X/gUePnzKeTukMBjx98hi9QYPRsoS1P2Jlc4fl7Q0anTbDyYT11VWGCw3J81NePf2G2soKxy+foFYokRF49vQ57//C96k1OnS7PWKxMNVahaWtG4TjcaZzBZcHLxi1W0jNBgqFEoVKxSdfPyN9ecHS2ibD/oBiNsO3PvwIqdUml01hMFuw2exoNWqGvS4GUYCFgvM3r5gOhkSXlrksHeHwuNjcvkYycYU/FODq9BgZFZPpjMGwQ6/dpdUsEw0HOX+5oN/t8eTrr7h+6waDwRidycLO/Xex2lwUs3mmswWDXgu9aGDj1k3WNpbpdrpIrRa9dothu4mKIKdnCQS9gclgzKTXw2gQcfoCfPqjP6fZHSK149RKJWwuNyurawwHA6x2CyazGa1aR6tSoF7IsxYN4YjH6Y6muAMR+mYDrVaH4WBGMpEiGAxg0aqZzqYYTSYuzy9w+8MIgha300OnUWP0F76K2cQ5K+sbeF1Wnj36CZHVdcaDLqmrJCqtjtTZMQ6bHaPZRLmQwWoxIU+HdKQ6KrWa2aiPMxDi4vSYyXiK3mhhMp0QXlpiMBzg8oTZ2YnjcTlxO5006g2Ojo5wuV2sbu9wsf+G9x7eJ3mVorxQMp4pONrfw+f38J1vf4Bao0U0WGgUK0jVAr5AFIPJgtVo4k36CfJ8ysX5GenLc1zBMCepEi2pg8XhQatVYzEZeZ44x3LtJj6f5y2InXZWl2P0RlPUyBSyKfyxlbcJB8UiSrWatlRnOBmh1igJBEPUShUKuSxGo5bxaIigVROKRHF4HJyfX7L/5hUff+e7bGxf4+LsnCla5vKCWDzCcDxk/+AVLm8Yh83OODTAbLPTG80IxDdoFNL4fQGGJiNHpyf0mXN5ekQwECBdlPjm6+e0Ow3e+Y4N1Do8gSCh5RVUehFr30QgskWhVmc+X6A3isijEUaDEZ2gxW4f4bLbODh3UcikUGlVmCxG+v0+Tp8fUTRiMogs5Dkv3xwhNeuMpyNEq51e623+m8vnZbaQsVlFWq0O1XyWQatBtVwlm8nRlRpcv76N3WFjOpNx+33U2z1klY6FUoXX58HrdrFQwHg6odfuc2t3m3Y0zDdPHjObq7A5PbiDS2QKZWbDDpOJjNXhZD6fY/GaWItHqVUqvHj2DbGVNZ588ecIZgc6QWA2V3F4eE632yG+tk6pWEAvGpkMRwgaFZ3JhE6nw1J8mfx2jX63i8lmZ+f6bZ5+/RPUTEhc9pnLC6xmE16HhVQ6T7fO28DYeJTRRKZSzPHOe1uYrLd48fQpz5+/xuOPkEp8yWB4xO27N2jlszRqDUxGgWz6iobbi2Bx4jPZCEcCWKwWjvfeMJ1O+fiv3ufLH/6IfOIMmzuAYrFA0GrQ6zSUc0kMJsvPlAc/98CLr21QqzVYqFT4Ah78fifl5AmNSoV2u8PSepx4PM6Tr76kKdW5ee8Bx29eYHe50Ak6ev0ewUiEZmeA1OxitTuYTPoMhx28vjipiwwHBwcYrDZOLpK0pAZ2gx7f5ganyTROt5/17XV0ei0XBgvDyYyLqytMdg8rKyvUas/QCSqGozEXh4csb+7w8tUB7WYdi9ePNxhCMBppN9tolGrcLjej3hCLyUGtfEm33SGbLVIpV7g6eI3ZF8FpdzIej9CLRgLBALOZjFarw2C24HFayajg+PEXqFQ6XC43WuUcZlOG4z6dtoTd7Wbn5g1WlqNMxjKuQAyL1UIpl6VcqqIXRaaDHkaTEQULxsMxsqBCodBitdtYjsdwmC1UimX0gpbJDDSikZs7a+wdp2hJbUS9QDAYZGs1RtTvIBON0js5xe+xUbg6JNeq8pViTiWfwen1Mex2KZeqhFd3sDisnJ6cYbPbiC9vkMqkcdqtvPPwWxyfX7L/5gVnyTQbSi3DVoWHv/g93uwdEdndxet0U5da5BxeRIMZvcGMRi9ydPiaVl2i35aYzmb4oksIKgUff3ifcuaK06M9XP5lqoUcw47EyrWbtKQGahUg6FFoRIxWB+1qie3tdbr9txKWi+NjJrKCpiThdJqxWyxEY1HURiPJTI6LsxP0Rj1niQzJ83MatTo7N29iVTs5vbiiN5BRK+csr6/i8PpQqlWMh0NiS37ikQCJ+DKteplC6op2q4nGZGU2kzHbTORTKa4SSRqVIoHVDcJr29SqDYxGEx988N9TbbZ4+kd/ys7NWwRC4bd2UoIGh8dLMBIleXXOoDdE0GkRBQ37r45QILOychOloshsNqZcLLDQqJhOJkSWllgs5kjdERqtgGgws0DFyeklXq+fRilPo9pAqRZYzIZs3rjDcNDDZtRjiMaoNiS6nSYqtZJuu41Op+Xi7Bi9KOD1Ojnfe0wpvYZCqUKlVmN1uCmUSoSW1rBZbRwcHjEeDjGY3IwGbcq5DPVa5S2M7j5k0BvSbdTpWZyYDHpkeYrNbsbp8NBrS6ysrDCWQVbp6HcbsFAym01pVnKolTpWlpbR6bQoZ2PuPnhAtV5BMBrRqQW++OSMZDJJuzegWS2h0ajw+vxcHLzBYHMwkuHli9esra8xmkyYTCYkcgWqjTpag4lJr0+rXkGt1tCqN9BrFty+eYNUtkS7WaVdLyNqVVjNZlBrsbhc7N57F6vVTr1eJ5VM0u20GA+72BxuVFotC3lKJZ9GHvYIRqKcHh8xHk/ptRsMR1MGoxGNdger3cFf+f7HdLtjfvyjz2j3ewSZM58NGA6nmE1GyqlzbrzzLVwWHeVyCbPdhd5oYjIeMZ1N0RtNuDxBZmMVBouTw9Nz3vvWQ64uzzk/ecPu9Ts8f/wNRpONTDZPsyHh9fuZTGXsbjdK9dtfQLPxBIfDjfWulW+++oxy9uJnyoOfe+C9efOaybDPyu4tFos5xXKF3QfvsVBq0BktRCMxJrMxHamK3WihU2/SadZY3dyk2ahRq1ZwbF3n6vySYb/NxvY2vV4HhdaISmtAuZizsr7GVSKF3++BHhSSV4yGY4r5DBs7N3E4HJweHfLuxx/S6Y842d9nY/sa+VKVZrOJy27G77aTsDveWlLVa7QqGUIbN5nKcy6Pj1nZvUG1JpFPXnD71h1UGgGdoMLs9KExWvA4jYSWVpkptPQGI/bfvGHYHaIzWui0m4gGC75IgMlsBos58fVtbDYr6csLLBYToWiMZ0+/werwYjI4ON1/g0KpoVmt4QlFMZhF9Ia32WsGUY/JIKDWaIiFQzRLRdSihcFgRLvR4knxEfJsjtPjJBJb4vTwBG8gxMVVnuM3rxAMRtxuGyrm2OwWavUauVyWj37hF7i2EaeWz3FyeoJOL7x18ljeRqtVo6RMNZ8mEvkW+fmIyWTCyekxw06bUa9JfG0VtU6Lxe5BpzPQ7nXRGcw8fvoEtdbIs2+e4A5GGEh12k0Jm8fPVJ4QXd/k2mqcZCpDPm9i3O8z6rWI3LtLodJEo9Xj9DvQ6vWYrS5UiyF2qw2HO8DNa2scHV2QTyWZT3q8++2PMQgC5+cviETjqFU6Dl88Qq2a05YqnPS7pPPrdDsSo16fUavD9rvvIGgFmk2JO+++y92bWwx6A7KFMsPxiF67QTWfYPf2A0SzlR//yR+j1arRCmZQqrj14B0Cfjf//k8/RbmYEvO5MGhV5JNJTCYzqfMj1IMh9WqNYjbHsJFja2uZy/Nzuu0WuUya+PoGgqhFiQqDXsfp4dvpRaVyTq83YDicYXa5kGolGu0uJquLUiGD1+dDrxPIn5+8fXnQapEqOfSCgFYH08mA6FKIsC9ILrODSqNkIitIXZ2RujhlodJQSUn4IzEE0cag18fictJq92lLEjani7XVOCaDnmwqQafdRGew0O/1WcznTLsSqW6LWSTGfDygUy7ii6+xkPXM5SlGswO9ycFgNEYlD1EpFqiUsLW5hkanp1orYrcYWV1ZInF5idpgRarVmY66uJbXmI0nGEQDWp0eQdDRH454/NknrF27STgW5cG9GxTKNUSzmWF/wM2NFWaDAb3egDvXVthdj/KHf/wJg8EYhU7gyddfIZotWGxWSpUa9XKBSHyJ2zevc3F0QLWUZjrts7x6neW1DXrDOShUVEpZjg6PMJtN1Ko17E4Pk/EIk1lPNjOkVa9gMhtx+4J0Wy3yh3v44uvYvCE6lRy37j2gVG0w6I9YXt2kkMvQrFcoZhJ06yWevjhE1BuZzxfcuH4Do8lEo9mkncri8Ac4fp6l3e6ysX2Nn3z+JVKjST2foyNV2dr+axg01ygVG1RqDRJHeyxvbpHOV5FVeqRqE51WyfbONS4SKQS9AQVwfvCKXqdDo1bH6XRgc3t59fhLXr18RWRpBZs7jN1u4Ojxz058/nMPPJfHxdleGo/LTOoyQ7vZYPXaDomTc0wGAw6LlVqzy+71m2h1eqr1JnfffR+bw4lW0JFJJlCpFAxHfdr1AqlLLdPBCLM3wGgk06jV8Adc3HvwDqJBR61Y5N47D5FlaBSzCIKaxFWCZv1txMjeo6/o9/tUvH7K5QJ+nxuNoOfw4JKVtS021pc4u7pkNlpBJ5qpVCto1BqquTyVzCUw58Lx9lOLLC+wOD3sv3pG2qjn4Xvvk0rlWV2NcnF1yd7TZzTqdZqVIk63n0Fvxv7eEXqDicjyOplMluF4iE3nRbmYsbSyy/rmOk2pSzmnZNQfUcokUSjVGEUt8rjLuN/h6uwYtVqH2Wwjm0yCUsXaepxBr0s+m2KhsFNv1IkuxYjHoxQKBZr1CqP+gGGvjTcUJptJ066WmIwnGE16LvZfE4ht0Bv0kdoDNnZvglqFSquhmj3n7nsPGfec1MojjHr12ziawYDrt6/TazY5OjziPJGhXq0yGo2oFPIUMzOu376JaNAxni4Y9wc4LEaqyXP61RKLWIT1nVsUSxUuLhOkr64QjCbWN3fYe/41B3tvUOn01Cpl/EtbtFoSRoedkNeGViFjspjZWF1hfWWZP/rzrzg/3id5laKeT1Mr5mA+RjRYEExWRKsDpTyC2QjVQsZuMuFcijGV55SrZdZX43SrGV4/U1AolGg3KlhcHibjMZPxCIPJiFqjxWoyodXpaLcaSM0WxdQVHq+by2SO+VwmvrLCRTJPIZvHG4rj9/noraxzsveS/MUJepOFRD7P671zNHojTp8Ho8mCqDegUqmppBPcvrVLQrkgf3WOLxpHOZtTLZXQ6rQ4XW7G8oKu1KBSyLC6sc2gP8YbWmI4GrNAjd6gZzaaEgj7SV+ecHx0wcnBBcVcntWtbWwOI+2Om+9//JBEqkQmW0SlUuFwWimV1DSLWcxOH/PFnEo+zVkix6AtoVQpuHn9OqdXSRSKBUGPA4Nug+cv3gCwuhLjy2yCXPoCnU6H2+NiypReo0Uw4Ofuf/N9Hj95zng0RqtRU6mUkaoVOjYHFqsZqa6lKdUR1Cqq5QKhcBhBo6KUz+PwhShkU7QbdYx2Lw5PgEq5SrnUQBTf7u7H0xlKjY5AdAmTxYBgMIBqCgsZtQrsbheNQhaLy4fZZGQujxF0Wtq1Gksfv4/VaOT5q9c47DbKhRSffjGg1+qhF7VvTQsaDRwuJ612j7OjA2LxGNVaG6vVjjsQQdAbWFsKEfBc5+lTkXS6gFqWaTUbHBy+QRCtVHJFQtE4w9GMyayHw+PFF4pQLJZxuX1odRr2Xr3A4fbT6w9QqTSE/AEU9x8SDAXodfv02hKj0QhrIILU6tBrdbm2vUmj9ojBZMrK1jUK2SQ67VudXbtRodUd0emO6HUkXF43giDQadWolfNYbE6keoX46jr+6BrZxDmolDAdkpNyP1Me/NwDr91u894HH719UGjUDNsSTrOFnPKth9sXXz9DL2jxePy02m00gshSLMpkOqWQy7G9vYte0KOyWwnF1wjGlkmeHNGsFFjM5xSTJxTzTrZu3OLZ1/vYHTbsHh8//MEf4Q7H2dzc5uTkBK0goFgoMdscKDQCi8WCTqPGtz/6iFZnwPnRFwzHA4wGAwaDiM5qxulwMxgMWVpZ5catm5ydRHn2xQ8pZfOYTDZuXFunM5xQyVwRDC5TzOd4+egTFosPGQ9muN0+bA4b09GQfq+L1eWiVS9i97gwWQzMRh0WiwWzqUwqccb6znWmCg3tbofoyiYLlR5PeJXl5SUsNjO1RpmZQkGtVsUbCJFNX9Bu1Ljz0XdptNqMWnWsTieFYgVZlmn1+hQbElpRJBwIM5srUSiVmExGDEYToVCEWNiPXi9gsjkpFErsP8/AZEhoeY1cNoXLE+DbH73HxdUZZrOBD977ZQ4vstSbLcKRCIu5gkazg8nmBMWCXreNwWhmIc9JXxzRaMVQqd0c7b0m5PeysbmBwWjm5Ref4nY40OsNBAMBpqMRGiVIUovhcIDVbkexUBBf2UBq9xj2JMIeLw2phlKlolAqc374mkdmI4LB8DYWSyswGs/RGW34lww8uHsHu9PJTzQCUr2J3Wrgf/kf/nuGwwF7J0nG8gyp3SMQjjBXKbj98D0O37zGZr9OrZjFKIp4l8K0ayU8/iii1cbJ6RGhpTCCYGA6m6LRiQx6PRRqNfJ8zunpOXqzA0GjwOWw0euOaTVbXLtzl6WlNdLZPKs372Ey6klnc8iTKYFwCKnTIndxzu7d+yjUOqx2G9ViCbUoIA+m5BPn3PvoFylkkvRaEsNOi9Fwwv7hEaJoYDAcEYhF0QlarDYPZqONXndEr92ilEqye+89HDYjZ0cH2NwepsMxze4QjWjEbrdy7841prJMrmBjpFiwubLMV4UsPanBVJ7i8gZpNVskUkWyl0m8oSXsFhPJVBa1WsMUDdlSGYPNiTccp1YukLpK4gsEaNWKFEU9RlEDCwXtXp+z8wSdXh+DoKLVbFGrS0iSxMbWDs1Wl1zqHA1zbt+/ySefdmlLLcxWM+cHrzHbXLi9bhQK+PrxC0SjEXkOqUSCbD5PJXXBzp2H1KMxKpUmosXOxsYy+/uH+OLLeIIhOg0JrVKDxx9GL4iMRgsWCoGFvODW/TvMpjP2jy8JBUMMxz26/R7D4YTZAmRZZmltg2goQLMlYbcYUKyukrw8Q6VSsr62gt3u5Pd/8CPW17fJ5aOcHDwlHIvRH7R58ewLlAoN29dvMJ6NyBfyCFqRbr+PQmtgNhkBWnrdCtPp2xe0reU4j1++QNBqCUciLEf81Cs1tBolk8mMg+NzxtMRgmhmKRZFJxpInuwTXdtBrTPSajdxBXxcXc44ef0cbyBCv91m++59mvUq7V6PdCaDwWxHrRZQMsfkdJK9qv1MefBzDzyNYMLqC/N6/5igz4PL/RB5JjMa9BAELc16GZUCTBYbRkFHtVYhX66y//wbBMFAMB4nnc0wm0wIx1fI5/NY7HaWXHYWGj2DXgOFUkXq8pxeq0FkdY3PfvQJxeQZJouVb758hNSocO3+Q1QocPvCrNgtFMsVrE4PxVqDyWRMt11GIWh4/eatAH5lfY1sucKrrz8ntrpBoy4xV2h493t/jdF4hNlg5v2HtyhWm/SHY1z+ABqFzHQyYu/J1/ijGwTjK+gENWabDZPVxkKhwOx0YbbamSsWdNodJqMJQ/OAhUKJ3WpEo1TwJntJKL5FvZLHYNAhK2YkUkmWVtaYyzKTyQSFTofeaqFRq3Dw5hValRan3YZT6UAhz7BZzWjUGhqVGkNJYuH0ksnnGA0GuIIhzo/2MJssaDVvo4acLj/Xd1Y508Gs3cJhFjiolMgnL9EqFMzmE9yBAMVGm2Qygd0bJhyLc3Zyis3ppHJyir7VRb2QsZgNtDsj1IKWRr2KQlZQTl4hqmRONGpyyTRbt++iMxh58ugZZqcNjUaLSinw/ofvI7MAWcbucFEolpFnU8yCikjYz3w+p1RsEI4EsTnceN0OyrUm5fQVWlFgNhsz6HXfuryrdaRzJTRqcLvNlLJZfvTp1yiYc3mZILy6gkqjYTKd8+zFPj67nf/51/5XksX22xgZs4l37t1AkhrsPX+B3e2kXCpjNerQmC0oFgsU8xn1agV3IIhULXD3wUPiq3Gkdp9IwEe32+fwUEW9UiMQiNHrDogtLxP2e9l78QqNTqDTaiG1JHr9Lv3+gMPjM6RGh2h8Ha1SSbFRYXltlQUK2u0O/Y6EJxBHNJoZj0eMe02m/TaVjBKLw87JyydEVjbR9510Oz3i127h9nkQdGragwti8Sgq1Lx4cYDD66PdbPH7f/DH6AQjSoVMJBbDZjOhN9swWcyolApqtTJqlQaP14ug01Cr1Wh0+hgMIn2pRil9RbVcxOZwYDJZQKGkVc6iNxrZvXOPRq3EfLEgvrpC7ocX1Ic9Nm+/Q7FQ4tWzF4xnM9rVPKN+l4cffozdYef0+AR5DuPRDH/Ag0E0vJ1kNhgZDfpEwl6YzxiOZNxuH+Z4nFqjhlSpsL0WxxcOcr6/RzWf4ebOKt997x5/9slPqBVyLOZK0tkEsZUVpvKC0/MzrDYr1WqZbx49wuGJoNGJ6K0WPEYvtXoFbzBCS2rh9HqYDtosRe9ReZbnJJvA5vShUij55LMvaY4WdKUmuXwRq8PFfDFFZzRjcngQzTYuzs/QLuZc31rBbjPz408/5cmjx9h9EfQ6Ne1WHUlq0G9J2L0BurM5qukUo9FAPp1mY3UVh8XI7u4Gmasz9l48Y/fubcr5NHrRgMkkINWrGO1ORKsRRU3NoN3HHBXwh6Pkz0/xe9zUinnqpTJ6gwmz1Ua5lMdgsKJSzpDqZebyFBaanykPfu6BV85mqFfKCKLI7vYmpbrE8bOnbO7eAJ3I3otnbO3sYjJb6TQbOF1vE3YdTg82l5veYMj5mycsbV7DYDRRzSTYvnkPt9vL3tEpy1vX8Ht9SJUS8nIMjSCiRMHN+++yuvPWJSGg89BqVkldpVheWcXisHGy9wajw4PU7tCsN1jeuYHRYqKYKyKa7RTKdRaARi8ynk159vQJnUYVf2SVfq+BNxLl6eEJ2Uwas8WJxWykUi7j9Ebwe5yEVtY5PT1lMhown08RDQYSx/sYRC1iyMfF3iEujxdvJML56QmCKNBqtajki+gNJoKxILJiwuX+AdevbdDtgJYF55cJ4uvbGEwWspUadk8YdyCARq3B4XSgUarQG8x0Om1UCiWT8YRisUx/oUYql9CLeiqlEq1GnU69QafTZTrs8dF3f4HBYEwpkea//W++h9lpZc7iL5zltWin0JPavKw+RdAbUS6mVEsluu0mvUEPtUZLqyn9xZSqmclUidHqwiRa6LYkHIEoOoMJq6inIgj0R0P6ozG9bguj3U4mnWBQbyAajaDTkM/mqFRrTEZdZoMe9z78Hs+fvUGlMWKxOymVK6i1IslsgXZngN3tRaGE6RysTg9KjY7Xr49Qa1TYXC7UGjWpizPOjo7QGgx4Aj5Uizm5YgmNEkLhEK+ePUcQzbRqLcrZEqHAEheJAtPpnJ3dHRRzGbUClpfXcLl9GPQaTgUF9XoD5Cmi0YLHbaPTanK4f0ZLkhj3BvTaLawuLy9fvUGlUSKKES4uLmjVC6i1BopmC+1antXt65SLebzRJWrlLLi8xKKbzAdOxlNoNdvMZzPuP/wWMipGkzHydIoSBTabhflsitNppZIvYrVZCYSCVLNhzHYHrv8Xe//1JFt23WmC3znHzzmutVbhoXVcfW/qRAIJkABFFauqu2jd1v0wZmPzJ83jmM20WXdPNatIsAgQIETqzJtXhxYerrXW2v3MQ2QiM0nWdHMGL4Op/XJ977PD4z7E9s/XXr/1Wy4Hd9c8OG0KitlKMVdhc3OT6XzOoNUhfXmGy+PFE4nR7g2ZpLNILHD5I8ymkLq6IhgKookas9mCu/fvEYuFkBUDVqcPj8eHrOhInr5CEgWCkSUmqkgueYVqtlDLJ9heX6XTHyKpBnb3trCYdLyslgmurWN1WKmXlimmr+gOBqzv7nL85WPanQ6yXo+sGpBEDavNQncw4eIqSdjvolmt0h+MKeWS7BzcJugPUckWSGbyhFaWWVlfRxTg6OiC3YODm3Kd8YT19WVeaXMKmRS+YJjJZMxk0EWYTUnGL+j0+swmM2pFA+5AiGGni93rp9VqYTJZGfR7HJ5cEolskE5m2PL5WI7FSGbyxC+umAxadOs5Lk/m+MNRpoMOnWYDndGAIslEolFMZhOFSp21nR2K5SZ3Hr7GatRLIZfj40++xOQP0O22aLbaSGjMxzOCS+vIFhufvDjDaLbijcTIXB6hN1m4/dpbfPrL/8zmzhZ37xzwwW8+IHcdR0KjnEtjNpsw6K1sHNxH1Kk4/RGsNhvra6tMFxqvnn+JLC248/BNzl49oVmv4XA4f688+IMHnj8So9VsYDaaiF+nMFstmIxGtnc2+fSzL2iXclR9firFPN1Wm5WNDarFAharDY/XR+M6idXtIxheRhYkZsM+zfw1jWqFQjrNuD+g22gynYyIbaxw9vIF/X6bew/u0W51MBoMvPfOe1RbbarlKvlcjqVYFLfLS3M45OjpE2aTOWvbO+hlPaPBmPFkjN5oYDGd4w9Fuf/gPtVqlVzOjMcXotVQUDSNcW9ENpHk4K6HdCZP4vyUOwf7bG6tc3KVoddpY3c6mQ67GA0mrFYrVrOeteUwTz7/AkGn0O50GQyH+Pw+nA4bMhqtjgFNkBAFCVmWqNVaaKKO60QaVVWpJOOk+yM0ILi8iqITqJXzKKrCcNAne/GKzYMDLDYzL5++whkIYTRbKA8uYD7DsqwnGIky7PW4ff8h2XSC508es7a5RbdZ5xf/8CsCy8sMBwPuvPtDPC4bisHEUjRGt9sllysyHQ8IBrzMNHjx9DHf+9EfsxiNKZRLCJKExaAx6bdp1A30mw1iW9u4vR6G/R46UWQ2mYEoMh50EcU5Pn+QRK3MZx//Gv/SKrVSBlc0xsr2FvHDI/SqiVGvw4QhJquN5OUFRqsNpdWj12yxc7BLu9VmPJ9Ry+fx+n3oBI1KuUy7XmFjc5tbD9+i3xswGA4xmk1El2IMZyLVYo5QNEKtVOCzz77AarLQrZV5/uQLDl9KdKt5/vK//+/wuN0kj49Q9AYa7T7jmUKuUuVgew23J0h/OEXSKZRLTYajKQgaol7PyvoKTreXar1OJnFB8jrFrVsHDL7/x4wGQwwmC5PRAKfHx9bmGpV2H9Vox+t1s7+3wVv3D/h//D9/hkGvR1UUTp8/xb+8Rj6bIhRbR0RHIpXF7/dxmczjCQZZ3dhApy0wmiw4LXYi4SDaqIvTauPw7IJcNk9wZQNJVpnMJuzfu8f9e/d5dnROqVgiElvBE4wyGAwxWh04A0sUywV64znVXAaBBSILXrw4pNMosX/rDoNBH3cgyvbeLnqDCW0+xo2AYrLSb7f57a9+w70330JvNJHJl7H2xuiQ0Uk67HY7sqxgNlkYDqZUSzV8kSjRlVWazQ4Ou4WQ342EwD/8/Od0qzWE8RI2uwt/eAm3z8Wg3yXgdWB6+zWePnnO4+fHJK4TVFIJtm49YDITsJicVPsFnj59gWwwsbJ9gNftZjKZ4HYaee+PfsIXn38BzNm6c4/45QV6SUI0qFRzGWRVRlWN+LzLvHzyFJcvyHQuIooSkUiYq+sEVqMJs9+P3mDh+vgZKxsb/Phf/RuOXhxyZ3MDdTIgEb/kc72RTDKDIN+UP4T9HkxmCwtJz96t23i8XtKZLFfnJxQyAqIAvmCUZq2OpKpcJ9IMO3VEnUilXGE0nuEOr2CzuZkDFquVQbvJw3feI5/J8ezzTzBYHSwmA5z+KCDSbtQoV6yIkshkMMDh89PrdbF5QoxHPaxu3++VB3/wwFtoU4TZkHfe/QlzBI6PDzGYDGhoqEYTvugK3W6TVqmEyWoncXlFtZwntLIFUoVmqcjm9j4ej5d+t4fD7WfnziMuLi6YDrr4fD6GvS7NWonX3nhExx+kU2+TyFWJH79Ar1cYjAbUq1Umown79+8ynk5RVBN+p4dKMUc5dcG4G0JzOehUCyQnIyTdAhYay6sbNFtNBr0eVrsLUYDZbEqlWMbpcBEMRPB7XLx4/oJhr8dMlCnWOxRLZWRZZdjvsbW9ReLqHIPFjtPrIl9rYveHcDqcmIxWXjz5lEGjSt/tRpBE5uioVOrEz0648/A1TEYT10eHRJdW0dB443vvcXaVpFEr4nXZmc8XyHo9Agvm8wWiTk+/22c4HqPTCXj9AUQBAqEQJpOF9dUY+qIOq92NopMZjYcYrE7q7S6eWAy9uKBdbzBstejUWlQyOUKrK9QbfarFPIuFhtVu4x9+/RGCTsHmChC/vkZezDl9+gXv/emPiUbDXJyeYTKoCHML2asTeu0whcQFsm7B/dfe4MXjL/mTv/g3FDt9jr58ysr6LsuxEJVmH5vFfCOXlmXMNhuj8ZCdO/ucn1wSW15iPptQzmaxmm30mg1GwxFGm4N+tUizkmdze5P+cEy/22P7wV121m5qAD/45W/Ip6+weXxIqgVFUZjPZlxcxOkPhtidbjY2VpnOh3g9PkxmM5980KRcbRANh5gt5nz0wYfoVAMOv5dMIo2qN3NyVcDjdVNtdnj57Bmtehm704HZYsHlcmO1WhhP5/hCyyQuzykWSzDuouhVDMsbDHsd8rkCohRh3O4x7TXoDj18/PgEFnMMDhtun4NW00X++hJJ0qETZQb9LopsoFWrIjNHlA1Mh30cDhvNeoPZpEupVOTsUiEWdJMq1JBNNhRLj2oxg95gpl4t4/G4SRZKlAoZJG2GtphSLeVQjBbyuTzjQY8FIoKoQzFYuDg5xW6zsL+7hTYbUsinEBYjpuMeC02gVKkznM65e3DAatiPTqfQbFTZXF1CURVy6RQGg4H9g12ePf4UnSqBJjLq9zg/KVOt1NnZ32EyGlEpFRB1IeSGAjqZ1994gM3u5eT8iieffEBweYOltQ1GowYLNB7c3adUyJM6OSWwFEaYjTh88im1egtmM4ajHrDgzvYWo9mNSGkyHlEuSCwWcybjEd///hssLa9xfnrI2ekJq+sbONxuJJ3AcDzl8PlzxuMJ5WIKTRA5enXIeDyh1e5itdvpjSb0ej2WN/e4ffceV4kMOlWlWq3hDUdZCCKdVgm700Zv0GY06vHBBx9jspnptJpIkoJqMOD1eqhW7BQKJWxONxaLlX67gSzqWF9Z5snneRboOHn6GXv33sToD/Llk2eYLRaarSa3791hPp8hqQpOtwdvZJVs+prRaMDS8iZ6nY5yqYDZbqfTqiMiYPUFKBczaLMpRpvj98qDP3jgBbw+DEYr8XSBRrVM9uKIh997n6tEClFUcQejdBoVQktLbOzswGzGL/8uy2jYI59uI8xhOoPzizjzQZOHb75DJlcCScfdN99l2O1RzmeweH0kkllanQGPXnuThaJSrxRQFJlqtYU2g7v37uDxOPm7v/nPbG5uE11fo1FMc/+d99nd3qJUraMaTOgNKrPZEE2bk81micfP0TEnsrZDOpnC5jTjcq/w9PFn+AJhCuUqo9mcwMoaa1sbVGo1Op0WqqwjsrqGqtcznYyxKk5CkQjPnr6gWq5hNFrIpo4wmEwEolHG8xnx62tu7d/CbDbx8vM5qXiCvqdLo5TDYXfR63WoliSuL84IL/kwm/WkkwX0ZismiwVtruFyWFnf3MLt9zIZDJFVPR6ng36vi6IaKBYLzCczViIBPv78MYnj53iWtm7anBhV/pt/9xd88eIE1Wjm4GAHZgsMRpXrZJb4aQubzUS5kKNRqRJaXuL9997h5bPnODwebt9/yPPHT1k/uMfa7j4Wq5VWo8mgbebWgwck3Q6mgw56k5kFCwqlKnaXh1IqjjQfsbQSpd9vU8rnsXsC1EtVGo06H330CdpigdXhZtjvMp9r+IIRhMVNH8HxaIBFb8Coyuzu7/PiyROCSyv4gyG6/SHH51fE49dIehWHP4okgawTaNWbFK8v0AQBQZvhMRp4/vQpFoeD3YO7VHIZQGCiSWQqDWwOBxabk2arjkmR8fl9REMhPvzVryikrzh4+DrrO9t88veX1Mp5RgMHJ+k40Y1thpP5jWXc6gbtVp3JTKZTq7C8sko47KNRbzAde3n99dusr4f59LMnVIsV2o0yDo8fvWqgWS0RXVnB4/FQLJZQFAWT2YTJYkPSKfiCAa4uOjx78gxtsWA+HRM/O+Ty7Jg//8kPmM5gOp2jscBstxOOxDDZrCjCAkGb8tqbr/PFB79FlmWW1tcw6CRknZ7PPvwVOrMLWafDarEwGmgEwkHsdge5YgUWUw7evM/f/KefIkkSDquVUibJZTzJeDym323i8TsZT6dkU0mahTR/8ePv89mLCwxGI7PxlEqxht/nZmNrg8vEBednp8iqmX6zwWwxR5svGHRbOJ02bh9sMBckBEEi4PXQ7XVZX1+nWO4wmWXoTxbs3jpgaSlEyuVh2O2jyBBcWSZxeoRqtCFpM2xGPecvLpiNx0zGM5zeAP7oGoVKg1rrhHG3g8lmu8mfpVN0h2M29/Yw6VUKqSyKUcXmcnJ19JJ0ysig3WY+neANRRkPRyxFg3TaXRJXcSqZNCuxKIoikYxfEV1ZYym2xsXFKVt7W8QTaar1m1rUei7LeDjCHQgxGPRQZJFRr0+9VsNodWCymFElEYvdzhyQRAlNEAgEwlQKGYq5PPM5ZNJ57HY77V4XbbHA63FTSF8zajeYDPuMNBj0OpjMZjb27900bLbZaTvdZC+P6DZrv1ce/MEDr9vpYDQaUESRi6MjXA4zBoOe4xfP0RtttNsdBv02r737PWSDkVdPvsQXXSUci1EuFGjVqpiMJoTxCKPVg8vtIJPOMeo08bhdJK8vqVcK7Nw6oFXKU8nnWFle4uToCTDGF14hnc6hW8w52Nuk3+9QK6TwhCJYO30GnRbj2YzjszNK2QyBUIBWo4nd7WdzfYVWb4gkiwQCHiRJYTJ5xbjfZmt9m+effIgkCrR7PdIXp4RWN8hnveTLZaazCcznlIpFUsMe9VKWaNiHzWbG5/NQKVXwBTxUSgmsdjcLxczRs0/QG81YXW4WkxEmsxGrw4bd5WI8mdHqtRG5sQOSFRG93kgkukK7OyWdSNCuVmjVqqxtrtPo9jk6+gCv30u92eD8+BiL3YFuMeXF05eEljcYTyeYjHpmwx4mHUwlPYNun89fXJJOZXF4HJTLZVqNLpKkQ1D0uAIh3A4LwmJBxxdEkUWcdjvTyZj5QsMdjjKTZPqtOo/efJ0nz4/IZNLcf/QG9XqTxULk7Xfexe22M53BYDShN+gh6kSq5SLVcpX5cECzXKBSSJNJpljMJtx++BpPPvmIWqWCxx+hlE3jW1qlUq2zd7CN0+Xi8iJOIZFi+2CPwHiO3mCk3WoxGA4osiCXTOEOhBFEGA97aJMJPk+Ia5sDh8PJeNjH7XIwm405ef4cq/nGlmwxndAZjDi7vGb39h1K2QJulwOn031z62CzsL1/h7Ojp0R9LgRFz6vPXTTyOfSrRpq1Ega7B5fHTT57hU1ZZW9zBY/dQsRnx+dxMZ2MKBYKTEQDbrNMqzbHoIOxIqNpYDCYcBiMRMIhUvFLrDYbImCzOqhWSojCAkFWUWSZ8FIQj1Xl/q0D/uEDI+fnF4ymc07PE2yuL/PR588ZDjqMei0W6BgOhvjcDsxmK7JOwRNcAlGhUsyhW0x58513ePjWu8QTaTqtNvPRkNGoy+MnN3Vc/VaDQDjC+UUSRW+kUi0T9AWQmJE4e0m5WqScvGLrzn3QmTDYnJw+f8Knzw7RBJFBv41XCtAop+k0iih6AyazC7Oth8FoxWQyUS9l6Lfq2OxOBv0RP299xuX5KZKgw2q1sLIcYTQYkM8UcTqN9Np1rntt7t7e5sXzFwTCUTa2d6g2GoSWV9je3ODyOs1GIEAwukSzVsHm9iNJCtvrW1zHjzh6+RkGkwWPL4CqNzAZjamkr5F1EqubO9gDQaxmC2arFW1PoNOoo+pAYs7OegxFXBA/P0Un64nFYpSzaT757W956wfvs7J7m6DfyWwxoVGvUinZWV5eoZTLoQR9HE0mtLsNltfX2Vjf4fOPP+K1d1/H5bBxcn5Fu92hWUhjdzow2ky06k0SV+egSbRqDfRWG7O5RimTQK/uEI4uIaExGXR4/a23ePb4c1LxM3SqCrMpudQQk9lCu1kFRJzuAO1mg/l08nvlwR888MbjAb6gl3q1xu7Bbfb2NshXqkyGfX7w3vco1jr8/d/9lONXJ1gdDi5Oj7l9/010sg5Jr3Ln0QNajR6dRo2pquP4+ILJeMhrr73JcAqKIUkgEsPjsNJutiklz/l8PqLX6dJtNxg0O0iKjNsfotkekMkV8EeW2Vhfp1yq0qxVCI3nzBcLHA4rG3v7PP30E3qdDo12n7OjQxRFYjnyYzRgOh1hNJg5fnWIzeFFNVlwenxU8xkkQWM8GmC1OujZhzAb4bDbKA+6rO0e8OiNt0jmKsgGEzu726yGAlyemhGQ0eugXa9hMtspl0p8+eGv2bx7H4Oqks8X8AeCrK9tUCrkWDnYp1iMIMgCo8kcp9OBLCxxcnoOkoAn4MPr9ZM4O8FoWMXt8vPr07/D6fFjs1sQJXAHQwg6A6FomNWD+9y695CT41OapQyNdgurzcrd3S0+/ewzCoUyNl+YSqlMt5RE2L+HPxBC0/rs7WzT6PYoVsqYPB5sigOj3kSl2GLQ7aMtNAbtDhenxzQLeWRFZtTr4vUHcDjsePwKk+kEnWoktrHD/q3bSNqcbqdN1OckGg7yN//r/0Iqfs7O3j7lXIrltWWqxQwLbUav1yKRSpEplUgcHdIqZ4mtrhBZXqFQKFMpFfAHIvjCITRBZD6b4XE7cLg3afdHlFMX7N9/xNb2OulUnvFkxkIQePD2m9w92CCVtdPpdbFabRRyeQ5fvECRRFZiyxwdnlCrlXC5nXTaVVSDiVKxRL09wBlcYjkSwOH1kbu+QFkM+Mlbe6hvruNy2jEa9OgkCUEUEUUBjGbctnU0TUPTNEK3YjzaCtDuDriMJzlNViiU80RjUfKZPAICVouJajnPaDim3WpRL5cZd5s3QgeblXwyTyKTw2hz4g77MFuMTCUFbbGgW68jiTpUvQ2D+ab79vHz51TLJTyhJcaD3s2XTbOFdL5GozMkGAqgqArVSoN2FfrdPoqiZ6zTUSmXuH2wT/b6nFm/i8V4Y22nqHp8/htRVa1Sw2B33fjILm9hsrtZj0VoVupo4x7vfv9Nfv2LXzOdjyllsuRTSTZv3yO8vMSo3+bh668jqSrxy2usThcb+7fJZ3JkcnmSqTiT4RBtNsPnd/P9H/yAj3/7W45PzlhZ2+DZk2ccHb5kPNVolLKYTWZExchCA1VvQm+0sry8ymiuMZhOsFhd7Ny+x3gwolktEI1G2Lp1l36vg6hNKRXzjEdjxsM+RouFYDTGeDTiYG+LTK5IoVDE4/OSujxHlsBoMmB0uem3mwz6HRTFwNHLY1Y2NtAEkWoxTymXo1oqYbTYmE2mhJeXabTq9Ds9XIEAw9mMTC5PPn7C8uYu/p1t0rkiYZuT7Y0dnnz+BflkEpcvSrOexxWM0hE0PIEQFqud5PiSi9MjHrz9fUIrGyQvLnB6/ZQzcWQ0NG3BfDohGT/HHVhCESVMeuvvlQd/8MBrVMs3NW+tHju37xENBfnlT/8TRquNmSzT649YX9vCH46wQECYa6TiF4wmQ2qFHAGPh2IuzXQ6ZGvrLi+fPsWgE/F47Pzq1x/hc9pYXrtDNplEUVX+8v/8fyESi/L82QmHX37CD37yEwqFMrPplH5/QCaRJRAM4rKZySTSbOzewun0sLe/hsmsMhjPCEWXUHQywaCP5LUK8zHxq2v0isKs02LnzXd5/vwV3/vhD7E6XMSv4jh9QewuD+3+DFG3QJXh4P4DprMFlUoeT8DPbz/8jHZvhC8QwO1ycRWPYzaa2NzZQq9IyLqbjtBzbU5oaQm33cnZ0THVbJK7rz+iXStzfXaE3eXB5fbgdNmJX16Tz1zjDkSZz+csplNG4xmd3oDJdEE+n8frCyKremaDHvd+8Dr5dJLjZ4+5OHzFfNbl9t2HzOcLqsUcsZ1bpOMXWO3um8a1FjcWBzjtNmRR5GX8EEknYjBZGObznF3GMZlNdNp14peXNJw9JoMhOzvbiJLMbLYgGAyzubdFKxTi6ugFbo+TyWRIvtgj6PfS6/eYDfsg6Pj40y+QmXP/0ev4PF5qzQbeUJgVvw+by4+qKmgsMFksxJaiyFvbpBNxjKKErMgMO3X6nQ6x5RWOX76ikUuymM4QxTl6WWZ9dwejSc/5+Y2N13g2olqvMT6e0G/0cLs9ZK5THNy7z0y7keMf7B8wmGtMpzMa9SoejxNREJFlI6sr61xfxpnP5nS7PbLZAusb62RSKRSLHVUn8Oc/fI2Hdw+wWYzIsowoiggCoAGCcPOam4Ub4IFOFFAUBavZTMjv5p3X5jQ6fRKZAm+9fgeDzcNnn37GYjHHHwgyHg6YL2Z4/H6WloP88qf/mflMwxMMM1tomFWVcuqai3YDs8XO9h/9KRaTkVypwGA6ozcaIRlNtKslppPxTUsvFnRadUqlIq1alejyCiuRIC6blQ+zGWxOG6NxH3dwGbPVhNt7YwDxwa9/jV4VsDmcVAs5OvUGjUIJXzhEq9Ykc3nGuNukurLMZDQCUWb/zm0m0xHreweEI2E0QaBerpFPJxAkaNbKtJs1FIOFarmKoFNZaBrz+RyfL4jNZSF1Fcdu91BpDMhkv6DX7BDPlNnecWP3Brk6ek5waYWZ03vjPhRc4tPkFegUWtUyVW8Qnd7M8fkLZrMR0dUo0/kMTVKoN9skr5M359ztRCcJeH1b1BtNKtUKC0GHqNOxuhrD6/fxy19+iNvrZTKZMxqOkQ0TJr0OdruBWCxM/DqHqjdiUIzodAoOVwCT2cTO3bucHl8wHOVp1xpIkoTV5mA2HtKpVajXm4zHQzRxQaNZYzabMJtrGA16lje3OH3+ku2DW/R6UQRtQc9q5+j5UywON/VKlV69QCGfYz6fEYgsMRpN0AQdFpudrYNbTMZbPP7w1zSrOWwOF81a6ffKgz944K2srKM3mqgWX+C2myhVKtQrJbZv3eY3v/gH2tU6b773PoJOIpPMEVhaxRMO3/hotjsoqgWH00s+G8fhdrO2tcvB3jaqSU+7UeHg1h53djZ4/MFvufXoES5fgCfPXtKs1Hn7/R8yXsAUjX6vy3g6wW63YLRYOTk7pz9osrS+RfI6jazqCIRdDHtjhv0hkc0QoqihGozoFBfTqY7puE+72+fs8ppiNkV32MUXjHB9fopisqEYLNQqJabTCa1yBpvdhTcURDWYsRgMhLbt/PSv/zOtUpKyx0cxdY3d6cVot9Ntt9l/9Aa3dle5vEwRCIQIBnwYbWYOn6osJCMWq+HmTn02Ztiec1rMI4sia+sbmB0OLg+fEwwGcdltvHj6jNlsiiAKJK9OUA0GYivLnJ5coSh6zHbInB0R29zBYbfR7PXwBcOMB0MsdifT6YRCtU6v18XucOJwOJjP5riCUbyhAHq9jMVqZm9vgw9+9QGj/oTRMIeIQrdVRxBnREcrVIoZ3O7AjdPKdIZiNLPQSUiSgCQoOO1WWMwQmdNu5NFJfs6PnjHstVjeOOD01VO+99YDHty9w//0V78gtrFJo1ZhMpmiLQQmwwF2qxlFVbE5PPiia9TaXa6uU/j9LnpNH4Nek0ZdZdwfMZmC1WakmMngCUUxGsxMun26iLSaNUwOG/12jfjFJS6X4+ab/GTKTJPIxi9Y3lzH5Qswngu0W3Uk2cmDN95kMIH45SWtTo16q43P4yDmUtmOubGZI98C3deAu+HdzRC+wt3Ng28AeDMRBRFREfG7HfhcdmbzOblKmyubgbFoodYekk9d4/b70EQRTVSxuT0sraxx9/5dnj15SS5xislsZdhsUk3FCYfDTOcz4kfP8a1skc3kmU26rN1+yEYsitUXJB6/pJhOYDQaKfV7JE6PkSSJ8aDLoNskn12wmEwQwkGWVlbIFEo0a3XCaxuYjCqxlSWmixmiTiEQWWY2H+EwKDhsJkSbAUmQqDdapC/PmE9G6M1W+q02FpMJg8GM2eoCcQHoiG5s8vzpU+6//gaTYZdBv0+tUmLQaSFqc1bWXuesU2c0m2Aw2pEFjZWNPbqDHtepDJlEEqPdjcaN6AxJwOy0gTjHbLEiC1DIpHAHglQzlxhsdjr1FsXENXqzFTQNXyjA+ctn1MsFNjY3uTh8jsXhRRJVdJJAJpvj7372a7wBP4Ggn92tNQJuK59++imKwYIo6ei0+zw/PCIaWeH48IhcLo3Z6uDJJx+yvLOPueug1+0QXl5jb3eL3qDPbDqnVhKQRLAtBbketylls7TqNRaAwWyhNxiiKhJmlx2dqmPcgm63i8VkRVZkTCaZ4N0HPPvsY1q1CoHoMonzkxsLQreH4WhIJl9E1esZTWcEfBGC0RiDfu/3yoM/eOBVm21W7Hbuv/4a+7vrHB6fogk6cpkypXQGg9VCvlrh+vgVJqOJd957m+t0nnatRnhpiaurM4bDIeHlNa4TWfSKAbPFSn845s5rb9NtVskUWzhdbhLxK47PExQTF6xubTMTFb741W8ILS8hG608ffKM2No6RquNer0BiMwBvVEhlc4Sj19gNBgJRSP0pwvOXz5nOJggTmZ06zVW1zbY3L+L0+di2G3QG4xInL6kmLggtLaHRY5gX16iXKsz6rUxW8yUc3ka5SrC1joGi42De3fJXF1itzuR12VsRiOXz75Ab7GxtLVPOlcncXnF2v4B17kyqfglaBpGixVN1PCv7OCwWhkMx1RyeXZv7TObg0E14osss7+zSTjo5+xQojHoYbE5USSZYrFIvz/i5PAVyxvLWN1emvU661u3MBmtFIpN+r0+BqOFVrVANBKm3e5gc7rwup30hyPq1QK7d+6ik/RcpXLIosQckf0HDxktdCwGdfYPtnj86RdMBz3sFhuTXp/C4JJ2q0Th6hKjy8NgsszFi6eIgoTV/D5uuwVfNMrazhb7B/tYzQaef/oxg9GEXPKKrbUwuUqL+NkZepMBvV6hnk9ygois6pmPB4ymGiaThXf+6M8ZjKbEL0+5c/cuoeUVGvU6jXqL9HWS4WSKNJ0hqQbajRoWmxW/P8hoOqHf6iCIAmaPH71Bwe1xsru3y+NPPuf+G29hfPiA08NDKvksW7v7IMw5f/kMSTWTz2QY9jrceu0hXped1zZ9xIJuzCYTkk5C07TvwO7rIfxzh0bT+M5G7ZvNgigiiwKxgJP/03/7PteZMv/x7z9hPh6iTefUy1VqkkQwtoI/6EdRFMwWx00jXr8PpzfEq8cfYxJnPDzYpJxJMVnocPi9xI+fEd1fI7KySrNzIwazuTwMh33MTjcOtxe720mrtsBqsbDQ5gQ3V4gtr5FIpDGYDcSPnmFzOGkvL5OOxzHpZRxOM51WB4NqJBAKs7q1Rq2QZ21tmUyhTqfZotloErLeCKviZ0d4gxHMBo1au0+90gBtSmx5ld3NKI16C0knM7JYsNuc6PUqik4iGAqSKxaZixCKrTGdTMldX2Ewm6mmkugUhXEwhjCbYnG66Pe7KAY9w9EIu8uBajCxur7MZNymXqphMRrRRcMYrE7m0zHadEx4dY1+s4Y/GEYQVHLFBNHYJjpVptdpM+p2QDKg6hVevjphfX2FtY0tJosZRpuTdCJLs9lDNdVZCBLx45e89vb36NYj5BOXbN17xKBepjhoYzYb6TTrGC1mKuUyP/7xDzGa9JTLNUSdjNMTIpdOkL86wez0MRx0YT5nPpujN1opprOkpyOmwxYWi55yv4/JbCEQXmEpGiF9dQ6TIW9/7x1OTy548eVnOLxBPP4IlWIWAQ1Fr/+98uAPHnjNTpuz40Pefu89/ubvfkU5n+b19/+EUDiKplNwBzy4HVYun/URLVYKtRZHX3yGNxTG5QtQK2RwBcJYnQ6yqQS9ZhuL2UC12kCRJby+EFeJBP/23/5rJEXglx8+oZlP3eRJFBlNW+Cy2Wl3u+QzSQxWG/1uh2KxTHgpSrvbRado2A0Wzk8zDJp1VEXG7fPRbreQRJnFTKSSTRKJLhNZXSURv8BotfPwrVt0ey1+9bdjnHYrK8urWOxmCv/wa0wWK81Wl6tXTxgOByRKTU7Pz3E6HLz+3vs8fvwcs83Kw7ceoBoVxrM5zXIOkOh3u/QGE5qVAgy7vPXuO9RaXa6vE0Q2N8nVqqRTWQ72brOyHOUqU+L8MkG72WAwmpDNlpghEVpeR5vOKBdL9Fo1ZpMO8/mQTCaD1WRi0Chz9OoZGaePfqOG3mLBaLejdLtMNB3ZbIVOq4HNsoPZaKKaTdJvN3F7g6Su4zj9fo5kkez1FSaDyp/+t/+GZqfPdDxk563X8fptLG3uYLcY2Flf4XxpmWZ3yGooTKeQo1Kuk7yK47izx7vvfZ+ZJpHPl5hO59x94z12djc49IeQLB6avQG+YBinzU40FqaYe4hiNDOdzmlUCzhcDhCmzLQFg36PRjHD8y/63HvtTaxmO+ViFeZz+t0Gs8WYUDiM1WhkNp3SbrXptlssLS1jsDlYzM6YLuacXySR0PjRn/2YSDjA8+dTVL0ebT4mFoshCALdRoug34NJL/Lii8+ZdPuEYg5iIQ9mkxFJkr6BmqZxQ61vzsfNiva76A60m7XfQU/7ViT41d6vrkJVVc/OWoTg//infLIR4tefPmd9Y5VGrU6+VKZV75ARC4xHN3kmRW+gkkkTDAV567V7uL1OzE4XlUKBmWZCb7NjNBhwO210en3mmoDLH6SUTTMej5jMLXzws7/DZLHiX91C1UEwFmHQGdCsFjBY1lnfPaBerVCtt9BkI/GTFwwHE8ZzDUFb0O+PsdmsFAtpiuUqdpcXk9XO/v4eHp8Hp9dFs5hnMxZgf/Pf8dd/9wsmGJiMR8wQ+fLZMdV8lv1be6ysRvnVz/8BncGMq+liZWOP2PoqeqOJ2QwSF6cMhgNC0SheX5jpfEq312VtfZtSPk27WsFssaA3GGg2GkwmZUxmC5PJnGg0xubmBovFjMurJP3RkFqpSCAQwLO6RbHapNXqoldsxI9fsBBl5rMJwViMSDhC/OqMejnLcDJh0GkSWooxHo4wm62EIgEMBgWH24pBmeOPRmhP5ixra+zsbLO3vsIvf/YzWpUS2nzGdSaLTtHz5OkRSALpq1P8S2uEl7yUCzomog6708WCBbXMNXqTGaPFQng5RvzsFXqrk2Kpis1kRptPSF1fYTAa8Ho8nLy4JpnNMEMjFFnB7nTi9ge5OpVJnh/i9Ad/rzz4gwfeQrtxv4jH06TOz7F6PfTHGkfHJ8xnA5r1FovxGLfHz9b+XeqdDrcfvU1syc9UEzmeDomGAgyHM9xON7Vcis8++i3l5AX+2Aq6e/d49slHeG0GxnONQibNH//xD3H6gpxfp/GFIgymczRBIhhZZjkSRq/o6LY7BLx+nj59zOpyBH8wzKunnxFeWiEUCGC12bCbjcgmB4PeAFVR6Pf6JK+vOfriI9Y3NykVyhTyabZv3SYUDHJ5ncDusCHrjWwEfTjcHuIvZzg9Hmx6mcFoTLVSRVho5BOXIEnIOolev4e2mLG2tk46kWZ97zZ7ezu8fPESi8fC9sYqv/zVb6mlE9y5fYtcJk23WgDxLu12l2a9zPXZMdNBi2ajxpPTUzRJ4eDeI6qVEoNenVv3X+N779ynPxjQ7474/vffZTEbc3V1QbNSRJYE1rx7VHJpqrk0Xr+PYMDP0y9LHD1/xu3X32D19n3m4xHT2eLGAFiSCLkcZM5HhHb2eHV4RiaVRBI0qo0ecyFDv9tmOh5zqiXpDieEIlEkTcDh8lAuVZlrIrlclYO9dXLFEh/88te4HFYevPU2v/77nzNbLLBZzJyenGKyW7G7Pbx8dU65UCC8tkkxk2JzdxuDXqZRr5HNJFleW2P94D7xV4/R5jP0eh3z6ZjZqMdwMcNqs6BTZUrlMsVsCkU14A9HuDx5idHqYmt7D4/bwudfvECvyEiySLc/4OziHLPDiSwsUIwGpvM5//5/+EsCAR+Ndo9iOsmtmJ31qA+jQY8kir87B1+h7iuY8R2I/e4hfGsX/KNdN3NN+M5cEEQcNhs/+eHb7O9vk23OkUSJdrfL3v42qas4LruDV69ekc/nUVQdzWyC46sEarZEp91lb/+Aq+trmrUqg+U1mt0BpWKe3a1NXnv9Fp9oGtPpgMjqMv1amXqlyWKxQFEUao0GifMLeq0a9p6fRrmA1+3EoMr4QmEcHhdOkx6328vnn3zMoNvE57ZTy984MLkDbYbdDtNhn+lsRjFfYDoakq52qVUqTOYCdpeZ/tBArzuiXWxidDq5vE6zJCnIskSv3+IqfoVeNeJ0mBG1OpGlZd58510GwyHNVhePz0KzmGJ5bYVKuUwwsITP5+EqnqTebODy+ImfvKRTrbAWDPLi1UtsLietRpN2p09oKQqiRLfTYGtjnf5Qo1wqosoGohsHtDpNOu0WlXIZT2gZn89Lq5LH5nCjadCoNTCaLNRyWWSdgNfvYzEXmWtQrjcZDSZMBx0Wc41Gu3fTXWI4w2oxM+wnUcZdsqkFgcgyS2tbVKsltICPYDBIXTUgSBKz6QKHJ0QoGkWnKsymM1y+EMPhkIViZjwZcuvuA85ODqmXi7z17ltUSjky5ye0O30apTzL27cRVZVBv09oeQ1vMMjFF78/HvzBA29peY1hr0u1VKA/6DItz5lOF6TPX/L2+z/AYrFxfHTMwd3XyOfznB2+4L0f/RiLw0Uifo3F5kAToJTNYLJaCcY20JusePxubu1tcLC3y9OPfs3HH3+KYrRSL+Xh7l2SqTSHz78kGl1hMZ+Tz5VQVYVsoUi/20XWSUiKwt7OBtVSgaJkQBJErG4vokHP5UUCs8WJwWynUa5itLuZzOaIsykGk5nJXKBYKlMqlgivLnNyckWv3SakxZBECYPZSTKdJ7K+SyQSxB8M4LAaySev2dnapFmpEr86pVIqwmzC8sYm3f6Y86MXbOzfoZAvUkxfY9rY4jpToFptsbS2iclgIhAK8Go+o1bO0qgWOD18ht3uQTEH2VpfI356itVhJ5fLkDx9hdVqZq7N+YePv6Q/g+XNLRTVgMXu4bW3g/RHUyLhCI/ubPPy8JQvZjN0mki93kIQRVCMlCpV9EYrFm+AXDaNLxzF6nBRq9dZ39qiWamQiV9htlrYvX0XfzhIo9Wh224xHM+4vjzFarWhqirXV6d0Ox1WNncwmiy8enmI2+dmf2uV+PkZp4eveO3t72E0GLk6P2V7/z6jXodaLsVoMKRULjMZdPB7vdSLaebzCc1Gj1zymtDKOtp8grCYsXHndTqDGSGn6aaB5lclBKpJj8dmQzeZkB0Ncbi96FQDRqsFpn08Thtmq43lzV167Sa1cpX9nX3m4wmDWR+LxU4mmaJUKPB02Gd9a53r6wwxr4XttQhG401k921BivAV1W6mX+XsNO078++Mr/cAgvBVVPdVdCggoGnfoqQgoJN0xEJeXPYRHz6t4vF6WcwnbO6sc53KM5+PGfSG2KMrOLZv8eT5IbLFzXw4RNJJGFQdqiqRy2RIXccpx495+OYbmFSVfrONZDQwngI6I9F1J0uRIMGgm5fHF1hsDja391AUhem4j6jTMZpMmY1H9FotHtx+m/FogqQ3ojdbCYSjbB3c5cmHv0Sn06FTjbS7fV4+f858MqBeKiDrDXRbTaaTCcHwCvVyDtlgxh/wMh10qBSzqKoZX2SV+vPP0CtGvJ4ACw0a5RqSpPDyxSHjqcBCgGGvRSGVQFVllla3yKUSjAd9rC4rlVYbTVQIre8xmc/Z3NgkX2mQSyex250Mug2uL0foDXpK+TRJpw2nN4TN6SRxdshwFkSWZcxWG2hTTCYDkfAKlycvuXj5BLsvSLda4v7rryNL6yQTCVRVR8Dn5aiY4+Xnn2C02smnrrk4eoGAxqDTBEFEUvRMJhO2Du6xtLxEOl0lGFunN17Q6Q5Q9Abmsypuh5NZv0O5kGPUHzLtDymlMuhUHRabBYPRTi4d5/T8FFk1MJ2NaXeHrO7c4pNf/gx/dB3RL1HIxtEZDfQ6FSTA5/2v1mL/otGo3RQW721u80L4EpvHy3Q0Zvf+6/zo+z+gXK1TbgxYWgoxGfc5HI+4uDjl5Ysn9Dtd9m7fJpVIUCkUcc7CuHxO2o0aj15/yFt3t8nkizicXjb39igUG3QMFiq1NonLQ1qlDJHYKrVKlWGvTTVXZzReotuoc//RI0ajAZ3eiOEUdNMZit5MIZehUS0wG0/YPNhHkVQGvRZGi4PpZMyo1iG6usHG5gbCYk67UWY+maFXZdLlPGsbqwzadT777TELdCxv7SHKKkfH5yBobBzcZq6TGE/nuIIRFLMFt8XKa6895NXxJRablUY5Q/rqhMV8gaColOttSsU8Do+PRDpHrVxg8+AeoUiE2XzO9vyAd956nZEGV/EMk5mG0WjE7gmgk3TUKkXiF6eYzBZmM43UPEM2nkDV67h35wE/+8VvqFTrfPDZM9qNFsHwEtubmwyHfV588QGe2w9w2V1cnlyQn80Y9bvEwkFEvZ5sPsvW5iaS3oLZ7CSbOmeOxmgyhcWcxajH/q3bDEYa6csTmo0qk9mCbneIc7Ygm7qmmDjh9DSATpZw+oNEBwNq9QbB1W2s7gCK0YQzGGU66OO0W1ksFljWNzDbrBgMRsqZJLdfe4tyLk0wFGAxW1CrlNBbXXRaHYq5NBabhXv3D5hOJuzu75LIlLh9e5/oUohMuU6/0abXqLGyd4t4/Irg6ib9XpvJaMDmnX1Uk4rBYGQ2GCJJEuVSgdl8xMVRivjZESajmff/3Q+xWMzIsu53+bpvUHaDvK9zc9/RpXzr9T/O6n0tZhG+kbR8a/3r6ddXoiIWk4Efvb7Nl0cJfv3Bp1jsLqrVGjpJwB8KM+g0mev1rG/ucHoZp10vg3qbR6+/QafdQ1ZUhhOVigCX58dkH9xDb9Lz4tmXmGw25sMOC73EDI1nz4+ZzDT29nbx2228Oj7F7nBz+uwJ3f4IvV7l+uQlkqLicjoRmSFKkMimaDYaBJbW2NrZ4ez4lPGgz1vfe5PlsIv/+X/6X6nWyty6fYenn35GOpmmUS0i6/V0KjL1YgaH086k16dWKeILBNneOyBfrKEaTKxsbqHT64hfnbNYQHh5hUz8CqPdg8HhI7a+ic/v5/T0nGGtTPb0FdljCasvhDgbYrcYmExmaJqINxBkMh6STiYwm5cwmh0Mp3B2ckav3yGysoqsyIy/aiOlqDrsNiNoC1STBbcvgNnmZNjvkykUMVrsIICqGJhORiiqAYPRhsfjRtLJWCwmAh4H+UKZV4+/wOMPc+9779Ou1VBVMyZzh0LqisV4QDZZY6HNmE2GdD0uAuEIg+GAQi6B2xPA4rBRr5SQJBGH3UU4FCQZv0DQKYjahLOTEwqZLIpeZXl7H40b4Y4kStx7812efvgPFPP/VaX5LxrFRAJREEjORgQjQSRRR6XdZufWAZ8+OeLl0y+xeoPU2x3cHg+P3n4Th8PJi6cvMJvMbGxv0eq02Llzi2gkxvHxEemzFyymQ85eHlEtpXn/Rz/EbHdxfPI3BIJ+ZOWm3Y1azOP0unC7vRiNBlyuu8ynY46HA8rVCtNChm57wBtvv0OrXmE66rG0uUm/N6A7qeD3OLFZnJwfmen3G4CNybCPy+XjKpFCJ2joFB2T8RSn04HJbCWXSmNzeoitb1EpFpn0+2TSA5LxK5xePxazi1IuSXRlCUGv54vf/gZ5ZYtiucFiseDdH7yP12vn48+ekjg6wu+0EQyFOH6sYjXpyWeuaVZq3H/rHWSjjce/+nsevnYfo8XG0ZMnDAYjvKEAqsHAoNdHb7HiV/W4PE7Wl5e4urpmMhzQKJdZXb8pv1iOrnCdTNIQYbFYEI2G6XTrVGpN1nYPsNqd9IY33p31Qp7xoIPXYcUgqywmE169fIHF4aXfqGJxObG5XBy9eIbTYuDP/tWfEQz7eHWSpJg0Ynf5aXV76E0DJHGOyWrF6vHR7TT55NPPMas6Hr35Bq+evaBUqRNeXid+dYVOJ/KjP/tXLC8FKVXr5KsNMtkU9UqB23cf0Wq2sDhdGIwWvE4rL58+xWUx0qw36fV6mG1W7B4vbruZcqnC2ckptXoDu9VIOZMl6PciaiLdVpdqIYvB5iCfuKTbKCHrBOxWC5PJiGhkCZ1eRWCBrBjY373L+voys04Fn8+Foig3sAO+Da9/5nLydy804eaa82b+zXXm7/J62jd5POGr5xp8FeXd/B7h69wfoCgKr99eR9BmXBT6aIJI2L/F0eFz5nOBWrmC0WxlPhkiIHJ8fE7F3WA6m7O+GWMmKjTqDcwmlY8+fYXL7cLuCWI1Grhz9x6vXr4knUwx6A/oNVpIokTDZqBYyOHxhTDZnBisDhRZhy8UxmbW89YbDxn0d/n1bz8k4PdjkqWb25HoEpqgI5tOUSzUMal6IktrtLs9jAYrW7fuUqnWsLocFNMJ3IEoGzsHmI16HC4b9x7e49mXjymWy/j8QTq9Po1Wi8VigayaCYSDbG9t4Hc7efzZF0iywqtXR/S7bRB0RFe20BYChVyK5Y11OvUq2XQG1WohcXaFzW6nVCjh83tZikVotQcUyw3moz46cUFsaQkkCbPRSCGVRlwIiNocq0nFaDCxmM3QiQJ6kwVVNWCxmAlEAnRaXarlLIPBgKW1LVRZZlHXUcgV8bg9GK0u3OGbvzVFNdHtJvjoV79m+84t2o0qTl+IUb+LxeJCpyrksjlcwymSYsLqNGC2uRGkIfVFnma5hDcQ4dFbb2EyWzh6+YL+VCSTTmNQTQjoyKYSDAYjeo0igrBg0F/CaLHjdP1+vTTF//0t/789TCYTPpedXq/PoDsgFgox6PUol8s8+fRDxqMeOkXkg1/9ilK9yetvvok/EMZo0GEwKYzHYwKhCHfvHWBzWOj2esiKHqfLTa1ept5o4nB56LQ76EQRfzBCq1Ejc3XF/Xfep9vpU8zn0etVJFlhMJ5y+9EjFsKC3OU5sihweX7Gs08/wOf1YjLokbQZB3duY7XaGY8n6E1G/OEIa1u7jDpNFvMJik5AlXVsbm/hcNoolwps373Pwd376A0G/D4P77z3LuFwhMjyKk6fi3atTK/TIx2/IuTzoEo65qMxs+mMfL7I0dPP0USZ8VQCZN7+oz/B6XBSKFbwBEKsra/iC4YY9Jo8/fi3XByfUMunyeayHF5c8vlvfo3X5eDu/Qf0exOK2RzDfo/pZMh0MuXiKg5orK6vYw8GKJTLNFotdKrAsNtGUvTMpxNCAS+CKNLptQlHo1jtViRZxO624/C4WVrbwO128v13H/HWu+/j9PoJh4KIgo5+u02z0UWUjZwcvqJSb6GqCrNhi3A0dNM6ZjHDoNwYBgsLDZvLjcXuRBAk3n7ndXa2VvGFw7TqRTJXhyymAyqZa16+fM6LkwsuLy7otVoYDbqbQuxSEYMssFhoTGczzpIpHF4/u1vbHBzcol0t0Gs1kGWVUr1DslBhMp1iNhoYjqb4vF5cLg9Wl4NOo8ra5i5up539u3cQEKnXKiQTCerlIo1qg06jQerqhHwmzcnhS46PjjDLGga9iiTdHOmvgaTxrYzcV0XlXz1F0/7pPu1m482zr/Z+s6ahfWt+Q0u+2vNtEIIk6Xj9zjZ3NnzMFgNMNgfvvv8Tbj96A6fHi05QsFpcNCoFatk8Rp1Co1yk2qhSLpfoVPN4PSFA5OzkEEkSmC40poIEOh1mVWFtfROdLJGJX1IpN2kUiyQuTgjFlhEEgVT8klarzVyDy0SKp0dnN1fpBgOx1XV0ioGjizj5Uon5fEGtXOXyMkUqHkfS6YlfJ3n55DN0sg6vy4PFbOXuvXu4QyFcbi+T6QKT2crmzj6NZgtZlem0qlSKOYa9HpK2QFhAIpWlO5jw4PU3WVtdpl2v02nWmQzaGExGFNWEQW8iFo2i6k3o9CZC/jBoc7TZAJ/XSylfpj8cYTQbEBYToqtLmKw2eu0Obrsdm9WM0+PGFwhRKjd4cXTJdCHQ6/SoVmssZhMKmRTFVIKdzXV8fjuyqjIe9EhfnjDotDApCuV0kl/8p//IxeER9+7fR5Y0sukUjXIFu91DtdhC1ltY31rnT//tXxCK+DAazQwGIwq5PBurKzgsZqrlAs1Gmcmgj4SAJCrUKnUkScUfjOANRbG4w7Q7TcxWB/EXn6FXdIjaAlnW8eDeLQ4O9pjM/qvTyr9oHDx8RHQpRqXepJiO0+oP0Mk6ZpM5qsnCgzdfQxLgF2fHHL54QblUotOswGzGrUdvcHFxRq83wGy2UszmSF+ds3fnARo6HC4nOmFBMlNAE2Vk1YiGQDmfYjToIUky5eQZZquJSGyNF0++RNNEFIMJl8uHtrrD3q3bjGYz2vUqRruLUr5A7uqMSDhCKpGnXqtwcOc27e6AZCLNwaO3CcVCPP38M+wmI6H9TbLXV7TrNaLrW7w6PKQ/GrK9s0snl6dWb9Hu9jEaDWzt3aZRbeD0hZhpEp1O/6Yrw2JEr99B0snoRHj69AXlQg5EkWQqT7ucYm1jE6PVwaxcwRvws7u7j9nqoJJL0qjWUS12JFmPJOuRRZHxsAfzISZVZmVthW5nQK1cppDPUqvWaDUqhJYiHJ4nKefSuCJRWo0W/Vadl0dneEMRnB4/x8++xOZ00mg08ARjhFc2cDmt3NuJUq23ePrlF4RXN3A5bfSX1jDo9QxGPex2G22bg4tEjkZ/yKDdYTEHVa8yHvRRFZlOp0vi/Bh/OIw/ECZ18QvSyQA+rxu9bCAY22RvZw2H085f/8//gX6rhd/j4uLwFaJO5d7rD+hZ7WTzJW7f2qVQyNNuNDk/fsl0MsZuc1KrVQiEonz//R9SqNRIXJyTS6cYtOvYzAYUow2ny4OqN3D7weuUynVYQMTvZyGrXF9csby+idGgJ352ijfo4uHd23z26cfE43Gy2StMuhnWW5HfXWV+d/zj2I5/JFL5L4/vvNW3okaBr7Qr2ncyg//ozTUkScfBeoR6pUyhWsRsdZNJxDGoAlv7a5TzFeq1GIvZFI/Lhi8U4tOf/y3OQAhRWPD0k18gKXqsLieiaMSgVxh2+jRLJSwmK4Nxjul8QnRlmelMI7C0QT59ibiYEI0uM5+OuKjmSV1cIgki2XSS3Vt3CflcnMYT9IYdQrEVZtMpBoNMu1JAnA9xBiLMtAWKoKGqepq1MntvvYtOvbFJ6zTruJxurE4fIcmNquoxGM3Ikg69qjIbjdhaXyZxPWdzbZlGs0m+UCKfuMBktd5Y1d06IJ24InN1zmjYo1HO8vTxY3SiyGg4YHtvh7tvvY3FZmHYHeAbj1gK+llbXeby/ILry3NWN3copZM3HrR2KxabmdlkgSCZqNWqDIcj9HoFf/CmyfLJy6fUaxUGoxnT4QhRAJvLT7WYxxsIYrSqBJZX6TUb2FwuqtUGqk5FNsn0DCaarRrtVpPJcMDTSZeV7R0a9Sq1ao3JdIzH7yG2GsNoMpC+vqDX7dDv1JAVI+VijlajxrDfxuWysroU4uXLQxaCxNbBPYxWOxaXEwSN6XCAqui5c+8RycxP/49/2P8fGH/wwMsVMjeemM06kdgyg/GE1954yOl5GlFW6HVndDo1XIEoik4hl0zQqeTZefgatVqLdDyO2eYkkbjm8uUzjIrE7Vs75JIpMFhYWlqm3ukBApv7+4wnY249uEMgGiEU8DDuRGn1h7h9XqwOB41KlU6zTKfZJhRbw2g0M+x0iKzvYLNZ6PcGVHMpxtM+yfM4NoeDYMBH/PJTavkUXreTxHWSdnvA+uoqs7lApzNgjkA2kyOXyWC0GmlWG+xur5G8umTQ7bESu8t8vqBeTRIIR6k1W6RSaTyBMKHo8o1juc3FAvB4nZgMN41S1zY2MEkBzk+PaLYHFNJxlrbWCYYCXF6lOLh/H5vVxLMXh+gtVmbzGeVanaW1ZbKpNEazncFwTrVYwGy1EIgGmc1FvKEYDpuJ66sE9WoZm8+PIs7oTkaMhkOajSYLTWN58wCX3cSnH37EoNshthxjNuzzH//qp+jNdpKnLxhMpmiLKdJcYuvgNrVWFbfbyiAYZsGCbm9wEz0U8kxmcwxGKzajisVuQ2NBvZjn/sPX8Hq9PHv6nKmo8OyLL5lNZ/RWlhnka9icbvyhCMVaE7PDw2gwpFnvch2Ps76zRapQw2DUI6sqLATqxQKtcJ1OpcJoPOTkMkUunaKQvGB96xaysES300Uczzk/OSS6ugmCQK/TRBQE4imBUW9IKXVFcGkNSZywtb2Fze1gosHK5j4zTWahQTDgw2AwIEk3x/nbOstvyPYt8H2jNfnmBvPrZUH4zlXlzZKG9k8g+VV27/8NODVAp9Px3pv3OU+VyHVmaIwpZq55/a03mU3GTAYd7r/1DrV2B7QFP/yTP2H39i1avQmf/OY3mIx6Du7e4/DFIaNBH6fbhaAJtCpVfJEAw04Nt/sehXyFUi6DL7SM3eW86RtntSHqZKqlAivb+0SX17k6P0evysyGbarZa/zhMFaHg9T5KXpZ4t3vvU69NSRVqGC12TBb7jHo9XA6rEwnE6rVMnpVpZBNgKyj8PkFNqeHciqO3WzF6fTS6wxIZ3L0+iOGoyFOpx3FZCCrKPQ7LRxOJwtNJrayjs/rxut18fO/13NxdsrunQf0Epe8/PIz9u7eYTCe0RtO0JstLBDRNAFR1hNYWkcTRVzBCJ12B0Enoah6HA4r3X6XmaDDaLbTa9fIpNNYrUa6jSpr+7cYTqbkcjmm4yGbm1t0QmH8oQiz+RRfcMGt2/cRWFCqNhj2etzZWWF3c5UPP/ucjd092q0umasTFNWAwxckm0qgzaaMBy1q7Ra1Vofg8hpul5vz45ekr05QDCIaAv1Oh16rgjcQJhgMUs5mOHrxGEknMBq28HgDdKYTcvkil/E02avTf8nH/f/u+IMHntNq4vrsnMV8iiyvUKqUKBcXJC4vsAVCdDsdUleXyAYzAV8Eq0GFlWVCqysMR2OmswV2q41weImwz4usyLz14BZndjM//enfM5royOevCYdjKKJAtdbAoMDK+hrnZxfIOpE/+ckPaXZ7tBstxsMRzmUXg14fq8tNplwgn0nhcvsxGlUqxSLB8BIGo5VANIZBlanVqgwGY3SSTKfVYC7B/v072LxuBlMNTziGaThEFEViq6sMOk0qxRx2k8rW5hZOp4OlWJQXL89we3z0ex2m0wn9RommtqA7GCIsFgTCURazBaPRgmg0xnI0it5s5OzVgOjSChube2QvTxl0BhTLNUr5LLGNTQrFPOmT5zgja8TTOWSdDlVVkXQigqRxdX5Nr1HCEw4xniyQZYHpYsInv/oSncHEYjpCJyyQJA1JlhEkPSw0RoM+OgG0xRxvMILD40GWQDCqiHoDGiLr+/fQOxwkLk5RBJlsJkG/20GcDTAYTMwWMGxUMZvMDC1Wes06vV4fw+Y2eqOZO299j2qlRns4ZSGoyLIeEFjd3uLoyWNSyST9Voul1RhLK+t8/vkXeENhGM3o9fvsHOwxns9JJFOMJ3MM2gyz3cm6y8P23jaKtMuLw2O67Taz2YjZdEg6eYHD7WfUa2D36mmWspjsdkwmK/nrS2xuD+NhH7PVjYCOq1df4g4GsVsMBMIBzuPXdGpVRFGHz+Un6HGgKF85qfxOSal9h0+/U1x++3D8M8Hf11eY4j+z6R/Xo/+X1m6uS4XfAVWSJLaXA+hKLQ5VI+sHj3C5ndTdNXSChM2ssL2xxemTL4g+uIvZaOPF0XOMFhsbWztM5yJGs5nE5Tl7D14jtr2Nqiq4HDayVhc6xcjy6hp2q5WTw+eEYhFAo9ds43QHmTknaDoRRJFWrczFmUSv26FZLPLqs0+Irh9gMdpw2WVevXzB+ck5kc1dbEsBspk6hWyGK6eTxXjAaixCKpWlUS6jN5iQvRKiBsFwmFI+RUCI0KlVSF8esXH7EYVSBUnRIat69KqKIxIhnc4gCBJ6VaDTbtHtdVFUFYvdhSYqRLZuUc1cEw0FUBSFX334OYpO4ezsErvTxemLJzfdKwwhWu0elWKZOQGG7To//st3GAzH/If/9HPqtQoefxBJd+OGZNDraXd7DPMlWp02vVaNvTv3b4RppRKT6Yx6pYis6Ll9sEN/MqbXafPy9BqdKjNfaOhNRqaLmx6DstFGLBajWCox6rSZjoa8ePwYg8lKNnFzDqezBYIgYDPbEBQD1Vya2NYtdKoevUnG6nIx7rSJxDYZDMeAxPbeHqdHh4iqik76/Wbd/uCB98aj1/D6ghiMJsJ+Jx9/9oxGq4UoiEgLEW0xoVHK4VtaRW8Q+cF77/Hk8Ipms8d0OubOwzcwGfS0OjffQG+txvjs+Smvnj8FAUwWMya9gVIuRWI0YXlllXQyTTpVYDoZsbaxDguR45fnDAZDHB4/ok7h3XfeZDRZED9OUS7kUHQWKkKR+Mlzbj96m0qpyqDfY+fRXRrtLpIis3frHtHlCJ1Bj2K5QDbRod/p0htNicZWUAxGFEljYylIodzg1ZNnvPX2G1itjpt+VnYTg1mAXqtJ0B+gtb5FoVxgY3uL69MTssk4nU6bSqFAreTl4O5tro5PqZVy/MW//284eX6ObDDx4NHr2K0qL758xtVlnNGkT3h5jdBSjMvzMwIrqxSzSexON3NmzLQ5kc0tbA4rTz7+lGBsle3NNSwGmelkiiqBPxrjk49SdJsNYltm8rkU/XYDbb7Aarei6s0gSZQKeRwOM55ghEqmSCS2hCcQYNjpY1VFNDTGY5lapcrqxiaTucB18pI33/s+D998E7PByC9/8VvarQbhpSVsLi+D6YRiuUB/PGB9awe700mz0UIWJQ72dmm3myxEkVang2LQUSkXqebSpBM6bj+8T6NeQ6cobG7vUSwWGPaaWBw+2p0OiiozGnYwOzxY3T7GwwFOo4G5TsFiCrGxuUP6/IhOIc0f//d/iduso9XuYXV6WGgCO/ceMh2N0FvsVGtFTs/jdDtNms0esqhgUmWcdguyTocofAtrX4tRvjoH366sE74qHP8ma/d1gfl3FZg3xed8F4yahvb1z371/NvQ+/pH+Coq/Pr3i6LIisfCdsBGsjZhNJizsr6BqDMQPz9mZXmNQGyFDz/8CLM7RCZ1jSpprKytc3YRp13LE4iESVxfgSji9QcYDIaEl2IshfxIooIiitTDS3SbLTy+MA2hyng8QKfTYTUaqJZLhMIRfvwnP2I0mfBXmsZsOmF1dRlV0lPIJmn3mowXAoVUiqVIBLNRz3jQ5cuPP0SbT9k8uIWmaTg8fhaTOaqiMpuMWV7bIJ9Ns7a6hE4Uef5ljflijKgzUSmXGI+n3Lv3gLDPTbtWRK/OCIfDFAs19IpCKZtBEuaIaORT10jTLuPx5CvHmTzrOweM+l0Mqkx0bZfpZIhe1jHuNCgnTrHYrTi9AX776VPu3Npla2uNk8M+c2GBIosMu21Wl5b48IMP8YXC3L5zj09+/TMuTk8xmM3kry+5++b36bebJM7PabVaTEZdjIoBu8NLOpWgkLhkPhvjDUQYD1r0BwOyxTLj8YDpdMT63l3GoxGIIktrm3QbVe49uE/SaqRWKeELRpDEOdPJhEqtidVswGy3I+tUVLMdq8dE6uoMxDJGi5XJeMTy9l2yV09+bzz4gwfe3/7t32GwWNnePeDp4RXtTh9ZpyMQW8PpdGOyGJBNRn74o/eYa/Dli0OarRH1WhlZVVld3WK0mJJMJfD7A7w8PKFZq3L7YJ/BcMznnz/F7nVRSSUx2u2k00lquTRmq4vt2w+ZzDV++ZuPyV1fEtveQUAjn02ytRZhZTnA1XWWYq5As15Em5lZaBr1Zo3FYkH++oxcJEg2naFaqWExW0gkEjRqZbrjCQ6jgdlkRCWbRERgMhlhNpuZTyakrq6oFFL87G+rxDb2SJ4/Z21znQlGnJ4op+fX9EYTVta2aTRazCYTnE4nvugSzWaN9Fc92tIXp2xsrnF5GeeDf/hPqAYz2UKJQkXHyu4tbHYbgrQg5HWj1+vRNAGjw3XTALbTZ2Sd0G9VGbSrvPPDH+K0mUhfnmC325ksNAxmIy6rk3q1jd5o5867GwQDEfK5FDpJR2hlhXAsQi6RRJuOWEwnjPtDzAEV08YmyetL+uM5k8mEe2+9hU6S+Ojxc956dAdZJ3OdKTKZTWl1euhUIxaDiqIoSIpEo16h1uhiMspkMnHQ5iiKDgFIX50RiUZxOZ04XU4uL5LUOnXmowFLWzvIskSjUkWvGlB1MtlkEt1ijt7hYuvgNjpJ5fzsHElaEAiG0USNbDyOqpPY3r9Dt98jk7xClQVsViux7X1mmoReb+YguoTJ6uDzL59TLxdZWt8idX0FmoYgSBgNZhr1Nt6gi6DXhtVsuBGr/I5u2reiuW+ybL8TnwgCwtfKy+9UpPMduP0zS98tXxBuhC039e3fXH9+Xa/wLU9q0ECWZX7wxgH/t//w93z62Rdsbt54aHr8EWqNDuFogO+/9xr1Vp85GldHz8gkE0QjUZ6krzEZTHRaTS4ur5lOZhgUlWFvwHU8jqwzcnF6hsVhxupw4PO7yRVSzBcTxDlUy1lmszmlfI6jszj90QBRNfLO997DajKTTGaw2ExsbC4j6VTKuRw+t5MDzwqqIFCsNijk8uSzORxeP+1mg1wmhdPlxqiKdFpNFohMNR2aTk9keYulSJhwOILD6eXzD35Dtz8kmc5z594DeuMR0WCQl8+OqVWrWJwequUSwnyK2WqnlKzwwW8/wR8JI0wHXF8cMxnN0H/Vf7DZmmG0WAnG1qjVawwHAw7296nXq7w4uaTXbOD0BZAMJmaTCfFEGoNcxOJwEI2GMVvM+IJBes0KaxtbjEcjms0ysiJTL2UZDm5UzKV+h+UtcPt8LOYLOvUif/7HP0avjTk6OaPfrd98JiQvkZBwBsIYjEbsDjfCXECUZLZvPeTy/AxZbyC0ukGzWsEf9NOo1FjMplTyCTqdKqpsoFUt0He6CC9vEggF6HYGvzcWwP8fAK8/HKAYraSTWdJXJyytLuNwBjCbDSSS1ySTcdb27iDKKsVkgnqpyoM33uCnf31Nu1IgFIqRz2aY9Tp43LtcnR6RvjhicyXK3u4Wj7/4km57QGR1C6c/wHjQZzYasHfrAR6fn3yxTOo6hcPrIRqO8Olvfo7ZauMqU+L5q0sujw5Z2VjD63HRbjWIra0TW12i2+4z6QSx282UCzddsfutGhepK0bDHiZXgFlHRyASxev1sxQNkivkiS0v0++0yMRPCEZjjIZDivkUrUaNra0/o9WfkcyWOH32Me5wDGMkyuXxMfu377C6ssqrkyvCqxs4bx1gsZiRJJlwJEK302OhQSi6RO76guF4hC8QpN+p8/rrrzGZzji7ymD3hNBm2k139sUCj9fHpN/BYrVgNZqwOFxUKxW63RbFTIq17T0EUUZRJBxmI+++dpd0oYYiaLz9w/cZTDWa3S4muw+z2UCtWkHUZvR7PcrVNGdffszGvTeYDHs8PT7FYLAwnc4YTqZfdVHoYDCa0JuMnBydUCo5KGYv8fqjlHsNXC43q+trzCdTwiE/eoNKwOtld+8umVSCn/3N/4YvGAFRIZu45kc/+TH92ZTJeIwvGGShaTRbTVSLGdlgYjIeMxVFzJLKuN/C5fMhy2ZcTisFg0q1kOXFixf02nXMJpVyvQIItNsdPvnsCcXkFX/xl/8ds4VGrVKmXa1gtNjpNOpoiymNuoN6pYReNqLIOub9Nga94xsLsW+HWt8e3+6O8NU+4XfR2jfr2rfuJ78WwNwEdN8qQfgnubxvZCva765Uv/V/Eb5+ImA0Gvi3f/wW/9f/+1/z20yKUuYKfzDKZHKb+MlLdKKA1eFBAgL+AHdu7zGcCoSWV2jW66yurVEo3LRCikYD6MQoqXQSt0OiUS0gSX4MZiPZYpF2q4PT68dqduAPemm1OujkMl988jl6o55Rv8PLV0eYjXrK6QTjyZzW5i6LhYas6rnOlyk3qsy0BR6/D1GWyV3HkUWJ2MY6etVApVij2e6wQCN+egiSjNNupVuvYNrboVqpkS/UWd4+IBoIksvk+PiTx8hGmXqjT28woD/sYjDasdqdBPwB9O0h3XabTm9OUGfh+3/0Ez7+8GMMLge5XJ75bEa1UkEQQK83ohpMWGxWBqMJZqOJw6efM5lMmUzG3Hn9XVS3m1q1QimbxeF0cXx4gsFiRTG5WVrfJRKNUCzVmE7nREJBWrUKZqsTo91OKXlBt9vHKhuYzcbMEXl1fI3F7kcx5tAbjdjdHvyxLdq1Eu5QlOFkRuX8iHLykmohjMMTQtbrmU4nTKY3EZ5elonGljh88RxXIMyw38Mb9OL3Okknrxn0G7R0C/LpzP9Xn///ePzBA+93qjVtwWK+YDoXyeazjHpNes0GM03CvrXNb375W3IXR8Q29ri8uMbicLG6voreqGBxWJiP+8iyiiu8BPMFtf6Mk2SRUGyFyQw8XjfnR4eMun0evfk9nG4Hn330MYIosbK+id5gYj4DmztKr9UgdX3NZDwFcY7RYmHQ7+GwW4ktHzBjjqrT8+4b/yOdQZ9CscG9YJTbu2uks1vUajUMJjPd3pCD3Q1URabR6lCr13FYzQT9Xor5NIuFxp/863/NdTpLbH2N9nCBJt4o+Raahs1hIRb0cLwYc/zFJ0wmC8rFLHqjSiwYREBje3MbVa9jUJoQ2zrgz/7iT/n53/49w0ELnaLQbVQoFwqUqg1qzQ56RWE+HlHMx3ntvR8wGQ3Z3lpne3uTjz5/Savd4+3vv4/L5cSi1zEY9ClTpd2scPdgH4/DzrNnJ2zt7HH/zi0+e/yKi2ePCS5v0u91aDVqxNbWqTS61Gs1zE4fOlHCG4yQz2aJxJaplwr89OgFqtnA0uoa+/duowmgU2U6gx6NZou5pjKfzbGazOiEm+hjpukoVRoMpxM6oyHDuUCz1SK6tonD6+P0+ef85hc/wxOJolcNrK6u4PM4abdrnB8esb61jVGWefbsBbPpnPFgwNpqhGSiTKOUZWl5mWatht50U26SS12xtr3LwzffpNsfo1NVUmdHlCp1ZtMx1ewVqqwSDHsZDtoM2i2mwxGjXg/RJCGrepi1kb/K3/1zReVfA+rrnNpXh+J3/wrfjgaFf2o79juQ/ZNQ7+un2j+78t184deilxvo+b0e/v2f/4C//s0LBGkNaTFjbS1MyG/n5z/9G3wrm5TzOZwWEwajgVq5RqtZJxAMkkpkQFswGQ/JlMoMez10IjdCnr3bmFQZg0mP0agybNfR0AiFIlhsDuaaDrc/gsGoMBck6qU8FlVhbWMNu8POaDRDVRWq1RqtZpWLs1NGX9nuWZ0eLHYnvvASwmJKvdxl59Y+OklHJjkkGI2hGszMZhPu3N2lkLoilc4ymYlUizkUswGj0UC7WqFSzODy+9C0MXpVYCGacHh92C0WJBka9SKjQQ9vKEomnSYVH+H2+dnc2yaXKxB02nn27DnpqzN8kWXm8wUWm5XJpM+w20MnK6xubJNLpxj1etTLJbKJON1mAX/oj+gOx9RKeeqlImarnaOTc7qdOtpCw2Z1YrG7KWfi6NtOuu0WZrOdTrNOtZBiNp1wlbhCJ4q0ShkCsS3cDh/6fSu1Yprwcuymu3o2dfM3KcqEwxGu4pd0WwmMFhvTYY+j50+w2D10mnUUgwF/eAm7zU4gEMRsd4GkIxIOMhqN/z/41P8vjz944JmsDgJLy1QKBex+PyabjUm9jqw388Y7+xTKTdbX1jh79gRPeAmDw8UXH/2a7YPbeLwejs8v0JvN3Hv4OqVyhX6vzRvfe58FGolcmeFkTq1UAk3D73PRUhWC4SCFYoHRaIjN7mB9dYVkIk1rCrJeZTQaIkgisl7P8s5t+sMhdrOJu3duMxyN+Zu/+t+YzmbYrFaqtSr1agWUIcNBj/F4SCwSZiEplKstjk6v0asSZ0evsDjdlOpNGvE00zl873vv8OXjL7g8esFr7/+EeDKLLMu0Ww1cvhBOj59qd8x4PMaoytiMCl9enWByOnDarbQqVVTFwGw+od0d4vV7yde6BJdXWd094NWrVxgMZuqdG8eYdqOB6g+gGg14gkHqtRr5ZILFsI+mM1AqllhaXSMciXJ2doreZGY67yGIC+rlCqen5/S7XdqtJhubW2QKDYaTCQ6PD18wRCGbQxQl5vMFOkmGxYKt2/e5e7BNplCh3WxikBVkSUISNKIrqwwnYzKZAja7F4vdSb/XwukOsLq5wXy6QBBmFAp5BuMR7esExUyS0NoKdpcfrVDGE4hiMTsQRRlZVW/Mmxcai8kYbTbj2bMjZEXl4PYDJFmh1RkgLjRmowGDTovkVQKzzUGvPSSTTKIYDLSbdWIbmyhGA2aLm3DEjyiKnF+lEEQJu0FHf97DG/Ch6PTc2dtgcyVMMlPGbLFRDgSJX1wwGg5ZDjqQZd1XgpVvwU4TvpnzT9H0HacU7b/gsfmtvN7XAd7XwZ7w1eLX9mTfRIbfvMk/vhLVvirSEwSBzdUlHraGPD5Ls7m+we3tDaaTCX/3V/8biqgRiK1QSGV4eXjGbDYhc37IfDrDYrGy0ObEz09RDEYERKwmE35/iNFwwKA74yC0j8/rZntvnxePP2Ul4qPZG1EulamU85hMJqazBc1amfXNLfQ6lVq9zVJ0iYPdDYwmK2eqgiRJ2O03pTfZ8yP8q5tY7E62NzYZ9Po8//xzFFWhks3SqJZQjXoUnUij3iS4vkn64oLN7QMcVoXDoxfkMirMFkg6mdfeeIf5fIrz7l3+9m9+iqpYmI2mzLU5yysROs0qi8UURZGJnx0jra9TzOdInJ2h29hka/eAxsefIC7muH1+0ldxrDYLVrMFWW/EYnVw634Ip9uOyaAQj4T51d/+R45fvsTkdOH3+YksxRiNxlTyWSRZppi9QhBERqMJk/GApY0tbA4Hg14Lj9/HbB5j2G7jC7iYzkXCSz8ifXXK2fPPGE9mSOICu+UheoMRg9mCx+PBF17GbHUSiq7TNOrZ3dtkMoEvP/uEyWSCxx+j161TzFxTyklcnp0xHnRxB0KYzA76/f9ah/cvGrHYMqNhn16nji8YYrGY06wUcPkD5PJlZNVEJp3B4vRwcPsWg9GIo887CMKCi/MLsvFrNvZv0e0POD9+yWTcxWFz3qi8mh1moy4up4nV1WWqtQrtXh+z2YTbab+x91EVDKoOq9XMk8dfwGLMozff5dWzZ8y/0noP2g30wpSLRAan3Uqn3WUym/DhBx+RPH2JTqfgCq+Suyzh8Powmq0UsjlgQa2yoFvNISsq7bqG3elCnA0pXJ+jvfMONouN0WCEXhSZ9TscvXqCK7yKoqiYDWb6nS4uf4C1zZuGqVabDafTyc72FmeChqoJXJ6esFiI9Js6fvuzv8MXDCPq9BRTVwSW12h2mvR7Haw2K8FwCE3TKD3P0ahdY3VY6QxHvHz+FKvdznQ+4TqZIJ9N4YosYXd5OD88pFUuY7I6GSfKqLKBuTYnlc3wxQe/wOpyky9kKGSTePwRbDYbOrvEoNNC0elod3sUsiliIRfvvnEXp8WA0fAGlW6PoxcvcTg9iIJELhmnVS2ws3eHUDjE1cUFlXoNg8PLaDxFViQmkwG1Spn5AkbdJhs7O+gUlVqlisMfZj5bMJ0ICAuwOewMJ1MqpTJulwNV0FjoZcw2CwajEbfHzfbuLltbG5yeJ0ikM2x5nFycXJC4PGU6GfH8+VOePh4RjoYxWN0sbexitVpY31jD7Pbhdpix263YrTY+/egx/qUVyrkbJexsOkPSZjedy4VvMnbfBs7v1Cu/E5kI3whPvuWg8h1nla+g9bWl2LfHTZuhm2ffFcJo34XnP/ee8Lu5KEk83I3x8Yef8mWlzqDbQREEBEnhrXfe5uIyTurikk67Syi2jCe8ynjU5869R5iLVjLpBCaDCcVkI5dJUszlsFjtlPI5Li7jlKsNqtUWVocLg6oynsJ00GZzZ5eL81PcoSiyyciXn36E0Wij3WpSSMYZDAa0mm3q+QyecBSHP8hwNEU2OHE63XQ7DeqNJhsbG7g9bjKZPN16lVIuQWzvDsNBj2eff47JZmc0HKAJC1qdHiaDGUWW0BksDPodKs0mOllGmOlY3buH2+uj2WySz+aR11ZZ29ljaSnM+pKfj4MBcvkCgYCfVqXBb3/+n9l5+BZOtw9/KIyGhiiK+EJehAVo8xnJqzNWd24RTxdx2a3MNAG7+6bZ8Xw0RpUkfB4Pz54/vbmWdLio5VOYTCobe7ucPF9gNau4XG6SqRmKqmf39h36jSbBoJdqq0uvN8EbiPDWo1tMJyM+/fQLfvnX/wuzuchkPCDfrSOqetKJFAvmiNqE4XAJi81DKByhVC5jsrnQEOg0a5gtVowmFYQF4+mE+Pkxw95/zeH9y4YsIIxmSAsNRdbz4vFnGM0GllaXaFWbtNtdGvUSk/GIVrN3c51oNCPojdiMEh5fgDsHB8iSxJlBTzDgRdbJSPMpUZ+DwfBG9NIf9Dl9+ZxgLEYqnyebymBxh7A4PVwlMyw0AZNJj9HsIV/I0W41sUgy2fglorhgdWMTUdGTK5YJrW1itzlZLKBezGN3eXnjnXc4PT4kn04wGQ0ZdFvodAqe6BKdWpFRr8VSNEYo4GbclelsblMolFD0Nn7w5/8Oo8WF2TEjHFvHFVgin82QTedolPNs7G0iG8wcPn3M7r0HhIJ+Xj0/xBMOsrkcxWazs766Qqfb42/+41+RvjxBb3Uw6neZDIY0pmV6rSZb+/dptxvUKxWmc7C5/aiqyN57B0iiSLPdxKAaWFmKsNDmvHj8BTrVwnQ0ZuP2A7yBEJcnl3SbedDNUWUVSVbx+vxMpxMGzTITh4Nmu4lOWzAdD6hXSugUhWwijvveberdARcXVyBK1GtVWtU8vmCIbPIcUbn51q7Xq+hlHSaTjeFwTL1Ro5pNY7IYsHn9jFpNFG8IgHQiQcczpNusY3f5YCFRLeUYDtt8+fIloUAUk8XM6eELzA4b1WIdX2SJpVgEi0lhbSVCMp3nyaefsLS+g6yacAdDVCplDGYT6+trXB4dUiqVmRdadFolXp6YGH3xlHarxf03X6Nc6ZKKp5AUhWa7Rfr6Anfg/8Xen8VKkmdpvejPzHye53na8xzzkBE51JRV1dXVFH2awz19W5croSvBG0KCN56QeAIJoYvgAcQVCA6cw+kDTXcXXdWVVVk5R2bMsed5+zyP5u7m5pPdhx0RuSMym+7iXOlKJdaDb3ezv5nblmzbt9da3/q+KOPJCPsLCyDhtTLic3A7/3Eh63q+XbjY4/uKbdCrhkEXFsKFvPH1Ob7nh15IE1/r7V2ASAEBu8XCX/1L3+Ef/r//P+fC2L0Og36PyWDA0lycg+0dgqEIw8EETTgfdRmMx6ijKeF4gmgsjiiKTJnQbreZolGv5DndeYzFFcDhdGGyWPjws0fnyiiqwnikMjM7C5IJgQlCOEo0GEOTBD766R+xY9Sj01voNSpIoojb6aJZSmNz+/F6fYzHKma7DWU0wmw1Ewq5OTxyEJtdZ+PyVU5PTxn1FYwWK91mg+zpMZooMVH7rK4s8uThIwbdFt1WCyQde5s7hMJhpiIM+j3kZpNascxkPCbo9zEZT0klozQ7CpOJxOzCAseHBzz99CPWb95lPBjRbbeYjkaIUxD1Rmq1Bm6XjfTZEY1Wm6zOgMFgIpycQ1EV5HaffD6Pxx9gIPfQNA2b3UlflqmXCoQSM6gDlZPjNDfuvInRVGN3cxunz480HXJ8uI/TE0DQGamV8jSacRYXF1lYu0K3NyIcC9NVhhxuPqTXqmF3+clnzlD7Xe59NMYZiFIv5bHYbAxHKu127bwPGImhDBQkowlNlKimz4jNLf/Kj/z/VvzaA95YGdBXhiTnl7A57GjaFG06wWGzw1DDYLIwl4xz//5DRiOFRiXH7NIKmgaFTBpRkDjNldHppqxeWWdpJoXJ4qBWrZLNZqjW68i1BuGEhCPgQ1X6lPNFEK2YLDocTheziRBHJ6dcunabRCLK/vEx2nTKUB3TGKrUSyfsHbix2VxU8yeEonGSMymajQYzi6vMLS7RbneZTMZ4QxEcLgdWhwOdQcRk4txDrS8iMuHx/S+IBkLcuHqDD37xc4xWJ6mFRTa3trDYrHz3N3+I1WLmwWMTgqBj0G9hN1vQ6/RMx1PKuSLNVpfTvU0q1RpfvPczLl29yng05fA4w7U7bxIM+tHrJU5ODlHVKZVKA5kWkl7PcKTQapYxW3xMxyOOD3ax6czorSbU0ZiROuGDj+8zQcDui9BrtWk3SgSTKTRtilw9I5RM4vEHKGXTRFIpovEU1UaL2PwaTn8QUTJSyZ/hDXiZX1yhOxji8Id59OgJ7bFEvVnHYNThDUVoFLNIgp65pRVUpUtVm4LegCgITEcjrGYHElNsTiel9DHecJxrb9xBkM77ixaLHrc3hMFgpJjLnFcMrBIDFUQEGvU6k6nG8uWb2JxWZPkTmE6wO9105Rb/x+//JzyRGQq5LMpYQNIJTCcTfNEEHqcDm8WGw+XDFwyi1xt58qjFyekx3XKFq7duIokiOzs7NAoFvvWd7+Bw26gUCqiqSq9exGxKIUni1yisnMfLrt4FBucrPb5XMeyrxz4fQTgvZb7uqiCcg+mXi7886ddejvBytyaAIIgszsZ549YVsATo9nqkj/a598lnfOf73yMYSZI+OSaamKFVOiWxsIo2GZE72SOxME+jXafVbGCxmvEkUownI5B05HQiNncIAYFuu0qjVkEQ9Zzt7dLvtvAFIswvxfj0422C8ST+eIzdrWeEZpaZWZjFFwjisFlpVCusrywzUrpIRh2K0iF3dIDJYMRqd3N0lMVh1SMKGq1mkelIYaj0mEymJJMpyoU8Drcbp9dLIXNGrdogHI0jIZA5O8Xh9jGQm+SHKvVqmV67gVyvY9DrSc0v0usO+cUnT2m3G5Syp3i8DvwuB4n5OWZnZnjz7VucVloc728TiIbZ/OIe82tXCSdSFE72WVhZwed1cXBwyGQyQjJ5MNkdoAlM1REHezvUSllmNq7idjsIxlOUcmc8/Oh9GqUSNreP47MMkiQy7MtMBjZGY5VSLku5WMYTCtNuVPj5Bx+xdXhGo1pBp2msrV/mLF/g7GCXQVcmObeEoo7RGczU88cEjQZsLiftWgWH24c/HKFezpI/PSC+tI6cOabdbGA02zBbbf/N5/uvGr/2gHe0/QxNZ8bjv4bRYCCQSOIO+lH6I3Y2NzHZbAyVPvnDTb7zm7/JTDKAy+XhZ3/yJyhym5tvvsOzzS16rSo/+O0fUaq1qDfO0CZjguEw1WYbT8iK0+lCrtc4fPIF2sZlvJEZapkKk9EAtd/hYPsp88vrDEJ+DEYjy+urWE1mMpkSu3t6/KEAFoOVUlpDL0h0ux22ntzHbHVSrFRIH+yiM+hYWL9CvysjSBKBoB+DwYw4HhGZmWOoCUSjMd791tv0BiqCwUT+ZAeYMBxrVHInmAxGItEIvoCX/Z0tRiOF49M0euM560uv1zOdgsXpY6T00Jhyms2gDCecHe0zv7hAKBTCbrdz941b9Hsqz3bP6Cl9ur02RpOObrNBOBglGouj9tqUK6Vz+rrJwngyoZrPMr+6TiIeZ7tawW63E/T5mUkl2H9oZ9DrUcwWONvb4fbdtxhrErnTY7zBIIIAk/GQYCRE9mCbYCRGs93F6nZjd9px2ewI8wuc7W2zcmsGp8VEtSUjt9sMem363R6CXkeuUkFjQiASwBfwsfPsCTbrBm5fgGq1hsVmxqCXmJudo1xtUi1kMOgF1GGfyRSYigwHE/TiCKWvUFFVBgM7AV8Au8PJZDRCks7tnvpyi9Vrt5lKBqqlHKraptdpohdESvk8EmA0W8//IRuPiMVTFAUd4XCEaxur1FsdypkTPv/sHv/3/8fvkkgmOE3niYR82CxmdLoX7ggXUOYCMeUrcZHQ8louJ7z6cmHr15NTzkuY2vPvviA09uXA34WjvixrvhAl0xv0/PDdt/jl4zSlQob55UVsdhfbBxlMNhseAXR6gfXrb9Cs1zAZYHV9lVy+yOLaMgO5Q/bkjK48xO5yILeaeIIRVjYuUau2Se93MFmsLC0vMRr0ONnbolFrIuhtaBqkD48QRQvZoyMwmhD0ZtTBCEE08cbb72AyG7G43Ug6CVUZozdbaVRrmHVTDMKYjqwyt7TM56U8D+99jjcYoXy2RzEfZ2F5DVHUI/e6JGfnWVyYx2K2UI0nuf/w83NBiO++yyfvv894bGJm/QadRo1y+gCn04bJYiCdSRNJxFD6PQbtNj1Jo1LIEQuH6MkKg45MJX+ILx5Cb7EgyzL+YJCq2cbpySk37ryJwDEOixkRGAxHhKNRGE84PT7FYLYynk5otru4A1E0Qc/cbIx2u8Pm/S/I7z/jzXe/h92qI5/OcPmNt3jw6YfkjncRhAk6kxFNNKGoU0bjCYXMAR98bEcy2Bn0W7z93e9islh5cu8TbL4YFqcfpiPC8QT1coGz/UdcufNtQsEA93/5E0aDHlduvcH7/+X30ZnMCNrkL/ag/wvGrz3gDdUBRp2BSj7D2O3GYjLjMNo53j2gWS1xd+kWfp+f3JGbeqtHNb/PD//Sb7K6usLp6SmzM0ly2Szlk11OT/K0O20Ontxn9ep1DGYrvd4Ah8tDIhqmki8iCAJ2mwO/30Uhe0y1XETpd8+NHNs1Pv60QSl9ysLCAkur62TTx0xGUxBEptMxPn+AhbkE4USEh5+NaNSreAJ+RqqKIILVbCZzmqbXbkLQz86jx0iiQCg1w9PHj5jIjfPfezTG4vSy4PfwjTdu8dHHn7OfO8FmtdBtdWi222QOdokkZrBYrOQyaRweHy5PkFKljNXhxCgJuBYWmWgCbr8Xud9DNNl58Gib6ahPNBKgXm2xu/mQYGoWo2Rk0O9y9823uX3nFoVClVQyxXg6RSfpkPs9KqUi2niAz27g+9+5S7/dxGI1sbSYoFguIRj0GC1mBG2KzenBZDTjsRnoNQt4/G4k0US/18MdDeMJz6Gq2jnTcDREMllJn54xHvbwejwspGIszc3yyYNnzCeinOZyfPST/0q3VsdkNj4X2fZRq7cpZvOEohFEvRG5k6fX71MvpBEmYxzeMO1Wg9VLlwlFY3xezNOpFUgtrNCsFWnVq/S7XexON3abjcl0SrZYRacNmVtZI5c+weqwkUzESNvMtMsZlmbjHJxWaNZqeDxuzBYTzZaM0lcwCBPEyZD+oMfxWZ6uMsAZTuCw2nm8c4amMxOKRvHYBYwXBKNfxKvw9DXCmS83XRCGfsHmfH3ZK8Pn2kuwer3g+eXw+UVnBS74xV5gxAjnSiw8B8p4JMBbOiu3b1zhg/sP6akCqlxj0JdZWJij1Wyj1+u5ces6kl7HSLVgNhoxG0wk55bJ56pokxHRoB9B7bL95AGj4RRfJE6zUiSanKdSqSNKOu586x1EdGRydYLJGSrFIvVGFZPTjdyqc7y7g9VkpJwvYLMYmZ9JcLazSaPewO6PoapD3F4Rr9tKxHeJe0/2yJydEJldoHh2zNrlKxhEjd2nD/jNv/wj8vk6rWYbRRlQrVSw2T1kzrK4XX5AR7c/xhNMYLHbsNpsjEdDgslZPC47o6FK7mQHk8WELximLXdJJBygQbXeolxv4LZZGA0GZA/3iKSW8Hn81OtNOr0BvqCPYrXBaDQBbcrCwiIHh6e02z06zToOrxeD1UqnVSUWS1LJ5VG6bfSGBdYvpaiVK9hdbkxWM9HkDIVsjvTxIWabDb3RjDcYplUtofa7uGYXiUSjGHQ6JuMhidkwE2WdzMkZP/jhX6J96w5PH97HYLZhiEVwO90EIkkEcUIsEaacq5BcvMTc/DJ9VcHkcDNUB/T67V/tgf/nxK+9W0Kn02FudoV4LMrO5jM0JjTLJU72nhJOpPD4A8gdmakg0mzJlGotvnj4DLmnMBxNUcdTJqMhqqri93pJRGPAlPFkyvbTJxw+/Zx8Nsunn35GNn3AN3/zR1y5cpX82RmT0RSnx48k6bA6PfR7Kka9CV8ozmgy4eMPP+DsaJdgNIKqDNh/9gSvzwsGA/v7h5hsbtavXeKbb9/g8sYKrWqBRqOG3WIllZzFbrXQqldQlS5Oh52wz0s2m+PTh1v84X/5MYWzQ9xeH72xRlcd4PZ60Rl0TIUppUIGfzSBpom0G00EnR5F6VMunHJ5Y+m5FVCaXDZPr9tj98lT+q0mijJEHQ3P3dNrVfr9FpJRz0TUKJcLdGodvIEw6UyOJ48f0+m0CYQT2L0BErMzrK1dYWX1CvFonLN8lW63T3JmHovJwPHxMYFYnNXVK2ijIXaHk85gzN7hMXqjGY/fz2w8Qq2QZfvJE+LxCGaLiak2QS+A3qAHpqBNiCQSvP/BJxwcHTGXCOFyWBiPBd745rvcvX2VxbkUjUYTudXAajGgDvrkj49gOsLt82CxWzDZnAiSAbvNid3ppdNo0pMHWG1u1m6+TTQeR683oE2n+KNJltauEY1FUXodbBYdnWaDkTJgZXWNXlfm6OiERqlAIjnP7du3CYUDrF65TL+vsPvsKfGwH38wSDZ9/s9H5viQza1d8idp0ttPmAg6hlMRTdMxVhX8LutzSbHnpJWLZJVzu4M/cxzvpWnCK/E8A9N4qaf5ZRb3+rKvPcF/Iy7O5F3s7YEgSsR8NpxOG/rJhMzhDiaTAblR5ewoQy6TZjQenRNZTnPc/+weNoeFpYUUdpuV6WhIu13B4bLz5jvv4LDb6NZLGEQNXyBEo5wn4LUh189BbH11CbXXoVaqYrW6SaXmSC6sMDO/xI2r6/j8LmJzCzy6f48/+KNfIHf7TBFQe1363R42mwt1MKI3VFHUAYXTE/qDKXPr1+m0u0gWBzabnXDAx/WrGzAckUrNUiwU6Mstjo92yJ8cMBqolEoFiplTRoMROmGMXMlROt6lWm9SrtZxerzYnFa67QaNRp3jfBV7KIpkNGJx2HF5PVz7xrv0223MJj1mux2dwcBk0EeWFUZ9BYvZRrFYZH//gH6/SzGfZSrqaNUruF0uPE4vBp2Ezemk3+1QqzU4PkmjDkd05T6HBxke3X/IQBlgtlqJxmIEowmuXL/G/MoljHqRer2CJokk5lfotVqo/T7xuVWUkcSnnz4gHJshGE2SnJlBVfooSheTxUS1UGTz8TPqtcq5Ko5Bh1FnAsHAzNIa83Pzv8I99ufHr32G543P0uj2aA9GWFwBFhYWCHkDtNstZufn+fyzL2hUa3iDITJHeywsLuPzeSgWCgwGA3Z291m+tIbZYgRhgmaUiKRmCIcCGEw2JBGWFxc5Oj7BZDLQbJz3Ffp9mY0rVzBbrDz87FOC4XMV/nq7RzQaZnUxxdNnmwyUAW6vi3aniy8YJp/Nkc8XKOXTOJwewrEQf/reB+hFE7/5O7/LaTpDpVhk7dIa3oAXf3wWg8HEUJnSlQdIog6l38Pt8ZJLn5HLFjk7PEUnibz7g9/m8YMHiAaRN964AYLAwVGaSvaUyVTj2o2ryJ0ea8tzuBwGth98jNlsYSRpoLRpyj1arTZDpcvsxk1W1xZYSIb45POnnJ0dI+o0Tvb2QTdGL+koZUs4vB4czRa9bpdup47ZbEfURKxOF/VWi2opRz4fYzj0IdertHQmus0+3VaL6EwKr8uJezaBoNOhN1lodwfodAasZhNOt4vTs1M2739MKLaAz+qkK/fw+pzEYjGmmka5UqHb65PO5Hn2+AnJ+SV2Ds8o5dL0lDFmm4NGu8Z4KNOoVLn59tt4fXHe+/Ef4w74sXnsHB5sMtXG2F0enE4HRp3InVuXUUYiwmTE2sYGoXiKTktmMpaIpuyMtSmjoYqq9qhUp+SO9pAkDU8kSfrsjPeQ6I6mTEcDrFYTdruRbreDP5xCHR9j84ZIH+wwlWosLi7RLJ5x8PQBlXKFQadMKOAmFFg+lxQTX2/I8RLZLs7Cvbbiy3htg3AhRbw4O669SNcuzPtpz+cULkwAfjmoLryqtqK9UnJ9db1egp29PQ5PMsSSKcaDEf5wjLODA4bqgEkoRLNaod/r43B7qLdaPHi6Q6/VRSeANximVKnR7Q8RjVa+8e13mJ9boDSX5NGDB7g8dsKJJPV6F4u5jlEvkM0cYXH68Hg8uD0OtLFKIBTB4w/ykx//mOlExSDB0votOr06zVKJ9StXmGp6Pvroc4aqzI27d5C0t7n/yQc08iLCaMxU0JibS1EsVOgoIyqVAka7DU0UUSdjFi5dodNq43Q5UIcq/VaZZsXC3FKSpfU1+p0ONp3A1Wvr/Pv9bfa2trDanEymQxqNGo1yicrJPpqg5/KVy4w0kW/81o+wWW10e0Nq1Sqzi8uc7j3DlIhiMuo4q5RB1KF02+iMBuxuJzZbmEQ8im11lWazhdxsMhmPaXVkBsMBJqsZudWg1mii14kYxCmZwwP8kRiS3sDm5iZWuwcEHXKjTkGnw2Y2M0WjUS+jTiXyJ/tUClmqTZnxaIxBVfGFEhgMemZSKQrH+5zu7eAJhnDaLdz7+Jc43QH0RhODCZSK/8MA9lcKi15HqZgDQSQxO4tBr6dSKxMK+UnFIxztPCM2v4zFauF0dxPT1atoTNl69pThaIym0xOJBLj71lv88qPPaNSbJJKz1NsyjcMTLDY7miYwGo7x+kOk5pJ0ZRWxoScRj6AXBT5XFAamc/WHSrHCpcsb6EQBg9nOyuVrTBEoHj8DJly/dROb3c5H7/ewWu3oDCaOHz7CF4oTSsRJ7z5loAyplNyMplPsTjcWm4tqo8lUg2+8+x0cPj+7ewegaYQDQcrZNEajAbnXwWm34AsFWF9Z4unmNvtPHxBNpfB7A7idTrweL91+H3U8ZuXKDW7dfZOg00ypWOPnv/wlU0FHW4OJYKDRlnn4sETQ5yUUjfLR+x9gtttxeP10ajUcLjsOhwOTUUTtjUkf7OGJJJgMxjx+bKbXa9NpNzg4PuMsX8Jis2Lz+PAGApztqhw++ZzJyjK+0K1zhft+n2KhzFDt8/Y33kTudCjlC4zVEcVchlarQyOfRi8tcZYt43Da8QWDdFodxpMBgjblaOsRWaOF6VTFYLGRz5cxWw2srG9QrjbpqirNTg+n1YHT6UMn6WlWi5idLvQmM0e7uwRDIRKxMGe5Ig63j2vXrxH0uvk3//Y/0FcG+KIJSpksoZkEE1GgkD3D5nIiN8v4Q0EK6RylfA6DxcL+s4fYzFau3dziyz8AAHzWSURBVL6OOhxzerCHw+vCYDagMztIzS1itluIzi/QqNQJ+FwMjFNSHgNOuxW9Xo8gPC/UPHc5fzFSgKBd4KsIvNS3vAg2aC+B7IXwNJrwnFTy5bqXa3kFq86PuSCm+bXz6a9NtL8OwmgCoigSd5sYjwZcubpBo1Ti08++wGK1gqCh15twuj3IchuDUc/i8jrp4zMa5RKj4QCPL0AhfYY66CN3GmTOztDpDGQyeWKJJNOxRrVex2r3MtEkojPzTCQRTYO9x59h9Qbo1KsozRoTTWMgN/nRX/ltJJOdw6Ms/W6H4UAmMROjUW3w6OP7rF6/gdVoRq8X0elEUvPzaONzgWWX1UJb7tOQu6hKi5ODLaZTEUGSMNtsDCdj9DoBr8dDdGaF6VRl0FfoyD3c4QTVdo/YeEp8dol2u4kvEEScjtnd3iQcjTFR+hQzZ3hcXrrVJmf9Ht/+9rcQJ1UauSPW3v0e/W6EVquJNxTFks4yUFS67Q5Gs5mxotCSZT5KH3D5xi0i0SiXN9YoZQ6pFTNYbA6MBjOx5CKj0YBSscjylRsMBl1O9nYRJD1GgwnJaEAdD/B5wjSzaXpmE0q3x3g4AiZokzGpuTlsThenhwXGwwHKEEZqH5NexO0NUCnlCAbD+Nw2CoUKBknDaTczUYd0B4P/S8//1+PXvqRp0OnQT0eo7TpGo4mD3QOePPiC9dVlDJLEaKKdl4REPcmVdawOB6fpAqWTA8ZjlU6zjMtmpNfpcry3hzadnDMWnz0jd7iN0WSmWilTL6UxWSx0ByNKlSpKb0BXHmDSSdgdThaWl9F0epRum4mmUW00ePL4Cd2BgiDqkEwWgokkymhCs9Umnkhy9523mJtJEAhGaRQLWPQSCyvr2N0eDCYLhUyaZrXMYNBn7+kDunIbk9lKJpvldHeTpZVlbt+6zuUbN/EGw1isZhZWVqlV61TrTXx+Hzani0g4Su7omGfb++iMZs7yZY7SBW7evc1cMkqzP6QzGvLtd99l4+oVXB4X1fQBu1ub7O0fMRqOOTxJU6tXcQYiKKqIooxR+l3CsSThSAyX108oHMZmt2JzWUnGQ5Szp0yHQzrlDN1Om66s4HE4GQ4H6IxGgpEolzau8OTRDjuPHjIZyOiMOnrtOpmzDJNBn+GgT2RujngiRijoxWa34HC56MoKzx4+Jn2aYzhUKZcK6CSBxdV1Nm7cJDEzQ7/b5vjogPzpKZoGeqOZSqXBUB3x1ne/S1/pYjQYCEfjqJ0mdpuRTrNCsZDl/tMdDg5PmU4maFOJdKWO0WbBG/Rjdzhw2N0orS5TTYeg0zMFVq+/xfrGBu5ghMlkjNGoR5iMaFaKPH60yfHJGV25QSqVxKQTmKoyLreD7ceP0UsS7/7gN/AHg0QiUS5trGI2m16KRr/icv4C+F7QL1+yMF8QW17Jx/4skuZXQ7gAaH9WOfT56+s/v1yvvSypfukhew6jqagfj2HMZx9/QnJu4XxGS9CxsLJIMBrF4vbjDIZZ3LiE3eFiOJowQcDmchP2e0nNzGG127n+9jc52jvk3iefoA4UphoUCmVqhQLlYp6TkwyDwZBEaoFQNMHsyjrfeOcdVjYuE0+luHxlFZ/Pw+aTpxweHHJyuEunVuX6tctUzg5589YGZpORSr7A0UkGWRngjc2ysLbO7OI8pVKFEQKxVIx+X2GoTnE5HcwuLNBodUmfnnC8s8ne4RH9UZ+JNsLh9sMUrBYrPbmF2WKk1mzSaDTo9wcYrTaGYw2nw0ck4OX7P/wRHqePRr2C2WrldHePP/hPf8xHH35Ct91mpLR55+1vYLU6KBXLaNoEp9ePO5xAE3R0O31MVgeS0caT+/eoNZvEUhEu37qNXpKIzS7QbjU43HpMtVyi26pRKVcIhxLY7C5alQIetx+fJ0ggmmI07DLo99hY32Dt2h0EUYfP52Xxyi0knZGbN66xuLxMs5xn0G3QbZYp5dPYnD7c/hB6g4FypYbNbieRWmL18lWcLgfTX6ls/ufHr32GN5lMuHr1GvfufcpUVdl78hBtMuTnY4FoMsW161cp1zvsbm2xuLJKMhGn3pCxOlzMLa7S6bQ4PM4wHsKgJ4Pfj83txWgy4w8ssLy6SDGdpi+32N/dg8mYheVLpBZWqNWaVMtVIok59AYTU3XEWJHpdhQO+iUGvR5nB3tMh2NE6bz+vru5SbdVx+1x4o+FGVaHmGwW3vjGN2k0OqjKEL3ZhtHqQOz2MFjNzM6lUOUmykAlEA4j6nUcWcy4/V4e3P+CWrXKYDim2WlhNpkx6iTu3X/CW3evs7B2mXA4iF4n8fjxA45dLrKnpwg6kbLXS7etcHaaxmyzYoxYcTs8WKwO2s0seoObZDzOdArZo0M0JMbDAXpxykjtEAglGChDHj58iKIMuHL3bQqlAqPRkPhMnCtvvcWDDz7i8tVLGEw2vvjiIcpgQObkEL1ex+L6ZXYzRU6O9pldWmf90jVKtQqHTx4hdzog6qgVcvgjMWKL8+glgYX5WRwuN1vbe8hyk1LReO5bdnqASa9nZnGBXk8lnpglkpij0e5wvP2Y8XiE2uuCIBGbX2bE5FwYezolFEtSzJ1hdTiYaEPK+TqDsUggFMHqcIEw4fH9B2SPjgnPLVApFum0aoRiEQLuc+JNhSl+vx9Z7tFpNQj53Ny4dgmTOGY4HCGa7JhMFsouB/VOh4XFeR5/2mdnZwdVURn2VfL5IqVyhRm3jqB/CaPRiCiJF0mXvCxafoV98uLNS+bIK4PjL99pF/Kv58j2ujznSw3O572+FwD4ckThJZC9PtH3wkHhy1rr+bHnRBi93sA3v/kNfrmVY+ckjc3hwGgwoTdaqNUq5NM5TCYjAX8AZTAgd3JAbHaeaCSILHcYTzVc3gCteoNw9Nz1XBSNFHIFNAEWVq/RbDXIZY7Q6Q3Y7HbsTicLiwsYTEbGQLFQxB+6ytLVm3z0p3+Kb6pD7bSJRAL81f/pt3iytU88EuIHv/3b/Of//T+x+egR3kSCRinPo09k1q/ewGB2oIx1dLoKkiDgDwe5cesN3F43m1sHpFJhHt7TU8ykEZEYj4aIko7peIys9JG7DfaePeQ73/0Nbl67xM/+9E8p5bNoI5WB0sPpCdOS+/T7MjqTGYfPT3RhBb0oEomGGaoq+3vHXLtyjeWVBbZ39qiIY/SiQCgSpcKUZjmLxpRer4cwHrHzbJNK0cdUEzDb3cSjMVrNBoeP74MkIjBB7rY4zmQwOz3oDRIutx2bxcyop1ApZJmdmyc1E+WL+0+YjEfo9DqMZgOj0YT9kzO8gfA5OI5U4ovrdDstirlj/NEErU6LerGI2Wik21eQOx167Qb8D3ugXy2arSaKpvE7/8v/jf2jM6bTEcm5JexOF5owQZa75E4PGSgyTbnPF4822X98j6XL11jZuEKhVMJsNqJMeiyvbRBMxdAJGkur64RCPrqdPgI6ZpbX8QX9dOUeC0vzxMJBnv3hjynl8iTnliiXilTyOVZvvo3VaqNWKeBze9GECZrFhMPuxG13kp5qvPHWOwgSnB4dIbfbJFNJImEfP//ZBySTSey+MAe7W0yBxOwMkYCfViRJt99FEiXa9QajgUo4GuP0cB+9MMUbj3ByeEAstUg4keLp021+/OM/xe7yoAzHAETjSd5+4wofDfvc+/QeXbmHNp3S78gk5+bxez00ax3qlSqSTk+v3WEc0ah1e1idbuROC6tex7WNdSohPwGPl93dU/Inh5itdjKZHHK7xnAw4MNP7lPIp1leW+X6zZtUam2s1m2i0Sgup5PTk2PO0jnU8YROpYBx7SqZfIXjw0180TjeaBjG4IvGic3Ng6TjYPshM3OLdHoTKpUaRquLdrPO/OoGfblFo5All0/Trncw29xEY3FGwwYTTSSQnMNptZE7PaGSz3DqcJKMptg/3CMUieGLzpItVJAMVqLxEDavj9PDY6aKjM1uRen1GA0G6IBKtUSnVsTqsCLLLWRlQrersL+9iScYpdOscevGOm63jb4yRgBcVhcduc3MwhqxRJx8oYzcqJA9mPL2d97lcHeH/Z1tkskkNy/NYLNazh3OeSV5eo4jXzIlXwyavwShC4u/PPYCSL4ERr4sVb4Cns/dFi6MILwkyTxPATX4MmV8vT/4Ne9eXoEosLaY4FmmgyCK6MxG5K7M6cMdApE4V2/fInOWod8fYDUb8PjDlDNnzCUj6GxWPv7lR/SVPtPRhLe//X10Oj27208RBIjEZ3DYXOiMFtBEDEY9sWiQXq/Px+/9HEQdvV4Dly9IJp2n1qgRW1ghFg9itjgwmQz89JefYXe46PSGNFpdgrEob33zHbpDjVrujMzeM3yhIEqrwoOdp7RqeeZmo8j1Arlcllq1wuHWEySGzK5sUKuW0cYq/kiScj5Dq1YmEE+e23wZ9aQSYSYTgcTMHJ1Oi5tv3uV4/5DtrW0EyYjGhF6vw9nhEXaXE6vNhtPhIhCOoKoq+VqHk+MTarUyl2+9hSzLuDw+TAaJB+kD3O4lvD43+XQak8nKYDChVs5TKxc52tthNjVPLV/G7nbidFvRSQLDyZDC2RF2dxCz3cEEDZPZTDC+gNzt8pM//jGZ4wNcgSg+v5dQKMj2owfUSzlMVjeNSgGD2YwgSEiSAaPZgi8QYDCeoCgjpOmUxcVFSuUqm5UyeoP0F3vQ/wXj1x7wBuqIbrdPS+4jt2V8kSSLl69jMOgIeR0MVIWD/X0CwRCDXpvjzc/RxiOUicj27j7NWoFgMITcbBBLzjDsqxyf7BOfXURvsaObaJwcHGHzBkjOzLK/u0cxn0HS61AHA1rVPC6381y5v1ZAm1+gkD1DLw74wQ9/g/3TNCcnp5itZuqNGhZPgMTMLNp0gtxT8AbDXF5dJuByEI9FkHR61G6P8ukBwZlF9DoDu3t7yP0et69fQm7J7OweYbe7Cfj85xR+hwuPx0P2LMNgMCKTKzLst5kM+8ytrLGzs0O3WmLt8gaZfIXRROS7v/ED9AYjW7tHdKplirljfF4H1WKZfrvCpdvvYNBLDCbgdthQ+l3e/MY7XF6ZJVdsMOh1we3A7rGj1+sI+Ny8cfMSOzs7HO0dUMyksZr0eP0+0tki04nArdt3CQf9bFXLDFWV69dXKVdrHN0f0qgWGA77nOxuc/udb1HOndKqNFlanOfSpXU++uwBoykUa2VGaplmOYPFZWfl8iWsFhsZIJ6aY6oMECdDskd7VHJZtPGUYadFLHSTSrEMCLj9QRx2B/lciUgkgdPjQhkoDBWFeiGH79ItNASUTpXk/DIGk5XxVGR24yqReAqdyYYoCDi8QcYI9NtVwtEYoUAQk8lCtZDl/Z/9gkLlGsdHR5h0Agajlb3NpyDAdDomfXSA3R9jbnGJ0WiEaHFinWhcnQ8SCnjPszvxq//9vsqmfNFb+1qqyoXW2qt9uPO1069fe7F0+uKHxivHvnRIv3C282v7CpPmta8QsJqNWCYyT++f0ZerTEZjdJKO+dlZ7E4PxUKRerXC0u3rlKJhnuZP8DkdxBJxCukcD+5/Bhrs7j1jbn6NWCJJqXiG1aYnnT2i06jj9IQQJY3x+NwPT25XmVlc4+137vDo4QOOD7YZqwPCiVkiwQjpgxPWrizz+PETcqcn/M7v/R6Vwhk9uU6v16fRHaH0FC699W2+9913qdbq/P7/+u9RWhXeefN3cNmdHB7ncXsD+LxuPvjxH7N255vY3EHCySTaVGM8HBH0ebF7XPTbLVKzKZo9lVq1g9npwxMIYTdbiAS95HM5Fpc3CAedfPTzP8UXmWVlcY6uMmDvYI9S5hil2+Gx2YwoSTTKJdYvXcHhclMsnXvNhWYXaVVLvPOd71Mp5KmV8riDUZR+H38kQbfdIqdl8AQCVPKnuDxLTDWR3OE24eQ81Xyas4NjDDYzPaWL0+XDIPrRmKC3OMmnT8hnMnzjO99BXb1E+uSIaCqB3GkyHciMlQ4GHWRyGSYYkHR6msUMNruZbl9FHWskltboNBpff7P8d8avPeDpJkMqmQy9Xo/88XnP7eRgl167zuXr14jH45hNFmLxJKoGhcNthgOFYb/HdDKg26qjN5nx+oOY7E72njym1ayTMIiUKmXy6VPq5QZmuUO33cXh8aEzmygUCkhM8LgdXL+8TDiZoJg9JRr00zLoaTXr7J2ccXh8iNrrM7s4T6fdoJY7ZnPLidxuYZA0rt+4QcDjxuuwsLwyy7OtA3afPqPflVG6HdSBytbnv8TmCbBtNVIp5HD5fCyvblBvtGk22ownGtVGF5PNjdFixmQzEIhEOd1+iqQTsDvslM6O6KlTPv3oQwrpU37jt38Xs0HHQG4zs7JKJJXA63LT7fSxOtzEExHajRrVYhO130PptGi02uTKTe59+ilTbUw05KfdqCPodYRiSTwO27l1z2CMy+ZC0Ov57MNP8YcjBEJBLA47OwfH1Jtdrly/gc/nplqtYjKZmJlJMJUMrF+5ic/jZjjok+sc0223efbkGTuff8zixmW84TBGk5mrVzbY3dsmEU8+Z8L6WV2cJzWToC93ef+XnzLodUktLbC3O6Veb+J2O6gXzzAZHHQ6MtV8BoN5kcpBFXWgsLS8wlAdkJhPoigDxsM+kkHHyekxlXyGxSvXUEcqvV6HyOwMeoOZ6RSsZiPNco5kPE6zJWOxORmNhwjjKYur6+w+vo9JL2I2m7G5vUSiYaqFLINBG3cozEbSg8sE04mH5ZkwVqv5PLt7QRS5oIn5onX3teMIz0HrxfzbK2SSrzTyhBftwK/GK1j3XG1F00D8ElyFi1nmxVP/Wc3C59VUSZK4tJLgIN/CHZ/heOsBbl8Ei8HAoC9TzZ9glGbYOTolnztj+coVDE4v20d5JJOD1Y1rePx+uv0eRouOgQKF9DGLczPMzif44CfbjCdDltYvIQkSxwd73Hr7bQLROJmTNIJowOdzYne5KVdaPLr/BIPJxFTQuHb7Jq16nXqlzre+/S1+//f/kHyhTLvTZSA3aTVqHKbz7G1t4fR5eOuttznNlNndPaJWaTCV9GgGGzani+17H7Jy/S6KMmTQlxmPhgiSDo/bzezcErVqhUdP9qiVqvTVAZFEnKOTHN1OE7fPRyR67k/ndLsZDVUKxQLx5AyCqCMciZE7O6AvNzAYzYzUAR++91Oc3jCDfgelr2B1ObG63NTbXSS9ESQ9bo8Ht9dHKXtCam6Beq3JQOljtNjIHh4QjM3Ta8sMu318gSiF0z0sziCq0kMbT5mMJ4RCfnwBH+1WHaPVjtlkYm15Gb3FjsmgQ2/Qo6o6AuEoYyTC3T6tehm7y8ug10RVmjx9dI/hcMpUm9JtVP4CT/m/ePzaA95v/eiHbB2kEQwGdHoDnmDsvO+gaYDEw/tPWV5aITWT4Oef3mP1+m2MFivjsYZOJ3BpeZH+CLa3dzCZrJgsVlbCIRLBAM8eP2D3849BFPHF5hkPeozHQ/pdC41KGbPVytrtt5lMxxQLFVILq+hMVgZqiXw2gzrR0y5XsVht1EsVCrlT1L5MMX1Cu15CYIooSbSbNUQ0mrKCyeZgYW2V0VBhZWWJltxEbtUBgWeP7qP2+jhcfswGK/nMMcuXVvH5/Dx9tgN6M2azGW18Xsq1e8K0WzKK0sPlD7C2ushsMsR/yZ7x2acfMeg0GKkjgrEb5E4y5LQckgDrN26zf5Qmu/uIcHKB1ZU1jDqJVqPB/kRDUccYJJA7XZqNCjaPl2giTKlco15p4vGH0JtNaEOVH/7oBxSLZR4/fIA3EmWiDsidHDFWFTI2G5PpmLe+/30WFub46POHON1uQoEQbq8fdWpgLGjEZxNsP7Ej18q8decW6UoDyWDEYDDzs5/8FG0KwnTKkajRlvuMhiqSQc/CzCqiZMDj9zMYT4n5w/zV/2WZe482mUnNMReP8MUXn2P3BcidHdNrNfAFg/T6XfxuN063n3Iug9UXBlHCbrHgclj5fO8Z4dQcVvsURB0riwtsP+uSzZ3hcHrR6yRis3P0hwrdTh+z1YXebGVmcRkB0Ot0ePwhbI4A8UiEoTTlztVFRkoPp8OGwWB4TlQ5v8c1LmhjXgSUC+QV7eXOi/BzERVfLTaeE0u0L5mbF8Dxayud8IqT+utUA+31N6+psFw8fn4mzuXLY/KVJnff/R6iKFEq10nMpvCFw5RLRSwOHw6Xj8lkcm7K3JRhOiUYjmC1mun1FTqdHuV8BqfbB4Iep82G2W6jK3doNNokUlEcXj/NjoInOGYwUM6ZrGjUWy1EncTe04fMrKxSKNWYDFVWr1zHHwhjMjkxmW1Eo2FuXg/ws7HK2d4Wm5bHNKsVyul9IvEUvmCYs6NdXP5ztZRS9pTk0hpWCW68cYNspc1nHz7BZLXz8N77DIZ3SKRSFMpF3CaJ7737Bp98fI/tB/dwuDwMBjK9doPxcIgm6XH4g+iAg+0tSsUKZpsdi9mCyeIkuRzB5/NjsVrZefI5jfEISadHBOxmC1arjW73nLwyGo4R9TrUwQh1OKZaq9GsFChljnGFkgSjCQLBAP3+Io1KFoc/gmgwodOLaIKFTqtONBbFYrFSqVZAkJCbLe598QiN6TlJy+zA4wuTa9XIpc+4+863sdpsPPz4PeYXl7h68w12t55y9OwLbP4IoihgMv7/FqJ+7QHP5bCSOT5CbzTicHjwBsKY9DpCV9ZxOx3c/+gDTBYTja0uh48/58Zb30STjBRyp0jahEuzt4jG4mzd/4Kdx49YXl/D6/ZQLjcxmG288e5v0pFl5hdXqFcq57NhJ+fsSXXoQG8w8ezBM2x2O9/41m9yfHZGs9lkbnmVnqox6LYxm00Y9SIer5fpUOXS9Ru06hVO9jdpdeo8elyn2+kSnp3HZrUh9xU2bt7lrTdv89mDx7h8Ya7cfhOXx02zKVM4O8NqtyIKAgdbW3Q6HY72nmH3ROhUslTSB1icXmzuAFtPn2Kzmbl+5y1C4SCqYsUbjjKaQqOURRB1yN0+eknEZrdSyBcpFYvUa1WmCJgsZu5/9hlGk4VQJIEkThkG/bhdbgZTkWazTqdR5VNBZDhQaFSr6I1Wup3zksaew8Slq1ep12q4nHb6yhCLxYymqew82SIUS2GzJzg8K5I7OcZ+9SqnpRKZ0zM6zTaR+QUUdYw3MoNF0iGJOhrFCietOkgAAt5wlKnS42hnH53OReZsD3/Qe15eev9DltfWUSciu5ubJANv4wvGaXd7BJx2PN4QOqMBny9EOX3EeKjQV4bk9Hl8kSSBYJhM+gyzzUlPUdEECZsrhM8XJhQMsLW1y+MnXbxeH16fh6E6YjDoMxiqjDWBajGP2+3FZLQh6k2sLqaYihO2nm0yHk7QTQfYjCYGvS4elwOj0Yj00vvu64cALsYrlUr4ssSpCV89/LVW3guKi/DiRbu46PUTf9nLu7j1pXj161/25YlfnvOFjotRr0OcqBwdbpOKR4kk5lHGAi6nE5vTj9If4va6sVhjPH14nwWPH1fYxScffEi9mMdoNtKsFjHZnEzHQ4I+F/6An2arg8vlxRkwMkaj2+9x+fplHn76kM8++IK51UUkycDR7jPmV5dJJmfRBj363S7lfIl33nqDrZ1ttvcVYIlRv4eojdHrJZyBKPN6PYmZJNFk4vzvWhK4vJjCMPkN7n3+CH8gxFBuow57LKyvg87AYDBgPBrhCYToyW0Gah9lOKDdajIcdFmaS7Fx7RojJLrNCrHVNc4O9tBJErnTQ4ajIYuXrhAxmmlXa4yGOqrdLs1imulkxFTQI5ot+GLzhCIJppMRnXqVcDSO3GrR73UZqwOUgUqj3kCS9DRrZbyBAEtrlwjH4giTCf3BEJ1Rh9FixRtJYjBaUHstIkEHjXYfuabg9YZYW18lV6nx6S9+Sr/fZzhUGQwUJAn0RitWpxerO8RwKlBvVpmMRzSrJU4Pd1nauIEvlmKKSDw1S6VUIhYJkd7+7M99zv9F49ce8P70Z++jaSOu3nybS2uL3Lv/iEI2z0LqLvV2j3q1yoMPfo7B7qBZLvDgw/cxWSxMAU3QcZTOUShVaTfKBObnabTqNBtNxoMhitLj7W++hd3jRC8aGI+GJCIBRsoAud3EYjGCICDprQiCgU6vx9nhPqFwAlUZMB2PsDpdzM4vkkrFKJcrrKxdwuPx0um0MVk9WGwu+j0F6LK6tIzZKPJfdx4jCSLvvf9LSsUCOoOB8XhCpVhkrAnMLM4jt7sYbS5MJoleV8FoMCJNhnhCYaaDNi5/hPjsIrtPn5I/PsYbiDIcqZQLOUSDkVg4gclkQ5tOmJ1JofZkVFVlcWEORR1QKyqYXR6K2RztWoXU4grDqUYlc4bH6yMRn6HRaoImoLP5UCcCk4nAoNvBarPhcFoJpVLUWzIff/ABAZ+bhfkZ3v/4Pqury0SiAQwGK0azlWqpiKBrMB4MkOUB5XKN0ukB3373e3h8Pp483WE0meIOB/nswSa9TgtBBJfbRyy5eE58qY+JJ+OIOjDbXfTlLolomGDQi8tlpl7rUjo54GxlHrk/ppLP87hWwxsIYtYZMJuM3P3GOxgtNtKZPDa7Db1Bx2g6QtLpCEeieL1e1MEAs/FcfcXhciHqRErZM1bWfojFqufZg4dMJlNis/NUKhW8Pj9Wm5lavYrS7+Mwmyg1SlSLJcxmO7ubT4m/sYLb78FkMiKJ0oXE6EvAePnuqzj0ai/vuVTYV0YLXiOjfF329mWW+Hp8CWbCa8njK/2+10uoX8NsETi3DvI7jFjNFg4Pj9EkG61GBaNRRyGbQ2/QM51OaTbq9Ls9NEHg+vVLDCcaT+59jD+ygNvtoFwoYDBZyJyeMhI/QUNPt1HFGw4hTDX2t3cZJ2X00pSr19bpKCrqeII2nbKwtIzb7WIyXiebK9BoNKnICr0hHO89pCt3KBfOKOR8mGxWTNIU0eVGkgz0Ww08gRAbKwuszoQplYpo0zHtRgOL00+v22YiGDGYzOgFDVEQsVmtOFx+BkqfUrmI3K6RPyxjd3gQRQGrxcTc3A1a7Q6TqY7kzDzJZIrjk2NGgwGNYh6rw0e9dMbM8mW0UZ/dR59RyGSwON1kDzax2h1YzXbkZo26yUgoFqfZbBKIxCnk0hxvPSSYmEenN1LInDAcqfQbNUKBAHJXZpApoA5UOo0SRpOd8VRi58kj1q+/ydL8DE+fbmKy2ihVq2jjIYsbV2g22rgliZ7coJI5RunUcfkiDFWFZ48f4QuEcfnC1OtVHj+4xxSBfrOMw+Gk126y12n+mc/2/574tQe8/nDClVt38Xo9VBpNapUqtVqDjz57SL1aYWFtg2+8fQdV07j30UeI0zF3v/kdHjx4zN72Ng8fPkWajphZXsfkcVAplXB7/YRSCXafPWP72VNEo4VmpYLT62MyHdNVh8ytbmB3OZE7MkqjSCQeYW4uSbvTxmazYzQYcDst/OL9T/D4AgzHYLNb8fvdFEslDp89wBefx2CyUCtWECUdVqsZl81AMBTH6XKiiSKiJDEZjygWcjTLBeaXVjEYfFTK527GgYCPZrvJ4solbA47udNj4rPzzMzN4vEEkRtthoMBymCMUa+nnM0hGS20ajU6zTrz69cxGE1k0lni8TDfuHOdrb0j6s0O/mCYVrPFZDKlUSmCJNLptDHbnKgjlWr2hGr6iODaLYZjjfEYrr/9HZbm4rTaTXYPT6mXSqjDPu1mk4E6pF6r8sUXPdavXgH01GtVkrMz9HoyXbeLaxvLnObyjLpt5mcS2KwWfvKHp4iSgMuzznA8xWLW0+120BuN6A0S2dNjOo0S19+8Q/o0R0fuMb8wQ7pQRVUn1GsyXrcLu8vFycERwXAYgQlDVUHudtHpJUTG3Lx5he2DNEaridnZJMVyhXq1QjmfRhQ1hkOVmzeuYdLfZjIZUa3W6DYbzC8uMhV0FEoN6tUivVYLdBKNWgu/x0O9VCKjZJEkCRgRCgfwe92onRpvrl8j4HVhNpue778QL7Ok1zb/mUnfC9Dj5Uzdi9N8WWD8CkS9fDkH1BdI9qpzwpe8FeHF7ucM0VexTdO+/OLXoVN43jQUBZF42Ivf56NVrdHt95DQODnYR5iqDGSFSrXGdDKikjli3yihCQLKcMLVN+7ic3v55POHBCNxNi6v8cUnH6MJkJyb5dlnWXqdNhsbM2zMxnjy9BmKqtLttTk7OKJeb9HIn/KLH/+Y2MIK9XIes8mCyWyiUChRzpcYdmVmZxIEfS7MZiPp4xNcbhc7u0c0ml2moyHlfJaDkzSpVJJ6vc3129cxGkw8frxNV26h0+nQSRLqUGVxIcWtS4s8RSN9eozPbkVIJnhaLtBqNjAaBTr1KsPB4Lyv1azywXs/Y3n9KgIGauUCgWAYQWeiVtJjMJhwBeKMxhMMko7paIw/Okev00ISdUSTM2w//JSW3EXpK0wHAwwmKzaHB5fTg4gBbaoiTjX0JiNf3PsUUacnPr9MPJHAc2mFj37xC3yhKD29nszZMf7AGwiSgW6rjjBSqaSPsVqsRGbXUEdDBL2e4RRMehN6CQbjIV5fFFEnEZ1ZpFbKonY7LK1dYfNRnZO9zec98P8hHv0rxVAdYDaZGA6HPHi4xc6DRxgNOsKJFIO+wve/903cXj/3Hz0jEIowv7CAyWJDr5OQ9AZmlje4srGCNlT4kx//MZPxmNs3b2OUBLanY0Sj8dz3qdHgL/8//1/Um00ymRPc3giy3GHQk3H6/URn56k2WlhsVtqyjNIfUq9K2MxWaqUyhdwxK+trhLwOfv4nPyF7vEdvNEav0zNWVJKLl8nk8zytlPGHIyzMzVHttMieHeCOJInEkpiMRoK+IAa9jslExWQxMByPON3bJT4/h6CKdJp1FhfvEggH+eL+Ng6nk5VLGzQ6A1ptlbmV9efZYhazxYLNZqVcq9NVVSSzmUe7x3z83s8wWBxYbA7KxTKaIODxh7FbzJw2a8QSSUIhN82KG7PVhlGY0G9UmI5VJpMYPUVF6Q/QRkN8oQhyt4fN6aLTH2IwmamVijx5BBO1hy8cQp1MOdzdRi+K6EQJVVGRW226ypDBcMoUkWg0is/rZTQcce+D90jOLuJw2tnd36d4dIyEQjFfpF4q4vMGiMWTHBymqeRzxOMxur0uZoeN8XSKy+1Ck0TG0zF2u49uq4Lak/no43tkihVq2VO0kYIrFMbmsBFPpTjaeoxpbpFStU4xk6bZqGG0WOn3+iCI+F1mjrYe4vQF6dQqTCYjpuMxrXab6bCL0eTE6nBy+/oaiWQCnSCwErpCIh7GarWgk6QXKPJl9vV6OsVF0HlVVeVlDvb8HC8JL/AyA3w5vH6h7/eCgvIlGfMCI+YCE0V4Lf97HQD/IqGhnYvDCAIOq5FGtYzRYsWgM+CMJOm26qzMrfDwwRf0mzUsTjtjtY/calJvtCmkT4gmUkg6M6Ko5+zsDGcgyNqN26jPbcIknQGny08iGmJtPsEEHfcePubsLIvb7+fNb36L7MkRX3z4Pk6XnVAsxuNPPyY+u4xB72M0VphfX8XptCOIAssLSUaDIfVOj+nOPpndJwRjM8yvbfDw4UMaskKzUcdiNuLz+ZCbBVR1yKP793m6vUvlcIub1y+TCPl49myfQDhKPBpHpzPhCRUw6gVWN1bQC+u8/5Of4Q/HWLtyhYeff8YXn/wSq8WOxgi7y8NEadFtlpGmA0wGgXrhlLvf/i2sTifVapVuR8bt9WOzmHFlzjh99jmBxArTyZTJdILJasdmd9DrKvhDQZweHyIwGk6Q5Q4ubxCj0cBQHeAP+hGNZuweCUVus7m9y1Dt0mzWsftC2EMzdHsKqUSUcq1Gp15CaVbxzC7h9LipFMqYrTZMJjOdaQu7w4HX52NhZRWXx8vh4T6hcBRBkjh6+NO/8D3058WvPeCFw2Gy2RzKoI/b72dueZlgLIbLF8TrclCry3z0y0/p9Tv86Hd+RLVS4+GjZ2jClOhMitFwgNmoo90f4w3GCPn9zEYifPzgCVZfEJvXT2p1nXqugMvtxulyY0Di6eYmOkmg25G5ducmmZMzMidpErNJEESOtp/h8fmZXVpi/9kzNFGH3uyg11OZTaUonh7xxht3qdfqHO/tEoz6UXodOnIHk91BJlugWMwTDPpxBlPks0XmllZZTkU4ODrFZrNjNhvw+XwYzQby6RP8kSiNcg5Z7lIuNzjcfUo0OktyJkmxWuf0sMHq+grra8vky3E++eWHDPtN2pUihf1tPHYL6miM3OkQ94dBEJhMp9icXox2L6PxAIfTjdNlQdKJxOcWuPPuDxEFjXyuyGiqMUXgyeYW6Z0nzK9eZiiYaDZy+AIB1jZWOd7fYzQe4QuGYDJmY22J4WREt9VAJ0j87Gc/p5w/F77OlFtUikV6vT6azkynqyL3+giSAbPdgdPhQCfqSS3MEo340SQTHneAcinPzuY2tVoNQZRIJaPs7e2jdLrMLM1g0JnInz5GVVU83iCXrl7l5PiY7afPuH73LRKRMA/ufcz8ZbAaLfR6fayeIFNBotfvUcpnSSaSJObm6dQbnB3sIJlt1Kp1XE4bsxtX8YajhKMCp7s7TDQRvcFIt1U/9y4bDricchEJeDGbn9v/wPNS5HNllIsZ1ivtMeErGy9yTl6WM5/HRRD8uvGFr0LqBXkx7dWV2it9uRfV0+el0lfnJZ6/vgaGL5JPQcNiMuIwm5iKFgaKitvtpd1s4XDY8QRCrF++zHQ6pXh2gjadYhTh2s03ONjdplIsEQgGKZzu8Pn77xFOzWG3mtEZTCjdDr2+wuZRnu3dA1SMzCwsUsiesbS6js3uwBdNcPXNb+D1OAknUuw+foJRL3F5ZZ70/haZkxMMRhN6s5XM6RGz80sUGz3MTi+RpIjL66cnd5hd3kBWRihjDadOx8bGBj6/lw8/+BhJFJEbNRqVEvcfTLl09RpGs5779z6iNxxhs1lBFJhdWMaotzFUhoRjKZLzM7gDAYrlEsXTU2zOBKIkYHc4MVvMnOw+ZW/rKU5/jCkiBztPiM0tUSkWKedOkQx3UNUhE0Sc/jDBRBSlN2Qy7iNMJyhyjVa9RLdZZHZVot3uUilmic0sYjCa2D84gmEXs8nM8kKKw/09+t02a9ffRFW6dOUWrUadodpjduEyLVnG4XSfJxi9NsJERW7WqWQPsNuMWFOLtNsN9Exo1ir84k9/ymQ4ZKA0mQgig17v6x/s/53xaw94VqeXQqFIev8Zc6vXuX33NiazkXSpRjTip1pt0mq3UJQuJ5kSmcMjBkqbO9/+Njtbh1QrVU6yRXrtLu3egGBIot7uYrO7GE7g4PFjhmqPq2+8xXAyodeR8bhd+NxuqvUqTreH1bk5hsqA3FmGYCSG2WBg/+lT9GYrvqCPA8bYvH6sHicTQWKMyOqNtwhHopweH+H2uHG7XUydVp4+eMBAGZOYS1Eu5fm93/0RmmbgaPOAYqnKaKRyfLCPTjLg9XioV6sYzBaGnTYulw9PIIzEiLDHiUmnI3O8hyccRe0r5A+f4Q+5yeQc1OplWvUyol5kPBjjD0ZJxmMIOjPiZIrRIOL32BgmQnjdHvZ2DihkMly+fRt/yMV7v/gYq9XBjavrhLxOPrn3kIcPN2k3m9idLsajEfl0GqPVBmMFX8hPvphlNFRJpGYolyrYrA4iwRCDoUpkdhm/w0K+WEZ9brckAIlokNO9Ke1Ona1tlXL6iKs37xJOJNg92CMUCXF9fZHpCP7jf/x97A47/V4Hi8OJw+GkWWygF3Uk4nEe3n/M1sPPOTtyITcreAJBlH6XraePmEzh1je/x/X1BTa3dhE1HZOejN3rAQ0sNju+YJjT/V28gRCJ2XkMRjMWp4dep048GkBTu+w8vE8gkULuHpGaXcTtdZM7qeL0BvDFEzQrZSKXZggH/ZhM57N254D1IiPTXseZP4+38krl80tc+ypb8+XsuPYlJGkXsreXoPZ8sXYhw9S0F1N2L8YULn7362tfgPBXWaLac0KNJEmsX77CR589Qul1yKZVREnHQOlTzWc4tjmw2GxMBT2r19eJh6PojSZajTqioHHz+lUmI5Wth5+jDRQGTHA7HNx99zvsbe1xdnzIeDhAm4wRJB217DHSZIhgsDDotkkm46Rm5yhUWpjNTrzBAE6Xg5t33mZ/Z5t+R8ais5Av1jFYyuRyeZw2C0YmtCtV5H4bi82CxxugWipx1skTTmXx+0O4AxHE8ZDV9Vvcn04pnuzxJz/5GdfuvEEwHqFRKbKy/DYnO9scn5xhd7gp5tPoBYF2d4gmddAJEqFYnAkjRiPoNGt4PPNs3HiTo+3HnGw/xBdNMh4O2HnwMVZngEFPJnd2iM3podusIepNWC12enIRSSexsn6JbrOO3iDRaXfYefIQs92JhkZ67yk2u5OZZJLH9z5iaLUyGig4HQ52HmZJnxxhMNs4fPQpsbll9Do9mYMtRgOVjtyhXS+RXFjDF4jQ63XQmyzUK2Vm5hYwGo30Wl1mly7x9ME9JBH6cgfXUEF4fR70/2L82gOeMppgsVqxOZ0YzRY++/RzBv0O9kCYWsGAJOkRJY3ltWUS0Si9TpdipofdZKNdb507Y0805E4bs0GHzmRk8+CA4tkJJquNfkfGbDPi83rJZzKkD3ZJzS0giiK9dhO73Uat0aYr91H6CsViEbvdiagzoE0FFhJR2pc3+PiTz5AbdSw2K/1uhze/9V3S2TTtVoPLN99G7g1plrPoJB0ut5PRcEC/0+L99z9DmELueBtZDpDPmejWyiTmV3DazRzt7zMZTwnFZ1FHI2xOL4lUivmZBAvzCzz+4jOKmQyTscpAbqH2ezx9/JiT7cckl5cJhOJs3vuMhY0riHojtUqZ8WRKwBPk0b0vaDWr3H3rHeZSMVqN2rm4r8VIu9WhWWvhdTsZDwecnBxis5ux223UyxWsVhdvvf0mBqORz+8/wmq2MB4KaA4H4WiY4+0tJoMh+ydZFLWHxx/kzTtXqFTb/PxPf4leB+tLKZReD4vZQiQWo1apIMsdqrUyOquV7NERVv2U9YUUR4dH1KolhMmQ22++idzvs7W5h9nupFBrMZ2M6bcbGEw2LFYLouBjZm4BZTim2aihdrt0u32K5Rq1Wo2Z1UukklF6PRmr1Uq5kgWdyHAgs3z5Cu2ewtn2PqKkY/7KDRqNJrVaHbPdicfjYTieovR7jBSZ+flZrtx6g8lQYcY9Szjox2w2IQrnPa2XNBLt9UxLeNmAu5BX8cqPC1nWlzD25cvLrRd877SLOPjSu+4CleU1gsvXxZ+NwRcBFF4F3S/7f6IoYjdLpJYX8dmdHJ2eUS7msQ7NTCdDSpkjrty+xXTYp1ooYxCtFIt5RGHK8vIS06mG2WggmkhhtjsRdDrmZ2aYT0WplRtkM1lGoxHheAq90cRQHTK/uMRkqnH/o0PuZ0+ZShacHjdmhxNRMvDpg8fkTzNc2ljHZrfy3vsfU8ufYTfrSSSThPx+TDqBre199EYopk8ZT6cYjBLKYMLezj4ld51Oq8X165cIx0I8fmIntXIdqzvA9s4B6OxM6eJwWLly8ybbu7soXRmj0Uj+eJ+RpuH2hmlU68wtLmB2uKhWKgzUAQe7B4QiERLLlyieneLxhbly9Sr3PnqPRq3D0qW7lPIneB0mLv/gL/GLH/8B+bNj5pfXyOcyNMqV8/tSbuP2B7DZncitBr7ILNMJ1MsFHM5l4jNLFPNnNDoykXiM5OIG9UoFm13BYHZQLmSxeQLU8yco/Rbf/M67fPz+L8gd7zKZaPR6XQSdkVajjtzpcGltlaPjU8rlKlZ3EIfTgc28isfrx2A28uz9/+PPvJt+1fj1B7yujCSJWJxuHG4nyUSEZ4/u023UscVmsJrMfOvb32B9bZmP7j1lgoY/HCFbKKIxZnVtBbPJwlDp4bYZsFrMdDpt8sf73PjWd+i3XZTzWZr1FtJkQjI5Syye5HB7G22ksLC8RKVa5fQ0jdPtp9vpkD05wWI2EU8l2dw5pt5o4wuHyexu4nB6mFlew2I2Ind7BOMzZPMFBoMhVrOetWu3sFisjMdjUvPLjKcT5Gad6UjG6ZojFIxwNhwynUz4yY9/Sr/XxukJYDYayBztEYqGMZhM3Hu0RblSY/HyXXQmM01pgtMXJhIMU6q3iCTihHwBXA477mCQ2EwKnV7iZH+LZkum1+/RbdXxRSJMJZGpKGKwmqiWizgcLvSSEbnbYmd7h73tCcXMGZfuvo3NaOLZ5x8SSswRTiQRNY2FlTWS8QjZfBGrIDIVz0kISBrNXpv8yT5Om51iqU6r3UVnMPPmmzeo1OqcZnKEZxaIx2JoQHpfY+fxZ3TkDv2+jKq0yOZKjDSRYDROvZBFZ9ARdUV49ugZU0TyxQrFbBYBmJmfx+5yUatIzC8s4nJY+OCTIU8+2aUfi1Mp6zg+2MXlC7Kzs4s2GTO/tIKqDqhXK+j0OrafPkI02ske7WE0SCyu/yUGioraV0gtr7O2vsqjLz6nVMjj93q5fv06JpMen1Mg7HOeg91rKioXJcHO3wsv6f7ahUVfKRO+El+TDr7I6F7WPS+suzC299Im6CIgXjzN86qo+PLzhX7jBZLKxc+vguVrpVRBQJUbZE5OsG9cIRwO01dV/PE4Ln+YfDpNIhymuX6ZWrVMuZxl0GvTqNWQJOncJb5cYvXSBnJ/zPbjp8zNJPn8ixKnu5tIBiPDXpf88S6ecBxJ1KiUy9y6fZtGo8mze+/jMEv84O4GzWKGex98gMfjJpYI8+D+5zh9QXrtGuOhwhgdjWaDVqPBm3fe4M5bd6k32uzu7OCwObBZLDw42GEoN1j87vfo1iTuf/YZM8srKM0S2rBHLBbiLNumXioSisYpV9u0+iqj0RBPyIXd5Uft9ymnTxBFA3qjmc3794jOLWO22WnXqviCUTQELFYnHn8ci9XF3tEpg5GG0SSxdvUSEya43T6SyRTzqxs8/Pg9hkMVq8vLycEOs2vXiM0vkzs5QOm2GQ161HPHeJMbuD0uxuqA9Y1VHB4vks5ArzcglFpgzCl2+3lfv9MogzYkEAzRlWVK1RaB+CL5s2MYK2jTMf1OG6PJQDAQYDYVo6cM2f/pH6OqAxDnmY6NdNodrl678d+4n3/1+LUHPLfHyRQRg81JvVbH43ahTaaMh0MMBgOT4ZDjwyoaIluPH2D3+InPJDk4PEIdDmk0mpTKbTrdPm/cfYdwLMLu5hZGs4VyvkxP7hKKzTEzk8JsEBmNxwiSnlAiSTyZYi4VpVAsU8ufMLe0isfjpdvpYxD1BLxuPv7gQ4IBL3NzS3TKNRaWFknNzSH3+hTP0ji9QRqVAsNBD3NyjrGqkC7ksdhszCzMUyyWkFstfvhX/iqi0YbS73P3m9/E6fLw8IsvODmQQZBYmJ9BJ0woFLPsHp5wsrfLQOmjMzsYyh1ECVYvXyGVilMoF7nz5tsszc8xHg05PDigWq0hd9vUKiXcwTAz87OUC3qmU416uYmiqri9ITzBCCNFodtt06oVcboXEcVzzza5JVNVqkw1DavDSa5QoVIoYfN4abXOdf8GvS4uvw+z0YzIhEGvh9FgxWzQ05d77G5uIXdkHjzZRBmMqRcOCUSTCNoiGhpWh5uVtQ3cHg+nZ1mOnj4iX6rTqJUZ9mTmVy4h6UxYnTZi8TBPvvgUdThi/ep19Dqw2O1UqhUa5RLbmzuEI0FEUY/d5UIQxly6tEqr3eTZkyeYTEZ6co87d97AbtRxdnaG1eFEGw3whc34InGUbouT3T3WL1/BbDYz7PVJn5xQyaXRW+wc7e1g0El86/oCgaD3nI35fM5Oe41u+aJk+OfVML+0CPpvx0vaytei2JeZl/A6Lmlfyot9eU3na18dmXj9XK/+Jn9eBENhLLsFPvnlLzAarXSaNUajAe16DZ0oUa83MNuddNM5YiEP4UiMvvwZx3v7SHoz1UqVaDhIamGF7adP2HrymIXVVZZXlrhx8zI/+a8/pTeYIAx7dOplShYzjXodVRkQn1/H5/ejKCpLM0l++ce/TyTg5p233uH9939BNn3MxvXbpO0O4skZzBYTTz7/lNNsHqfTxebmDnqdwNLyIvJA4eQwhk4Q6fd6zCyt8pM/+D8pnx4RCCco1+t89t4fIejMmCw2tJGCThBxWc20ykUkYNAb06yVCcbjWCxGxmMP41GfSvaAq3e/zXSapFHKEQqFUJQ+vW6T8XiIOhkzHg1ZWrvCeDSk1Wpit1spNTpokgGXL0SnVUdvMiHpRPae3cfjj6HXm7C63EhSiOlwSL9ZQieK3DveY2F1A7snRK1WJX9Uwex0029VcHuduANRDBYzS3MJQkE/X3zxmEI+izoYEkrOsLi2jjqa8nmrBToD+4fHHJ9k6HYaxOdWKGWOUFo1tJGD8skWivw/xhJ+pSjnMjh8YQRJT6dZZ3uzT3+osrBxjclozGioYjDYODo8IXe0R3LdTKVaQW6fU8r32y0sThc6USCbydNodRAlEaPViqA3kVy6jNlo5OMPPyISi7KxvszxWRZZGXJ5fQ2Hw83uQQa7J4A3FEMdTdCmE4qFLJ9+OKBayeANuskeHzFUFHojDVmd0Kg3cQaiBEMhTBYrSq/N7MwMZqMOVelTzOcwmg1YbXYknYHhSGA67NDuqQwnoAzHtBpVgvE4M4trNPtD9CYL/VYHr8vNIDlD9uwUi0UHUxWDwUgiHidbrHC4+QSjXkel02HQbqP0+5htVqq1CgvXbmN32JkCg76CIndZW1rAYdWzu7tLr9dloAxpFM6Iza8yMztHs1Gj73LgttsYWhyIq9cJRyKYLWaazSqVapH9LZVmpY7JakWnN/LW22+iTCbUWh1GowkjycBELxEI+bFazaQzJ0Tic9hSi9QbNba2tinn0thsHoKRBNORilkn8c73foAynj7PbhMkZxeYajqGgyHJ+QVanR61apWToyNURcHh8hGLxajmTtl69AWlUoRBv8utd76Fw+nkLF/B6vJw4403EAxGdp/t0O008XtdtFoO5tfXSUZC5DJ59nb3iSTn8bgciIJGKBFFHE2QNI21Kzcol+u0q0WWQyZiQScWixlJOncvfx0Ovs6U9fURAo3n6l6vNuJeHQO4kLx9yTy5CECvzsS9Ytr6Ml709l67xq98ulhXFS5804sa7NeURC9g72QyYmHlPIOpNtpMqiWsRhsDfQcJkaOjM6bamG6njk63QLFYAb0Fh8/GZDohMrtModpifkkjGksyMxMhnkySCt8m5neAIPGz9z7jzpt3OD07ZefJQ7745AMsrhClfJ5PP/mMZ5uboMH6rbe4ffdtdo6yCEYHV675cHqczMS/jdfrQB1D+uSYw+1N3vrmd7CYjBxvP+La9UtYLQZGao+FS9dwBvxUyw0SswssLya5duUKW/unfPrBL3A5nKxdu8HhwRH1ap1AJIDVbid3us/alTuMRwMMkoBOFGhXC0xGEyJzS89LzgKSwYzOZGQlHqGYOUKyWtAUhfF4TLvbQ2q2MOoktu9/yAiB0QSMFhtGRK5cvYbIiFy+iICGxRRkMhGQNI1vfe83KJeraHoLnZafk70dzNYcTl+EjtxFb7UzHA7IHe/j9LeQ212G3Rat1Bz1aolq7ohQcoGJ3syTx0/x+QO4AmGCodC5oW0xhy8Y4ur6Cha7jccfv8dIaWM0Ghn2219z//33x6894FXyaeaXlmm1e/TaDQpHJUKzizgdLvY3nxIKBfAGQzRadYwWK9Fogrn5FENZxu1w4Q8F2NvZQkPC6/cSCXkZDCdYPUHqtTpLc1FEHew8/hhvKEi51WJr6xmtao2C38/x4TGFUpG5lUuYrHZOnz1B6bbZuLzKjetX+E//5Y9RlT4+f4DTnWfsPLlPIZ9BabfQ6w0ovS5DtYs2HTFlDk2SQJAY9LtM1QELl9YwCDqOT46p5tI4vD7MNicmk4V+p8Xi3CKj8ZRmo8FQbnHnO98l6POQy+WRgKHc5ubNN/jFz37OUBkRikfQ6Y2EQyHa6pCD3W0uXb1JMXOGMBriDccwmIxU6nXaco8b125y5/Z1Dk9PuPdxlV7mjEa1htlswOawUq2eqym88/0fMlSmPN3aJpKMYTIbmWoTfMEAhewpeoOB2ZVVCpljtMmE4WSKKGjkTtNIegNmhwtB0iMYrPj8ZlqdFj6fi/X1dX75yw8p5TIkFxYRND35bJ6371zl1uUlHmwesHvvPs1yFpcvSK1apJQvnwsJxBPMLK1idxU5OTwgObvA6uoCfo+dQuYUl8vDeDrlpFaiWW/j9ic42n5GT25x/eZNTrJZBFFirDdisDnYuHqNG2/cRCdKiDoDQ3WIZDKTPTtFEjTG4wFmswWj0UQylaSQ/4jra/NcWlvEZrWeszEF4UtG5fN4RdP5ZTmTVxa8mg1+ffb0+oov8ebCnq9Mrp/38C6C5UuQ0i72Br+0CXpxzS/5LbwovL4G5BfZNF/+Mi8PtNmtWLoQCPipVxsEk4uIej2zC3NY9HocLjdKX2V/8zHpw11CgRCtaomrd+5iNlg4rlexWc202jL+gBuLzcTZ6THVWpNyNMTOYY7xFPqDMUgm9CY7mqDH4nBg8wU5fPaAq7fuIOkkqsU8mWyBs7MMtUKaH/5PP8Lvc5HP1/B5nDisFpz+II1yhXy+hNnuJDKziMVowGwxYdYbaBTzfO/bb3IgHFMrZNi4fg1NMtDuKljcPpKzCSSjCbffx97WA1yB7xNOzaFpU3wBH612mHqjjdHqZW5lg/zpAZVCEZc7CGOV6USl3eowUBSMVgter4e1S1fY33nG8dZDWuEUN269yYPJkM2PfoI3MsdkPGE4kDk5yTJRu9jdLhLJGcZTjexZhulERZmAYDDRqJQJxxN0On3kRuX871Fn4uxwF184TqOURxIrmC0OquUiFpsNtdvE7nCycfkSpWqHncf3qJeyGK1ORCbMzqY4evgB4WiIeqNJV25jNOlZ3riKOlJp1P7/nOF9+OGH/KN/9I94+PAhxWKR//yf/zO//du//XK/pmn8/b//9/kX/+Jf0Gw2uX37Nv/sn/0z1tbWXq5RVZW/+3f/Lv/hP/wHFEXhO9/5Dv/8n/9zYrHYyzXNZpO/9bf+Fn/4h38IwI9+9CP+6T/9p7hcrl/pet/9je9jtjtJZ3JMpxOii2u4PD5Cfjenej2Ndoep0UR6b5/E3AIOh4ud3QPMVjseTwC328XZ0TFGkxllOGaKDkUZ0m62cNpMLCb9eLxuzs6uE46G2d3a5eTJfaKzc0g6gZ2nDzDaXQiiQDFfoFkpsnrlOosrC4zHGpImsLq6wtzMHGdHpxSzx6jtNl6Pjxu3r3OaybD9eJdQapZsPstI6VMvFLh8/To+r4dOR8bjtmJYW0QSp+TPzjBZbDjdHjoOJxaDDkGEZrmC0WqjPxzxyecPyJ8dcf3GDTRBpNWS8QX8COL5A8nhDWE02Yl7jRxtGrh1/RLbeyecnZ5g1Eu02jKVXBphohCdiXKaK9HqqFy59QYiE37+05+ikyQkUaReq6L2u8Rmkqhyj3Jmn9FEwWqz0evKhNxObr9xh7bcZTCWGA0HzMzN0OsPiIR9uNwOVHWMNh5RyeUoVdoM5DqK3ID5dVqdPqIg0qmVsFzaoCd3yJ3mSKUijDQfxyentOplBl2ZVqNKX24yVPpEkkmatSr25SV60pRGZg+7zYI2XaMj9zDb7MzNzSL3+rSbLRq1GsZs/twEeNzj2OPFYbPQrZcp5H2gweXLlzHqdBwe5yhXSswszSEIOvQ6gUeff4rDE8TmcmCdcXF8coY47fGNO7dwOuwYDPrXTFy11xOkV+LVbdpXt38Fw54DzgWCywu8eaUHeGHcQbtwvhdg9ioUfl2O+dVr+tr4akPv1X1AT+5x76P7hMJ+pmqPUHKOQqmEXu8hEokyGk9Qx0PsvnMXCqvdjgiU8wXiqTmCwQjBoJuzXJ786TFnDjdqt8VEA7c/RDGXYzIakY8mzglEowlzSxtMpiP0RhNWV4Dl1WVmUgn+90oBl0lHMhpCkTv43A7a7T7b29tUqyUMRjPHu7tYHC6anXPilMvhZDAWCTu9/OX/+Xd59ugBjx88YXltg5/++I/5g//4f2JxhznYeozFYsATucPhwTGVXJ6xppHJZBmrI1IL64w1HTqDhVQ4xsL8IoJeh8tl4+GnH9GsNc6Fo/V6KqUCyWSCVqWCXm/G6gpgNNkQphOWFmbRGUQW164xHA6YnZuhXKlzuveUauEMpdsmoVtib/eARqXIeKSgN5lpyAq1YgGzychQm9KpFxBECavVTLsywGg243R72bh0DYvNgtVq4fGjJ/gDXlaWFnj84AF/8l/+AKvdRadWRq834p2LUT7bZ3V1lfVrNznYfkaj3iSUnMfkCNBo9VhbW0JuPfpv30e/YvzKgNfr9bh8+TJ//a//df7KX/krX9n/D//hP+Qf/+N/zL/+1/+axcVF/sE/+Ad897vfZX9/H7vdDsDf/tt/mz/6oz/if/vf/je8Xi9/5+/8HX7rt36Lhw8fvlST+L3f+z1yuRw/+clPAPgbf+Nv8Nf+2l/jj/7oj36l611cWOA0XaBRKTG/tMQYIyaTiWq9SUdu0WlUQC8xGvVZv/MtivkC2ZMDltYv02zVOTk+wu70YrJaSafz5LIFBv0+LruNSrnET9/7CI/fR3+oYTPqGQ96iKJIJJYiGAihN5uJp+JUC2ec7WyDINBTFc5OMlRKJTzxWTz+AMfpDP6Ah0tXV6m3esyn4qyvzOLxuqjmKzidAQSmtHtdJpMBRpOBdDpHr93D7XXj8rkYKQo6EZwOF5PxiHajgaIoLC0nKeYznJ0cMFV62MwmRGFKLBmnmM3x+MlDguEoE7VHLpdBZzJxms7TbFXRm8xkqzVanS6iXoegDSlmTigenyBMFAYDlcOzUwrZLKvrSxQKOdRei4WbbxGLJSlmcgSCYYJuH85EnOO9TUbdDnq7g267TVbpojNb6MttCsU64dgMBqOJvZ0d5E4Tl9vF2eERfauZXquGIJwLJ+slASZjTk6zdOUu8dk5lhcWOdjdppo/Y3d7m6MzB2eHhyRm5hBFkWA4ykAdwmTK6uo6clchGg5iFDU+1KYUT/d5upWg265hs58/QOstmbE6JLk0B4xw+0NYTHpmZlMY9SKaoFHMnCCKeu6rAw72vXRbHdRhF0lvOmfkSjpEScdwBDqdFb3RRKfR4MpSnGDAh9FgeDkIfjHpulhk1C6CzUsUOt/4urLKq5//bCblxb3a12z9CqXktebgRRB+NeF8wbZ8bfj9JS4KL7HuleqsduGkzwfhJb2B8XjKWIPM6TE9ucukXUU/1tAZ9ThtRt66tcF4PGU0kVhZW8dstaKTRPR6E7lclXaric3nw+MNEgteZ2fnMeGAF7vVwMOPPyJ9sks0nkJTZdLHe/jiSQaDHq6AB6PVQrnRRmd2sLycojcUqcstur0BOoMZRAOCJKHTaSwszp9rqdpsGC0G0sfHPHqyhdvlYKwJBKIJ+p0m3f6AO9/6NtpQYTABXyBE7mSPTz/4gHA0TrOUJza/yGQy5OxwB7c/hC8UZzQe06zXqbrr6IwmsoUygViK6XSC0WrEaLRyvP0Uk9lEt9OmWfucXl+h12kz1SZY7HY63R7Pnt5H7fdYW18l3GgBU/zBEDOpGYwGkf5wRPrUyM7mE4wmE916haHcZNrTWF5ZYi7q4/NP72EyGXB5vFRLGYajIa1eF71RTz5XoFktITcqaKuXcfrDGHJpbC43kt7IoNfl0tIsv0jvMFA6fPP7v0Wh1qEnN+n3egwVhYOTj+nWcrh8kT/z3v3viV8Z8H7wgx/wgx/84Gv3aZrGP/kn/4S/9/f+Hr/zO78DwL/5N/+GYDDIv//3/56/+Tf/Ju12m3/1r/4V//bf/lveffddAP7dv/t3xONx3nvvPb7//e+zu7vLT37yE+7du8ft27cB+Jf/8l9y584d9vf3WVpa+gtf77/5X/8jPl+YaDJKOBSh2RtjNJlod2Tc/gD+cIh6vUEokcRkkGAywGA0Mz+bopQvsP/0MYuXb1Irlxm0y3z3t35EJByiWGsxmmgc7Gyhy5Tx+EO8//7HWMx6/vLv/jVcHg+Pnm7DVMNutRMMBpDQUavkyJ8eofqDKHIHowCffPwJ3VaTK1c3QNRTLh5it5goV+q0Ox1icwvMLc7gdTn5/IsvOOrIaIKZvlKl3SyzsjrP4eEx6YN9Lt39JqIoUS/lmV27RCQep9Fo0Os2MZv0WKwWAv4QtVoJvcFIsVRCVUeowwn54xM6nRaxxTVanQ7aZMr61Wuk0xm2nzwiMTNP0OvD/40AvxioHD/9jM0nW4wn0O32KOSLlPNZ7C4/kZkUjUYRg9WE0eFkMBgidzs4fGEubawj93pksmfUilXmZmbweHzsbW6i9HrIDQ+V9CECGpJej9liptNqkjk+wObxYtKZsFodmPQie5tPcXicXL56mZ4yoD+B2f9ve2caJOd11vvf28vb+75Oz75JM6ORRrtkW47tbHZiEwL3EghOYgqKIkASmwBJIFQlUCQOfACKAAFSVPIhoUxRcXJDbm6IHMuyHcmStcwizT7Ts/RM9/S+793nfhhNa0aSjQ1KDFL/Sl2aPu/Tp8/71Nv97+c9z3POnv1YLDZyxRLVSol6vc6h++7HoNUxcWUKvdVGIBShmCtgthhYj6Ro2X2AQjKGUhIo1To0GiPlao2FuRnWA348Xb0k4mE21uY5fO8JlCo1V6amERLojEZkjY5MPEkxVyESXKZcymBw2KnV6izOzaBSa6iWs8Qj62hNOswGHf3dTrRaLUqVEgmpIRRv5JYk0BCHrbq3hrRdv+PIdeGStonW9pdvE7Fruyts7ZCwlYyyfbWWrehzR9/bbdkuftfvze6Q3NfKWZG2vV4INFotvUMDmLQyJnWZTp+TFq8Lm1GL3qBDVqtRKjbHXK9v1gLWanXKVUEqXyIYKzCzpiK8sYyqrqJaqbC64qdaqjI02E+pUmZqdIJSKkrHsWP0df4cE5PjHBoZQFHNM3HhHKOjU1TrgsDqOs+/fAmL1YbN5kSpUvPi6R/jn71Cvb6LtrY27C4nJpMFh8VEJJaiWqzhn7nKt5NR+nYNMn35VXp3DRAMx1kPBHn04Qex2e28YBglk0pRzqTx+TpRHIaZK5cZOXIvre0dLM3NodXocThdVAs51pcX0BjNBOanMeh0eDt70Ki1KFQqJKmOVqOhd+gAU5fPkElEGNgzwvzkZc6+9CJGh4dUeB2VrOb8xVHc3lby+TzZXI5wNEo0HEapUmJzevF17qJaKaLRVjDqZFKJKMlImPve9xiryyskwhs4Wtqo1sosT15gfcmK1eFCqtdIhINo9GbWV5fJZbNY7A66OztIZSpkcykWl5axOT2UaxJroQRStczu4UMM7h1hcnqWiWSEYjZJz5FD3L6lo2/zHJ7f7ycUCvHud7+70abRaHjggQc4c+YMv/Ebv8HFixepVCo7bHw+H8PDw5w5c4aHH36Ys2fPYrFYGmIHcPz4cSwWC2fOnLml4JVKJUqlUuN5Op0GoFYVjVTdRCLDRixBtVxBUijYs2eASqXM9KXzaBQ9qFVKrHYbxZoSSaFCrdWDQkkmm8TucZKoZiiWqywurzE5M00hk6VrcC+JWAyX20ssEqRer9PR1U0un6NWr25mP6lligUJvdFBu9mMTm9kz+Aupq5cIVsuEY9G8fjasbtakIQCjXaRpdUgAgmFqNDS3kq+kCe0tkGlVKGzfxBQoNMbWIqHqZbL1MpFlAolBqMJs0FDYHEKm9tFPJUlthGkvbsPm8nA7IKfxeVFuvp3YbGZ6eztIxK9QGuLF4NWw9j5l6BawWyzE1qJUK9BtSI4fs+9KCQJ/3KAqoByoYC7tZvWdh+S0GA2GnjPu+7j/CvnmZlbwGSyEVjwI0kKUCpZDqxitpoxWi1EYnHS6RQatZree+6jp7eHek0gyxrMZgNGkxFXeweFYh6RF/QPDLJraBff/3aacGAVfWc/iXiEeDyB1bpZSJ7MFIgFIqRzaVpb26hXa6TjEVq7etBbbCythbHp9eSTMaqVIrVanWwyTle3j1gijs3pZHjPCG6vm4nLF1iausI9Rw9y5MhxIqEger0Wh72fhYlLm0tFGY2s+Jcw2d1423tIRMKYrTbMVjtlKmwsThNfW8OiM1Ar5qmU8hy5/+0oVSrCsSROjYTVbECW1dfq7Tav24bobYt+di7RtTNhZEtmNve6EzcJ2taO57fKZbn+6msCJ3ZGg6+dS7k9g2bnkZvst27Lbjuf7RHojdOIorEFkcBhknlgjwerQUZ7aHO7GISgVq9Tq9WoVcqU61VEXVCr1xrzmJIkYdUpcHQa6fUZsCpynL08i1atIhkOEV5dYC2yD4WkwmI18d7HHkOhMRAMxpBQks2kcbk9HDp6nFQqjaQxoNbIuN02Lrw6Rr1cRK1SYzZbsNqdLM1Motbo0OXKm0uUWcwUa3XyxRIdfbtZmh5lPJ9jY+4q0fVlOgcPUi2k+c63v82ukcMs+pco5zK847H34HTbWF9bw2h1ElwPIustyBo1NqsNvcUEFjOBpTksajsWq51SIU0+l2F68iq5XA61ZrNkqVgr4Wrvx+Fpoa2zC6PZzMzVMfQ6He7OXoJLC4yfexmTw4dKpcRkMpHLZPDPz+D0thJL5kgn4lQKaVo6+5BqVdQqJXaXm0g8i83TzurSAl1tXvq6fDyXSeFqacXna+WVF09RzKWRdUbWlmYwW22kE1GstnsoVyIU0gX2DB/nuf/3PRYnRxnesxubWcfSwgxVhZZ4PE6lWqF3+B7ae954cPNGuK2CFwqFAPB4PDvaPR4Py8vLDRtZlrHZbDfZbL0+FArhdrtv6t/tdjdsbuTpp5/mj//4j29qdzjdJOMR1LIaq9XKkYNdxCIRFvzLeN0ucuk01KqYbXYujk6gVgh+5rH3IJC4cOES5Vwau9lKtpDB5PSQKxSZm5li7vI5bFYrskpNMhGhY3cfbe2dTF8Z4+zZV3G4HfT37UIt61gPhlEoFIh6FZ1Oh91kJppIojWaaXU5WDFuUCsVKJeqdLY4USsE5XIFlVqDUlLS19nB4soasViMwb2DlEoS0XCUSDDAwN4DONweakJFTZKpVauYLC5SyQSRUIh0pkC9XMDrcWHQ64gEljGYjLhcg4yPTZJJpfG1tKNVq1ApwdPeRUtrGyaDlkLaxMbaGna3G7vdxOL8ArlCBb3Fye7BAU4c20ssW+b8+QkU1AjH0ugtbmyeAqlcEb3VhbEuGOrvZWJsgkwqjl6nZWkjTCGfI7wyj8PXysLSCtHgGr6uLu47cQKz0cwP/v0HLMxcxWxzEw6HsXk8KCUJo8lCz8AgEsOYLBb0ljhjr7zIzOQcxXwGi93GyoIfSalmY3meh3/2fyFr9Xz/e98nJytp7ewjlY5Qq1Xp6+uhrcXD1NQ0tUoBhUIiEooQDwfRmozMr6xTzFfwtHfj9niwWUz0De0lvBagu68Po9GA3eXFZXeyPDmOAExWC4p6ncH9h2lr60OjUaO3OqmrtRgtZrLJJNlUEoPPi1arQaVS7lzXku3Sxg0t29gSkG1Zl7fKqHztm5nXufF25pagNpJOrs0BNsoPri+30ihKb/R0Q7Jn4+mOGsGdduIWIlsXdfRaNRaTTL1ep16rUipVqVYrVCrXH9VqFVGvU6vXEaLe6EOpVKJUKpFlNW871EtXm5up9SLrizOUi0VKxSJd3T24OzvxB4Ko9VbOvfwiLqcFpUJFvlAiuL6GQtbg9bRRaGlDkhTsGd7N2RdeIBHb4NjhAxgNGp7//gIbq6vYPW0sT43SsXsYrclMNp2gqFTS0tlHuQbWI/eiqFXZMzzAnl09fPXvvsxLJ0+iMbuo1AXLywFKkoZoeJ1sKoHV5SadSoJKTTASQZ3JUczEUShqlKsVrM4WajUXJrORFm8L4eA64cA8kcAi9z34EJdevUwosIzeaEBWayiWSpRKRQxGGy0dvWQTYVweF7lijXwmw959I/gXZomG1tAYbQhRI7oyS6VUoK17N1anl41IGIWsBUlFIhrm0qVROnv68PUMUEhF2T0wSLFSY2luFr3RglavRauRMZodXLg0ilKScNit1AQcvu9+Lr58iky2yHt+7oN851vPUivloVpCKSkILM6hMVrewBX8xvmJZGlKN3zwxLbFal+LG21uZf96/fzBH/wBn/zkJxvP0+k07e3tRMNBrDYbOoOBTDpFV2cHFoeTfo0el8NOpVxEKesQChWx6DpdnV0oFSpGr0yTjEYY3LeXgT2D/N9vfxu9QUfe4UahUGFv7cSiN2Aym4hEwuQyOeKFAnaHg1wySXB1BZvDCSqZjRU/7b270eo1WC1GlIoyi/PL1Gug1upIRCKYTAZWV1dZmJ2lXKlRqVaoC1BKkClUsDucJJMZrly4iMXZSjAQoKeni0MH9xFLplhZX0Gt02M0WoknMyhlDal4GLtKRqtRY9DryGRLqFR6Mqk0+UKehdlpIusBPC2dBKQS0UgYndlFMp1CSZm33X+CYDTB/Nw8y/MF4uEoWp2GLpOVXCHL+MIKk+OTLIxfoGdggOdP5fD4fLS1dhHYCLPsX6Svpx+TXovRZGTi4lV6dw8yOLCLXL5AJr6BxWpBUS0xPfoqvcOHCa6FmU0vUC2V+F8/936imRLLq0EiwQ00OiM9u4YolfNkMjmUKjXxWASL3YHeoKdSyJCLx2jt6gOVmtDSPKGNCN3d3Rh1MvGNACqtDrVaQXR1gQ/+/HsQNSjmc4RWl1GhoVbe3NqpZ2QEVBJXx17FbNAhSRJzSyu09Q3iq5QIRyLU61WqxRxejwuTyUwsHCKXTpKJB7GYtFwZfQWNVkdVwMD+Q6ysrrFw5RI2qwWnrR9Zrd4sMJd2fuG/IcT1qElsPYTYGQ1uFX5vRXlip7g17Lfar4mS1FhdRVwvKdhKfGn0cS17c1uW5fbI7cbky+2Zmttvdd5UnnAtO0bU69TrdQqFPKVSiXK5TKlUaghdrVajVqtSq23aCVHfMV2pVChQKBUoFEq02RxWvRGjzsie/QfIppP0drbS1+FjbMzAhbOvYLY7KaQTrBeyFPeXcDlsLEyWaWtvo6OrjY1giGpNoq2jg56BQRKRDVSymsHBfmZnBgnMXcXh7UBrMLI2P0VLRzeqWpmlySmsLR20dPVCrUhrRzdDu3rwue0M7TvA89//LnuOd1JraeHq5FUkWaaQSbI2f5VyuYbZZgckQgE/tVodo9FIrVLE6vShlFVsLC4i4cPU14d59wCpTIr58fO47Fa6e3s5c+qHBJdlOnsHUanUaLU6SsUisY11jGYLe0cOEIkkmBq/wMDQMMP7jzI/v0C1nGfv8EHGqRFdW0SjUeJp20MwsEw2l8WgN6BQKgkszpIvCySpyob/CmqNFrWsR28wsHf/QRQqiWQ8SSQSp1QokgguoJb3Mz8/TzGXZvfIMSpVBUItIxBYDDLHjr2Ll7U65q6cpzZ27o1+It4Qt1XwvF4vsBmhtbS0NNrD4XAj6vN6vZTLZRKJxI4oLxwOc++99zZsNjY2buo/EoncFD1uodFo0Gg0N7WnYht09vQSCqySy6SolAug0mOx2bk4PkkgsMzu/QfR6k34WjuQFCpeOnuJhelJnC4HA3uHWFhcQCgU9A4OkcsVkdV6ho/ci91splwskk7n0Gv0UINKoQxKBUaTibZWF+W6Av+MAq2swqDX4mtpIVcpo9GqWVkKUK5LZOJR3A4Lolpmdnaatp5B6lKa4NI8SrWS8Qk9TpcHjd5ALhUjEwuxNjuK1XSU5WCMukKQTqWw2D1kCjmy2RQduwbR6/QsTk3S2tODzmCkrc1GKlskk07h9fpQK2UCszNk0jEUKolYOIpLtlGqVuls76BUUyEUKlKpJPlslt7BvZQKGcZffQlZoWD3niH27RvBatCx//BhxsanmB67jMFsRm+2k42uE7fbOf3ijwmuLKJSa+jt38VQXwfT84vYHR6sZguB5RX0Zgf5UpWl1XVKxQIHD45gsZqY9k8TXl9l+oIfi83JfSdOEEulKBXzJKLr+K9eZmjPECqtlpXZCLv27GX/4b0oJBWxUIDlhQUktY5SRVCtQf/uPoxGE6dWFojFEvj9a2SyaVzd3Wh0MnWNggPH3oZOb2RtOUA2EUNZMxCPRTj34vM43D68be2E14NoNTIj+/dh0mtp7+0jk80zMrKHbCxAIpZArZbx+VqYn59nPRCgkElRKuSw9Xah1cjXt/tprEjSyNy4fgFfOyZtD662Le3VECY257A2Swi2JIkdaZtiuzxudXqre5avl+dyy/ucm43S9vKIa++5Y/u7GyLH7Se2U6cF9XqdTCZDPp+/Segq1SqVSoVSsUS+UKRUKlGv1UGSUKmU6LQaZFlGltWo1SrK5RLr4SRTSxXUWjWDI4dY8Aew2Vzo9WbMVjsDQ4PYva1cffUsL/zoR7zt7Q/R3T+Ax+3APz9PJLhGPhnm4PH7EJKSupBYXF4nlUpjsjnoHN7Pgw/cywunJebHXqFWTPGhX/4gL5zpJJ7OYTKZmb+6yPLkJMl4hrZWN7Nzi3TvHuLo0SOcfP5FioUC6VSa9u5dxMMb1CoFuvt3k0nGWJwaR5LVWK02YpEQgYVZWjr78LW2kYxHGB27jMFsIpvNoDM7SKaL6IxG7N42Iqt+XL5ONFotaqXErpG9RDfWiG0EePGFF1CrZAq5JIFgCJBIx0PYXV6K1RpWl49kNESlWsVkMRHfkLGZzfR2tzM7eo5wIkjYfxWjzYlCoSadjNPa7SYZCzN24TxGkxGb047ZYqCzq4t5WSKbTlCvVThy5DDr6xuMjV5iYGiQaqVEuVKhXqtj83hpyQ6gk3euOPRf5bYKXnd3N16vl5MnT3LgwAEAyuUyp0+f5s/+7M8AOHToEGq1mpMnT/KBD3wAgGAwyJUrV/jzP/9zAO655x5SqRTnz5/n6NGjAJw7d45UKtUQxTdKz+5hWtq6MZkdpFIxVham0Ris5IoFlq9epLWrl4ff/z7Gp+apV2tQrzE/P0+5WsXh83H+x6/gn7rKrv1HQKUkFFrH6/Ji1um5Oj5OpZhHqZSpVytEohFktYJSLsXe/ft46P5jBAIhpievYrJb0eu1TF2dpVBIY29pobt/N5Kkwqw3k8uXCIcC5HIpysUsvlYfkVU/nrZubGYr2UwGhUrF/qP3UMoW2AgGKZYqoNQQDq0SW1tFr7exEtkUyX0H9lIpV0lEguhMRq5MTqMEzHYXbZ2dmLQGEooU3q5ddHW3U6pUCa6tIGvUFIs5VleD5Itl5uanWZ0ex9PahVKlIbg+h95k5dGffQyb00k4FAfFAC0trayG4lSLeY4e3UdFoSG1sYZKuRnB6PU64qksV0YnMGkV+FdX2H9oBLVORqVRMHjkHqxWG8FQmEq9xvPPnUKlUpIvCbr6ejEaDUgCorEk+WKO5elJDh69j3QkRDLi4vjbhsglolSqBYrFApFoEp1RT4+nk5XAGtRr9AyNkCkUqSlU6PQmVBoj7tZWDLOzmM1WsokEOq0Gk8WM3mjCbrHgMaqoFLJ0ukxYT4ygVqkxmPTUPV2oVSo8VgV1UhzqdXGg+0GcDhuatz9EOhEHlYaaQkMq7UXW6cjGwsgaPTICtVq9IzNzi+2RVEPseJ15r22R0i0TQyTphhdtvafYITI7RG574d/Wm980N3jd5pq0Nc5kx1ndQsMb9rfYy2/z7QS1apVUKkU2m6VSqVAuVzbvCuQK5MuwEU0hm5zkq5BOFKiUymRiIQxaFQadjKyo43HbcTvtyFodr4wtsRJKYjCZ8Ho9yFod3/v3F4hHIpRrdSSVlkxmHYPZitlsRqnWEApFia6v0rt7DxabHama4exLz1MpCwq5DEq1hr3795HJpKlLRoqlErVKCZVGxtc/QjJfRWcy4TUY6O7uopDPMXXxDKPnTjOh0ZKJhWnxtaBSKuns8JFPbqAzWSmUq6gNFvLJCLl8iaqkwt3ajdFqxe1tY3FuhnQqTmBxCovFsrnG5sxVtGYrWoMFvdHCufOXaO/qQtYZ6NlzCFDgbeti4cpFBgd28/Z3vpNTP/x3KpUKLl87sY0Vxs4+T3vfEBazCavJgE6nQ63R4mzrwdXSSTScoqpQsRGJ0uJr4V2P/iyvXhxnduwcff19lCq9RIMBIhtBUqkULS1GJKWa+dlFCoUkVquFgZGDJONxwsEggVAKndFG8MI5kvEo5VIR//Q4Jrsbs16DqNcwOFpvukb+K7xpwctms8zPzzee+/1+RkdHsdvtdHR08NRTT/HFL36R/v5++vv7+eIXv4her+eXf/mXAbBYLPzar/0av/u7v4vD4cBut/N7v/d77N27t5G1OTg4yCOPPMKv//qv8w//8A/AZlnCY4899qYyNAH2HTyEf3GVcGAVh9eFy9OGUtZQrQuKhRLpQoFvPftvxDaCGCw22rt6MFqttLj62DO4G6vRSqWioK+/l96uNuRKBavLi0qtIrK+jKxUcvyhd1EslkiF1zGa7bh9XhLJFD9+dYJcIgZUKBZzRALLpBNpzBYH8VAYpaxBYzBRLhWYuXgGW0sHKkmBWimRjIap16uUK1Xi8ThGk5lYaJ2Y1UgiEqetqxOr3UEhnyWdSKI3mrj//mMUcnnOnLuAx+miJmpoDWZU1FEplSzOTtMtSSRiSZIbUTbCIQb27cPjcTMxNorD18mugT4qlQr+uXkkqYos1anmc2SiERR1Qa2UQ2e2glLLC8+fZnlhHldrB+lsDv/CAj6fj7b2dkrFClq9HqPJgtPhRCUJgoHz+OcnsZplMtkCxl0DSFUJ//gEQ0fvw+l0EAqFsZqMWPVqjGbz5i7qgSUGBgbp7uwmlauQXs0gaw2kUwm0BivJbA6t3khH326i8RjRcIRT//Z/QBLse/xXUCqU5DIpDGYLkeAG64un6OzpI5RIsbK8hkKpQq/RIzvV1PIJTOoKTk0RNTW8PjP1mpF6MY7TYr4mUnWUsgqFUkkmEUWhUKBUKFArFOSScdqsMpK1hboQVKo1epy9yDoT6QEPK8EYpUxyMwHj9bghktoe4W1PbLme7XLDa7kWAe5ou+EtpJ1/b5+PuzGQe70ZiR3lE2wvatj6S9wkerdGakR3xVKReDxBKp0mnS0TzVSIZgroLS5QyKisVlDJJMLLlCsQXVtHZ9DSNnSYcqWKf2qCUCqMO1Zg+NBxZFOG2uISrXv2EQoFKBaLFAtFAgtTCAGySoXF4SRWybN//4nN1XGUavRmAwqVElmrYXf/AMlUihZfB+Nj48Q2VliYnsblbWHlwjnWg91E15cppGKsrayQikVZmptm99Awpn3DSJKCSlWgkaF3aIR0IkZweY6JsVGOHDtGeH2NtZVFvG09ZGMbaAwmbHYHM1Pj1AoZlCoJv79INl+gvasfRA2lUkKp1rM8M45W1qLVm6iLOvHoBrVahfDaMnoZOgcOsLYSxObyUqnW0BmMuL0tLPtXyefzdA2MsL40j8Pu5Mh73sMLp06hVChx2a34r55nrlbBbGshn02QjqxRyKYxmGzEohGsdjv3HD9MOFnmucAypWgEq6edSr0OlRLVaol6TcHqyio6nZZqTaBQSiSSMTZCFSqlElZLlcPveJiZiVGq5QKRcBib00VkI/gfXTRvijcteBcuXOChhx5qPN+aN3viiSf4+te/zqc+9SkKhQK/9Vu/1Sg8/+EPf9iowQP4y7/8S1QqFR/4wAcahedf//rXd+zo/M1vfpNPfOITjWzO973vffzN3/zNmz7BbLZIJLSOUqcnuLpE/+5dmK1OghsRzA4PVqubfCZFLp2gXilT7+zmwIER1peWGLswRiZfwmA1YzDqiaYKZIs1tMUKakmBrNHh9bg5tn+QUy+8RHx9if5dg/QN9jE7u8DLL7yEUlToGdqLqFapVKr4unqw2xwsL06TyRXp7O/HoJfJJGK4vR606j68nV28/PxzpKPrtPYNUCrkWV1YIZNMkkmEAQmvr5VEusDM3BJR/1V6B/YgKRTUhKC7uwurUU8kmUSv11Gr1tHq9JvLo/lnsbs6WZq+Qia9gdVpxqjTEl5bwdO5C7vDSXB9DZfHjcPpJLgWxOppQy2rUWnA5XHja2mhxW4i19nO+CsvYfO0ks2kWV+YwqjX8dKPLxKJxqlUylQqRWZnZ6hUS3TtGcFisbG2toxSreHqzCJSjc0vrPUQxUKRWGiNrtZWPG2dLKysoTHrScajhNYC2K02lEoN4cAa7b2DKBR12gaHOHZgiHKlzOLCPFqdGlnjQ0gKFFIdg1bG3NXJ6OgYtWqVUiFPtVTF7GqlUikxPXoOWSNj6+vFplcjlQXlXJyV6DqlUoV6vbY5TyTqKCQJhUKBQiGhUqlQqzcfKqUKlUqJWq3e3MlapUShUG4K4bV5pHI1gV6pYLDNwYI/D3C9BGAb0o0iJnYuB719/9Vbcf0Godjx3y3VphEB3jC5x/YEk+vd7ciS2dlJ46/rzVtvfF10d24TtPXS7UooEGxmYGZzRRZDOS5dvkJZacDpaadcLpFcDyJrNOw/dASrwUjIP41Fp+HY+3+W8cuX2QgFsTk8FAtFLC4Pzv49rCXzRMIb3PfQQ3QM7GV0XMPUK6c5fuJ+Ttx/L2dPP09oeQ6fz4es0RJYD+LytqJU1NDrtAilnnwmy6kf/oBjD7yLQqUKShlPezd2sxWD3khLi4cunwPlvfdw6ZUqSlGira2P+MY6y3NTzLS1Uy4VySfC6L1eFArIphM4vC2sB5aYsbsw2txEozFyhQrt/YP4p8aYuzqOxWhgYXkab3sHao2O0PICK5UCRrMdhVIGpRp3ezeuljZqdQUb60vkUjF8rW0cuvdBfnzyO2Qu/pi6gJb2blaWl5C1OtYDq9SrBZKJKO2trXT0DRCKxJibX6YuJHRq2LVviGg0xMLUFeo1QblUJBWPYXW4cNg9FFIxOjo7EXWBUSORT8UQkhKHt51qpUw8FCEZCqDRm9B399LicVHIprk6dhG7p5VKMYGs0+NwOdBpNHTv2sNATzszKgmb08v//dYzr32x/yd404L34IMP3rSo7XYkSeLzn/88n//851/TRqvV8uUvf5kvf/nLr2ljt9v5xje+8WaHdxNjl88TWp6jpWfvtRXcq/gXF9hYX0eWVVgs1s1VvvWWzS8spYxFp2OlVODShVfR6I3YPT4uXRwlEgzh9HWgUGsphQsIIbDaLGhkBULUQNQwWw3YLVY8HtfmLtgGExVJTb1eIpfLkEkm8Zx4EJWsJDo3T7qjE1E24GvvxmI1YLU7mJ2fR6nRM3D8AXr7+5mZvEI6urnTubejF5WsYc3vx6m3kQgGKBcKtLe1cfXqNKl4DLPVwsWJGVaX5ugdHMBqc5JJZ+js7qUmKtjdbRQLedKpDbK5AihUlPI5gstzqGQV1VIRrc7AzMwCOr2JQ/e/jUKlRCiyQd/uAR554Bi1ao1iFfqGRnjk4QdJpHJMnn+ZUi5HMp1nbvoKI0ePYbPZQYRIJit429qoVorEYhv0Deyju7uNQrHE6oKJubFzDB05Tia2gdzdxpEj+xBKmWq9SratA0nWMzk7TylXQNQq7OppJ5rOoJCVdPd289zJU5TyWdy+QSauTKE12ejt6UGl0VMqV1BeE6gDhw/yXMDP3Nh52jveh8fjxGUxkA8vEUylyGbzlMvXs//EVhLFtpR3JKkhfiq1EpVShVqtRKvRoNHIaLUaZFmNrFajltXIahm1Wo0sbwpitVq7Nt+22ffODXNunZH5RtmRHCLEtrbXs72hdXsNAezYJ+/mzJdbd36rW7H/0agRIOqCarVKrKAgrXRRVpiwWMzY7SY6Rvbx8unnSccTRBNx6tUaD777vcSTMQ7tHyIaDnPhzI+xu1ro2r2XjfUV2n0eFEqJ0ZdPsXfkf5POV4gGA3jbu7j/bfdisdmJZXK0Fcpk8xU0Vid+/zKe1m4sNhevnn2Jju5+JFEnn8mwvDCHWmdgefYKBrOdtrYOCkVBTWkgsBGho7cfq82B120jlSuxuGBjZmWZjeAameg6SpWSZDRErZSjf1cfiWQab0s70ViKTDZHR08/ss5MTitzzN1CJhWnZ1cfJpuJhZkpjt77AIp9B7g6PopSocbp9pIppomtby4raLV7SCfNZNUb6Mw29CYz3s7d5DMpUKrI5YvMTE6jt9go5vMg6hh1WpYXZpAUSkqlItHQGrlkmNhGO9lCBZ3ezO59R9FolSQTGfLpJLFwkP6hvXh9PnL5PC+8/AqJSAQhapgdLiwWC0tz62RjQQxWJ/lUnFQ6i8VqRVYqKeczzI2ep1arUi2XyOUrrAUCRKMx0rE1unp3sxoM4W7rYnX69iWu3LFraW59QVWrZUw2Bxa7jdRGgbFLowghUS6XcLZ3YLMZmbw8hpBUdPR247CZMBo2V0+Q1SqOnbgfn89FMLDG0pVR9AYTebOJ6MYqWp0Gl8fD6noQlUaDt3s34VgU/bKf1dlJSpkUqfAaVruFPcP7WBi7SK1ex6RX4PE4mTh/drNwtSah1mio1FrQ6PRU8jlsFjO9g7sp5ssUMxmGDxzGareDbEDUa7R1dePxelnzT2HQtVOWFKwszpOIBencPcjK+GUKiTCHDz5OqSxYiaew2Ix4vT6i0QSyXs3Q0Xvp7uoikYxTLGSpKyXSyQSrc1PoDVbKpRLtnW10DY+wEYmyOjvHhlbNjD/AxnqIl350mvsePEGLy0ohX6RWLlGpFhBSnXIuQzQUpFKtgVRnfWESUStz6J6jzKqVTI+PUkOizmZGakfvLkZGhrBbrUQiEc6PzZJMp4mEQ9SqVWSdnmwmRzabRRJlYtE1LGY7E6/O8n8iEaqlPIeOHkWh1nL18jmUksDqcvHKq5eoFLOYLBZ0shqH1Yanq49keJ2xixcQuTT+0DrFcol6rYaoi20/6MTr/riDrduL0rV/11YHUSpQqpSolSo0Wg16rYxWp0OrlZHlzZVDctnNc6nX69sWF5G2RXibgriVmby9Jn0rGWVLfLeud1EXSIptxeDX5gGv1+Fts92W8dyI2bYlnEjSzWO4xacMuD7m6/1ei1xvGPPWGK7HiNdvhm4FmtValVw2zZx/hehGnHIhh3dwGLPNxFowiEot097txW4xc2VsDLfDjdaoZ84fYGl5cx82nU6L2+UkE10ntOJn5PBhWtq7efH0y9g9rYhyASHrmFtaozq7xHogyMjIAOFohoB/Dm9rG7FEjI3IZvGz22HCOTiIJKrkYiGOPvAgxXSU4Ooqc7OzhJYXKRfyVKslVpbXqZdL+B55JzqdApPFjlpnQK+Rec973slkTxfRSBSX08VD9x3ixTOvMjpxGUmpoZDL4nQ5aPHJJCNBSrkMg8N7iCXizM9cxWo0odeoKdvsm1FwPERXdxduVz+J9UVmL5/H09FPpZQnHV4hl4qxtryIVK/wzne/k1g8zvj4OMVCCaFUY7a7qNfK9Pb34bAf5NzZV5G1Wvp2DVLMdjA7PcHlsQlqpRxmowGb243N6UTW6dEb9AQ3NqgjYXc4yeUyRILLaC129DoNolqmo6OTqdgaClHF295JKrzE+PoiCmnzR41BbyQdDNI1dBD/7BTrK352jxzH758jEt1ckaaUz+34Pv+vIonb1dN/MxYXF+nt7X2rh9GkSZMmTf6LrK6u7lhr+T/LHRvh2e12AFZWVrBYLG/xaP57slWruLq6itlsfquH89+Opn9en6Z/Xp+mf16fN+IfIQSZTAaf7/asqXnHCt7WjtEWi6V5sf0HmM3mpo9eh6Z/Xp+mf16fpn9en//IP7czYLm9VX1NmjRp0qTJf1OagtekSZMmTe4K7ljB02g0fO5zn7vlcmNNNmn66PVp+uf1afrn9Wn65/V5K/xzx2ZpNmnSpEmTJtu5YyO8Jk2aNGnSZDtNwWvSpEmTJncFTcFr0qRJkyZ3BU3Ba9KkSZMmdwVNwWvSpEmTJncFd6zg/d3f/R3d3d1otVoOHTrESy+99FYP6SfO008/zZEjRzCZTLjdbt7//vczMzOzw0YIwec//3l8Ph86nY4HH3yQq1ev7rAplUp8/OMfx+l0YjAYeN/73kcgEPhpnspPhaeffhpJknjqqacabU3/wNraGh/60IdwOBzo9Xr279/PxYsXG8fvZh9Vq1X+6I/+iO7ubnQ6HT09PfzJn/wJ9Xq9YXM3+efFF1/kZ37mZ/D5fEiSxHe+850dx2+XLxKJBB/+8IexWCxYLBY+/OEPk0wm3/yAxR3IM888I9RqtfjqV78qJicnxZNPPikMBoNYXl5+q4f2E+Xhhx8WX/va18SVK1fE6OioePTRR0VHR4fIZrMNmy996UvCZDKJb33rW2JiYkL84i/+omhpaRHpdLph89GPflS0traKkydPikuXLomHHnpIjIyMiGq1+lac1k+E8+fPi66uLrFv3z7x5JNPNtrvdv/E43HR2dkpfuVXfkWcO3dO+P1+8dxzz4n5+fmGzd3soz/90z8VDodDfO973xN+v1/867/+qzAajeKv/uqvGjZ3k3++//3vi89+9rPiW9/6lgDEt7/97R3Hb5cvHnnkETE8PCzOnDkjzpw5I4aHh8Vjjz32psd7Rwre0aNHxUc/+tEdbQMDA+Izn/nMWzSit4ZwOCwAcfr0aSGEEPV6XXi9XvGlL32pYVMsFoXFYhF///d/L4QQIplMCrVaLZ555pmGzdramlAoFOIHP/jBT/cEfkJkMhnR398vTp48KR544IGG4DX9I8SnP/1pceLEidc8frf76NFHHxW/+qu/uqPt53/+58WHPvQhIcTd7Z8bBe92+WJyclIA4pVXXmnYnD17VgBienr6TY3xjrulWS6XuXjxYmOn9C3e/e53c+bMmbdoVG8NqVQKuL5zhN/vJxQK7fCNRqPhgQceaPjm4sWLVCqVHTY+n4/h4eE7xn+//du/zaOPPso73/nOHe1N/8B3v/tdDh8+zC/8wi/gdrs5cOAAX/3qVxvH73YfnThxgh/96EfMzs4CMDY2xssvv8x73/teoOmf7dwuX5w9exaLxcKxY8caNsePH8disbxpf91xuyVEo1FqtRoej2dHu8fjIRQKvUWj+ukjhOCTn/wkJ06cYHh4GKBx/rfyzfLycsNGlmVsNttNNneC/5555hkuXbrEq6++etOxpn8295H8yle+wic/+Un+8A//kPPnz/OJT3wCjUbDRz7ykbveR5/+9KdJpVIMDAygVCqp1Wp84Qtf4IMf/CDQvIa2c7t8EQqFcLvdN/XvdrvftL/uOMHb4sYdmsVr7tp8Z/Kxj32M8fFxXn755ZuO/Wd8cyf4b3V1lSeffJIf/vCHaLXa17S7W/0DUK/XOXz4MF/84hcBOHDgAFevXuUrX/kKH/nIRxp2d6uP/uVf/oVvfOMb/PM//zN79uxhdHSUp556Cp/PxxNPPNGwu1v9cytuhy9uZf+f8dcdd0vT6XSiVCpvUv5wOHzTL407lY9//ON897vf5dSpUzt2CfZ6vQCv6xuv10u5XCaRSLymzf9ULl68SDgc5tChQ6hUKlQqFadPn+av//qvUalUjfO7W/0D0NLSwtDQ0I62wcFBVlZWgOY19Pu///t85jOf4Zd+6ZfYu3cvH/7wh/md3/kdnn76aaDpn+3cLl94vV42NjZu6j8Sibxpf91xgifLMocOHeLkyZM72k+ePMm99977Fo3qp4MQgo997GM8++yzPP/883R3d+843t3djdfr3eGbcrnM6dOnG745dOgQarV6h00wGOTKlSv/4/33jne8g4mJCUZHRxuPw4cP8/jjjzM6OkpPT89d7R+A++6776ZSltnZWTo7O4HmNZTP5xubS2+hVCobZQl3u3+2c7t8cc8995BKpTh//nzD5ty5c6RSqTfvrzeV4vI/hK2yhH/6p38Sk5OT4qmnnhIGg0EsLS291UP7ifKbv/mbwmKxiBdeeEEEg8HGI5/PN2y+9KUvCYvFIp599lkxMTEhPvjBD94yTbitrU0899xz4tKlS+Ltb3/7/8iU6TfC9ixNIZr+OX/+vFCpVOILX/iCmJubE9/85jeFXq8X3/jGNxo2d7OPnnjiCdHa2tooS3j22WeF0+kUn/rUpxo2d5N/MpmMuHz5srh8+bIAxF/8xV+Iy5cvN0rAbpcvHnnkEbFv3z5x9uxZcfbsWbF3795mWcJ2/vZv/1Z0dnYKWZbFwYMHG6n5dzLALR9f+9rXGjb1el187nOfE16vV2g0GvG2t71NTExM7OinUCiIj33sY8JutwudTicee+wxsbKy8lM+m58ONwpe0z9C/Nu//ZsYHh4WGo1GDAwMiH/8x3/ccfxu9lE6nRZPPvmk6OjoEFqtVvT09IjPfvazolQqNWzuJv+cOnXqlt85TzzxhBDi9vkiFouJxx9/XJhMJmEymcTjjz8uEonEmx5vcz+8Jk2aNGlyV3DHzeE1adKkSZMmt6IpeE2aNGnS5K6gKXhNmjRp0uSuoCl4TZo0adLkrqApeE2aNGnS5K6gKXhNmjRp0uSuoCl4TZo0adLkrqApeE2aNGnS5K6gKXhNmjRp0uSuoCl4TZo0adLkrqApeE2aNGnS5K7g/wMCBmA0fd4BrQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(rgbds[0][...,:3])" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[ 0. , 0. , 0. ],\n", + " [ 0. , 0. , 0. ],\n", + " [-0.00392157, 0. , 0. ],\n", + " ...,\n", + " [-0.00392157, -0.00392157, -0.00392157],\n", + " [ 0. , 0. , 0. ],\n", + " [-0.00392157, -0.00392157, 0. ]],\n", + "\n", + " [[ 0.00392157, 0. , 0. ],\n", + " [ 0. , 0. , 0. ],\n", + " [ 0.00392157, 0.00392157, 0. ],\n", + " ...,\n", + " [ 0.00392157, 0.00392157, 0.00392157],\n", + " [ 0. , 0. , 0. ],\n", + " [-0.00392157, -0.00392157, -0.00392157]],\n", + "\n", + " [[ 0.00392157, 0.00392157, 0. ],\n", + " [ 0. , -0.00392157, -0.00392157],\n", + " [ 0. , 0. , 0. ],\n", + " ...,\n", + " [ 0. , 0. , 0. ],\n", + " [-0.00392157, 0. , 0. ],\n", + " [-0.00392157, 0. , 0. ]],\n", + "\n", + " ...,\n", + "\n", + " [[ 0. , 0. , -0.00392157],\n", + " [ 0.00392157, 0. , 0. ],\n", + " [ 0.00392157, 0. , 0. ],\n", + " ...,\n", + " [ 0. , 0. , 0. ],\n", + " [ 0.00392157, 0.00392157, 0. ],\n", + " [-0.00392157, -0.00392157, -0.00392157]],\n", + "\n", + " [[ 0. , -0.00392157, -0.00392157],\n", + " [-0.00392157, -0.00392157, -0.00392157],\n", + " [ 0. , 0.00392157, 0. ],\n", + " ...,\n", + " [-0.00392157, -0.00392157, -0.00392157],\n", + " [-0.00392157, 0. , -0.00392157],\n", + " [ 0. , 0. , 0. ]],\n", + "\n", + " [[-0.00392157, 0. , -0.00392157],\n", + " [ 0. , 0. , 0. ],\n", + " [ 0. , 0. , 0. ],\n", + " ...,\n", + " [ 0. , 0. , -0.00392157],\n", + " [ 0. , 0. , 0. ],\n", + " [ 0. , 0. , 0. ]]])" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rgbds[1][...,:3]-rgbds[0][...,:3]" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [-0.16078431372549018..0.18039215686274512].\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbwAAAGiCAYAAACcbHM0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAozklEQVR4nO3df2wU953/8desbRZDzR4/hBeHhDMSEumZ0NT00hAOKGm4XHFRVKmXUkI49f6hFyi+3DUJl0qQqImt6I5vVXEFJTrleqI9R1WgSqseV9OmbhEkIBtaA2rSUzlsEK7b1KyhARt7398/UuZYG4x/zO7OzOf5kD6KsvvB/uzHO/Oaz2c+M+OZmQkAgJhLFLsBAAAUAoEHAHACgQcAcAKBBwBwAoEHAHACgQcAcAKBBwBwAoEHAHACgQcAcAKBBwBwQugD7xvf+Iaqq6s1efJk1dbW6mc/+1mxmwQAiKBQB95rr72m+vp6Pfvsszp+/Lj+4i/+Qn/1V3+ljo6OYjcNABAxXphvHn3ffffpox/9qHbv3u2/dvfdd+uRRx5RQ0NDEVsGAIia0mI34Fb6+/vV2tqqZ555Juf11atX6/Dhw8Pq9/X1qa+vz///bDar3//+95o5c6Y8z8t7ewEAwTIzXbp0SVVVVUokJj4hGdrA+93vfqfBwUFVVlbmvF5ZWamurq5h9RsaGvTcc88VqnkAgALp7OzU3LlzJ/xzQn0OT9Kw0ZmZ3XTEtm3bNmUyGb9wng8A4qGioiKQnxPaEd6sWbNUUlIybDTX3d09bNQnSclkUslkslDNAwAUSFCnpUI7wps0aZJqa2vV3Nyc83pzc7OWLl1apFYBAKIqtCM8SXryySe1YcMGLVmyRPfff79efvlldXR0aNOmTcVuGgAgYkIdeI8++qjee+89Pf/887pw4YJqamr0gx/8QPPmzSt20wAAERPq6/Amore3V6lUqtjNAABMUCaT0bRp0yb8c0J7Dg8AgCAReAAAJxB4AAAnEHgAACcQeAAAJxB4AAAnEHgAACcQeAAAJxB4AAAnEHgAACcQeAAAJxB4AAAnEHgAACcQeAAAJxB4AAAnEHgAACcQeAAAJxB4AAAnEHgAACcQeMXkFbsBAOAOAq+YrNgNAAB3EHgAACcQeAAAJxB4AAAnEHgAACcQeAAAJxB4AAAnEHgAACcQeAAAJxB4AAAnEHgAACcQeAAAJxB4AAAnEHgAACcQeAAAJxB4AAAnEHgx4Hk8SRYAbofAiwEzniQLALdD4AEAnEDgRRTTmAAwNgReRDGNCQBjQ+ABAJxA4AEAnEDgAQCcQOABAJxA4AEAnEDgAQCcQOABAJxA4AWAi8ABIPwIvABwEfj4cbAAoFAIPBQVBwsACoXAAwA4gcADADiBwAMAOIHAAwA4gcADADiBwAMAOIHAAwA4gcADADiBwAMAOIHAAwA4IfDAa2ho0Mc+9jFVVFRo9uzZeuSRR/TOO+/k1DEz7dixQ1VVVSovL9fKlSt16tSpnDp9fX3asmWLZs2apalTp2rt2rU6d+5c0M0FADgi8MBraWnRE088obfeekvNzc0aGBjQ6tWr9Yc//MGv89JLL2nnzp3atWuXjh07pnQ6rYceekiXLl3y69TX12v//v1qamrSoUOHdPnyZdXV1WlwcDDoJgMAXGB51t3dbZKspaXFzMyy2ayl02lrbGz061y9etVSqZTt2bPHzMwuXrxoZWVl1tTU5Nc5f/68JRIJO3DgwKh+byaTMUkUCoVCiXjJZDKB5FHez+FlMhlJ0owZMyRJZ86cUVdXl1avXu3XSSaTWrFihQ4fPixJam1t1bVr13LqVFVVqaamxq8zVF9fn3p7e3MKAADX5TXwzExPPvmkli1bppqaGklSV1eXJKmysjKnbmVlpf9eV1eXJk2apOnTp9+yzlANDQ1KpVJ+ufPOO4P+OACACMtr4G3evFm/+MUv9J//+Z/D3hv64E8zu+3DQEeqs23bNmUyGb90dnaOv+EAgNjJW+Bt2bJFb7zxht58803NnTvXfz2dTkvSsJFad3e3P+pLp9Pq7+9XT0/PLesMlUwmNW3atJwCjIY35L/FFIY2AHEVeOCZmTZv3qx9+/bpxz/+saqrq3Per66uVjqdVnNzs/9af3+/WlpatHTpUklSbW2tysrKcupcuHBBJ0+e9OsAQbEh/w3aWEIsX20AIAW+SvOLX/yipVIp+8lPfmIXLlzwy/vvv+/XaWxstFQqZfv27bP29nZbt26dzZkzx3p7e/06mzZtsrlz59rBgwetra3NVq1aZYsXL7aBgYFRtYNVmhQKhRKPEtQqzcAD71YNfvXVV/062WzWtm/fbul02pLJpC1fvtza29tzfs6VK1ds8+bNNmPGDCsvL7e6ujrr6OgYdTsIPAqFQolHCSrwvD+GVOz09vYqlUoVuxkAgAnKZDKBrMvgXpoAIqXQC3tut3oc0UHgAYiUQk9JxXQSzEkEHgDACQQeAMAJBF7IcLYAAPKDwAsZzhYA0ZdIsGsNI/4qABCwbDZb7CYEb8hq1SiGevRaDIxCSUmJPCaIgeAMWa0axVAn8BBL2WxWxgQxgBsQeIglrp2Cy5jbuDkCD8CocdeRaOBw7+YIPCAGPM8buqYgLxg5I8oIvNuI8/FsIhHOT+cVYPVX3EYqZjZ0TQGAIQi824rXjvFGYd1BmuV/9deoRiqeV7RgTIz298b36xkaMTs2chqBdxtxXukX2umpG5pV1JHYB8+LLMqvzo72ezfKaqPtR/btw4V1M7kVz/NGf8DkGALPRSNsDGGb6gttKOdbwB97tP3oaG/Hipkp6+p2cxsEXkh4UuHmTkbYGJwNGIRbyA7EEE0EXkiYdMsgGs8tfNg9IE6uf5/DNgOB/xOFvw2BFwHjuYWPi+O0KGxwGJ/rMw9hmYFw+Zt2qwPwsPxtRkLgITaisMEhHlz+pkV5OyPwAACjRuAB48Q0ZDBKSkqK3QQg9Ai8AkmU0NU3E+WjxTAZHBwsdhOA0GMvXAAlJSXRu3oViKFEIsGsgsNKi90AFwxmswQeEAJRfGgpgsMIrxAIOwAoOgIPAPKMadRwIPAAOKtQQcTirHAg8AAEJmojGYLo9qL2Nx0JgQcgOARIQRQygrwY3UiNwAMQGOKuMArZz9kCPJC5UAg8AIATCDxgLOIzuzNqBTmH44XnXFFY2pF/rnzO/0PgIdYC33m5OGdXiPNyFp4FJGFpR/6F73Pm+2CDwEOsubPzyh+ne9C9QVBR5Xt7JfCACfDG8TR6REdJosShKc74416awAQY92aMNZ5CES9OHp4W64AtTtezAEDUOBl4xTqtY26fDQFiK18H0Z7nFe0AfSLC+kBiJwMP4RHBbTkWPtiR0vvByU9fmlkkb14T1qlgAi9OQnQt02hFcFuOhxBdBhAH9GU0EHhxwk4MoxSV6fViTo1F7NgRo0DgAQitYk6NcewYPwQegIIpLeVKKBQPgQegYAYHB4rdhFCL2jl4SUpE6OYL0WkpEDBWKhYe04Qji+I5eIvQ44OYX4CzorhzAYLmaWKrpaO0GTHCGyUvgkv+AeB2IpRXE8YIb5Q+OIpx6asBAPHCCA9FxaB54uJ4LjJun8c1iZD+/RjhoaiiNP8fVnE8FxnHz+SSbEj/fozwAABOIPAAAE4g8AAATiDwADjLEwtkXOJk4MVxVRuAsTOxQCZvPC90tx1zcpUmX3AAyDOz0K3WDFf8AogUZkoQJQQeioIdZTwwWxIynqREQkok5BXx4blh5eSUJoovXztKz/PYCcNdJumPTy9gKxiOER7ihZEjgFvIe+A1NDTI8zzV19f7r5mZduzYoaqqKpWXl2vlypU6depUzr/r6+vTli1bNGvWLE2dOlVr167VuXPn8t1c98QsICwbnWdzASisvAbesWPH9PLLL+uee+7Jef2ll17Szp07tWvXLh07dkzpdFoPPfSQLl265Nepr6/X/v371dTUpEOHDuny5cuqq6vT4OBgPpvsHqb/EFJcPoTAWZ5cunTJFixYYM3NzbZixQrbunWrmZlls1lLp9PW2Njo17169aqlUinbs2ePmZldvHjRysrKrKmpya9z/vx5SyQSduDAgVH9/kwmY/rjjDaFQqFQolsymUwguZS3Ed4TTzyhNWvW6JOf/GTO62fOnFFXV5dWr17tv5ZMJrVixQodPnxYktTa2qpr167l1KmqqlJNTY1fZ6i+vj719vbmFAAArsvLKs2mpia1tbXp2LFjw97r6uqSJFVWVua8XllZqbNnz/p1Jk2apOnTpw+rc/3fD9XQ0KDnnnsuiOYDcJ2nD8YWiJXAR3idnZ3aunWr9u7dq8mTJ9+y3tC5eTO77Xz9SHW2bdumTCbjl87OzrE3HgAkJTwWsMdR4H/V1tZWdXd3q7a2VqWlpSotLVVLS4u+/vWvq7S01B/ZDR2pdXd3+++l02n19/erp6fnlnWGSiaTmjZtWk4BgPHIsto3lgIPvAcffFDt7e06ceKEX5YsWaL169frxIkTmj9/vtLptJqbm/1/09/fr5aWFi1dulSSVFtbq7Kyspw6Fy5c0MmTJ/06AACMReDn8CoqKlRTU5Pz2tSpUzVz5kz/9fr6er344otasGCBFixYoBdffFFTpkzR5z//eUlSKpXS3/7t3+of/uEfNHPmTM2YMUP/+I//qEWLFg1bBAMAKIzrZ5SCvJrJS3iSWUGukCrKrcWeeuopXblyRX/3d3+nnp4e3XffffrhD3+oiooKv87/+3//T6Wlpfrrv/5rXblyRQ8++KD+/d//XSXcHw4AiiIfoWTZwq0O8szieeVxb2+vUqlUsZsBAJigTCYTyLoMliKNR8zu/uB5JfJYlTZhnud9sJwdQCjxtITxiNmg2IzbtQUhppMlQGxwWA/Aedyz0w0EHgBnXQ86RuduIPAAAE4g8AA4i5GdWwg8AIATCLyJ8DwNX4fOyW8ACCMuS5iIm06HMEUCAGHECA8A4AQCDwAwZl4ieqdvCDwAwJgV8qbPQSHwAABOIPAATAi35UJUEHgAJoSLtxEVBB4AwAkEHgAgNPI5RU7gAQBuqdDnaPM5RU7gAQBuKU7naAk8AIATCDwAgBMIPACAEwg8AIATCLwc3DECAOKKwMsRn9VIABAVhbrygcADABRVoa58IPAAAE4g8AAATiDwgAjyEmy6wFix1QARZNlssZuACHP1GYYEHgA4Jk73xxwLAg8A4AQCDwDgBAIPAOAEAg8A4AQCDwAQqLCuAiXwAACBCusqUAJvNEJ6tAIAGD0CbzRCerQCALFRgIEFgQcAKL4CDCwIPACAEwg8hXdFEYDh2F6LIw79TuApvCuKRuJ5Xiy+gMBYRXF7jYM49DuBF1FmFosvIEaPAxxgYgg8ALHjeZ7E8QGGIPCAiGBEP3pmJtFdoVTMmQoCDxgvphgxVnxninrgRuAB48WIC2PFd6aoCDwg5hIJNnNAIvBiiCkT5Mpms8VuAhAKBN44hfeomSkTALiZsO61Q4+jZgDXeaE9AMaN+CsBwAQZB8CRQOABQKSN77x9eE/L5I97nxgAYmV85+1dPC1D4CGv4nD/xxh8BOCWEolELLbT0SDwkFc33lUhqk94MJMSiZJiN2NUPI9NGmOTzWaduW1dabEbgBDxvLzeCSLSG1VEctrMvWkqYLQ4HMQNIhxIeZYdHCx2EwBMEIFXBEFO6wU6RUjeARiDRMROURB4RRDk1F6kpwmBiPrgfLSbu88bD7KzEdv/uPkXK5IoLtiIO5dWqCE4Zubs+dIoH2TnJfDOnz+vxx57TDNnztSUKVP0kY98RK2trf77ZqYdO3aoqqpK5eXlWrlypU6dOpXzM/r6+rRlyxbNmjVLU6dO1dq1a3Xu3Ll8NLdgovxFiSuXVqhhHDgWipXAA6+np0cPPPCAysrK9F//9V86ffq0/uVf/kV/8id/4td56aWXtHPnTu3atUvHjh1TOp3WQw89pEuXLvl16uvrtX//fjU1NenQoUO6fPmy6urqNMjiAQCFwrFQvFjAnn76aVu2bNkt389ms5ZOp62xsdF/7erVq5ZKpWzPnj1mZnbx4kUrKyuzpqYmv8758+ctkUjYgQMHbvpzr169aplMxi+dnZ2mD76uFEr0i+cVvw0USpFKJpMJJJ8CH+G98cYbWrJkiT772c9q9uzZuvfee/XKK6/47585c0ZdXV1avXq1/1oymdSKFSt0+PBhSVJra6uuXbuWU6eqqko1NTV+naEaGhqUSqX8cueddwb90RAxsTo3F8Np11j9fRAJgQfer3/9a+3evVsLFizQf//3f2vTpk360pe+pP/4j/+QJHV1dUmSKisrc/5dZWWl/15XV5cmTZqk6dOn37LOUNu2bVMmk/FLZ2dn0B8NEWMxDIk44e+DQgv8TivZbFZLlizRiy++KEm69957derUKe3evVuPP/64X2/o0Z2Z3faIb6Q6yWRSyWRygq0fgacPBteIDc/z2OkCDgl8hDdnzhx9+MMfznnt7rvvVkdHhyQpnU5L0rCRWnd3tz/qS6fT6u/vV09Pzy3rFBz7xfgxYxEe4JDAA++BBx7QO++8k/Pau+++q3nz5kmSqqurlU6n1dzc7L/f39+vlpYWLV26VJJUW1ursrKynDoXLlzQyZMn/TrARF0/Iw6giAp5LjeQpS83OHr0qJWWltoLL7xgv/rVr+xb3/qWTZkyxfbu3evXaWxstFQqZfv27bP29nZbt26dzZkzx3p7e/06mzZtsrlz59rBgwetra3NVq1aZYsXL7aBgYFRtSOTyRR9ZRElGsVjBSSFUrzi3b5OUKs0Aw88M7Pvfe97VlNTY8lk0hYuXGgvv/xyzvvZbNa2b99u6XTaksmkLV++3Nrb23PqXLlyxTZv3mwzZsyw8vJyq6urs46OjlG3gcCjUCiUeJSgAs8zi+dZ+97eXqVSqWI3A6PA4hEAI8lkMpo2bdqEfw730kTREXYACoHAg3MSiWh97b2ItRfDcZF9OLAlwTnZbLTucm8Ra2/U5SObmMUIBwIPAG6QcPQ5d0EpLSsN7YiWvyxiK6wbHcJtkBH1hGQHs6E9bRD4rcWAsCjmNFIi4SmbZRoLhRGmlc5hPmUQzhgGIm4io0uewo6xCkvYhR2BF1Ie5xEibXBw/Ee5PIUdyA/2qiFlYocHh3mcgx2PsJ47Cwt6J6w4wh8zdpAxYkzTjUeYz5+FAYGH2GAHCWAkBB6AWCotZRE6chF4iCWPR7tOTAymhwcGBordhNiK6ukDAg+xxKKfCWJ62DljCTHP8/K/QCYPocqYH84J00W6iCtPithB11i2iYIsjsnDNsoIDwWXSHhFnRIh7JB/fMfCiBEeCo5bbiHyojeAgxjhAbET1QUFkULYRRKBh4LyvOJOZ7qAKVvg5gg8FJSZRXaHzG2bgGhjCwZGids2TQwj+wDQhxNC4AEoiJKSUiUS7LAnZBSzIxxY3BqrNBEKXBsXfwMD14rdBCewHd0aIzyEAhspgHwj8AAATiDwEBqcexgZq0SBiWELQmgwrTky+icaODDJFaYDWf4yuK2SRILV0CFA4IXICBsEl6+EF6s0cVuDbMBADm6lOXphOlBjhIfbGs2UBA9cxUSN9DUL07SYNLqdeNjaDAIPozCajZsHro6Mnd/tjfQ1C9MoYbSi2OYw8JS/G8oQeEABsPPDWLl6kGTKy7NfJRF4ABBKHCQFj8ADCsXRI3YgLAg8oFA4YgeKisDLIy+RiNU8fElpyfAXY/T5AMQbgZdHls3Gah5+cGBw2GtxijvPY3OIK/62kAg8TFCcAt0frDJqjR2z8d88gWtM44PAA/7IvyVUjEIcEzfWa0w5XgovAi/K2LKA0OF4KbwIvChjywKQB2VlZUVdcJev303gjVOcVl/CPYlEghkC3NK1a9eKen4+X7+bwLuJ0YRZnBZrwD1Zs9DNEHAQiXwj8G6CMEPshfA7znaHfCPwABRVaSmP5URhEHgAimpgYKDYTcBNxHGCmcADAAwTxwlmAg8A4AQCDwDgBAJvDFg2DQDRReCNAcum4TqeOoAo49sbFEZ/RZUoucmz+lxQ4O/dRJ46EJgQbmshbBJugsALCqO/osoODn9WnxNc/NqFcFsLYZNwEwQeEGnsaeOCNQL5R+ABcA7h4iYCD4FiRxIvcf17hm4BmueFr00xROAhUGy08cLfs0Do54Ig8IBh4jmqAVxH4MFtN52y42g7LuI6JYvxIfDgNqaSIslLjG7XxZQsbkTgAQhcvkdWlg3BBfCInMADb2BgQF/5yldUXV2t8vJyzZ8/X88//7yyN3xBzUw7duxQVVWVysvLtXLlSp06dSrn5/T19WnLli2aNWuWpk6dqrVr1+rcuXNBNxdAHjCyQihZwL761a/azJkz7fvf/76dOXPGvvOd79iHPvQh+9rXvubXaWxstIqKCnv99detvb3dHn30UZszZ4719vb6dTZt2mR33HGHNTc3W1tbm33iE5+wxYsX28DAwKjakclkTB+cjKFQKBRKhEsmkwkknwIPvDVr1tgXvvCFnNc+85nP2GOPPWZmZtls1tLptDU2NvrvX7161VKplO3Zs8fMzC5evGhlZWXW1NTk1zl//rwlEgk7cODAqNpB4I2vePKK3gYKhUK5sQQVeIFPaS5btkw/+tGP9O6770qSfv7zn+vQoUP61Kc+JUk6c+aMurq6tHr1av/fJJNJrVixQocPH5Yktba26tq1azl1qqqqVFNT49cZqq+vT729vTkFY2eyYjcBRVJSWsqqRsRaadA/8Omnn1Ymk9HChQtVUlKiwcFBvfDCC1q3bp0kqaurS5JUWVmZ8+8qKyt19uxZv86kSZM0ffr0YXWu//uhGhoa9NxzzwX9cQBnDA4MFLsJQF4FPsJ77bXXtHfvXn37299WW1ubvvnNb+qf//mf9c1vfjOn3tAjSTO77dHlSHW2bdumTCbjl87Ozol9EABArAQ+wvvyl7+sZ555Rp/73OckSYsWLdLZs2fV0NCgjRs3Kp1OS/pgFDdnzhz/33V3d/ujvnQ6rf7+fvX09OSM8rq7u7V06dKb/t5kMqlkMhn0x0HIedyD0Hl8BzBagY/w3n//fSWGXBRaUlLiX5ZQXV2tdDqt5uZm//3+/n61tLT4YVZbW6uysrKcOhcuXNDJkydvGXhwEzs6jO47wLlJSIGv0ty4caPdcccd/mUJ+/bts1mzZtlTTz3l12lsbLRUKmX79u2z9vZ2W7du3U0vS5g7d64dPHjQ2trabNWqVVyWQKFQKHkunhe+ldqhvSyht7fXtm7danfddZdNnjzZ5s+fb88++6z19fX5dbLZrG3fvt3S6bQlk0lbvny5tbe35/ycK1eu2ObNm23GjBlWXl5udXV11tHRMep2EHgUCoUSjxJU4Hlm8ZwT6u3tVSqVKnYznHB9IVFMv0oAiiyTyWjatGkT/jncS1OSPI/rjyYqD2HH3wRAkAJfpRlJxuXWE8HIDkAUMMJDaBGkAIJE4AEAnEDg4Y84XwYg3gg8/BHThwDijcADimToHYkA5BdbHFAk12+3B6AwCDwAgBMIPACAEwg8ALFQkigpdhMQcgQegFgYzA4WuwkIOScCj1syAgCcCDzuUAUAcCLwAAAg8AAATiDwgELjpDJQFAQeUGgxPanMA3sRdgRekbBriD/XAoDnFyLsCLwiYdcQfwQAEC4EHgDACQQeAMAJBB4AhJyXSIgz/xNXWuwGAABGZjw7MRCM8AAATiDwIq5QS989eX+cVgGA0QnbpTnswSKuUEvfTca0CkLF89h9hV3YLs3hG4OiC9cxIKLCjAOwOMrnqJDAQ9GF6xgQUcRBU3zkc1RI4AGIPA6aMBoEHgCECcPVvCHwACBMGK7mDYEHAHACgQcAcAKBBwBwAoEHRETY7lqB4Qp25yO+C+NC4AEREba7VmA4/kbhRuABQMQQrOND4AEhxbQVECwCDwgpjuKBYBF4AAAnEHgAACcQeAAAJxB4ecBiAwBRknBkn0Xg5QGLDQBESdaRfRaBBwBwAoEHAHACgQcAcAKBB0SEKwsLgHwh8IDIIPCAiSDwgIjIWrbYTRiGS3AQJQQegHHjEhxECYEHAHACgQcAcAKBBwBwAoGXR5zQB4DwIPDyiBP6ABAeBB4AxBSzTLkIPACIKWaZchF4AAAnEHgAACeMOfB++tOf6tOf/rSqqqrkeZ6++93v5rxvZtqxY4eqqqpUXl6ulStX6tSpUzl1+vr6tGXLFs2aNUtTp07V2rVrde7cuZw6PT092rBhg1KplFKplDZs2KCLFy+O+QMCACCNI/D+8Ic/aPHixdq1a9dN33/ppZe0c+dO7dq1S8eOHVM6ndZDDz2kS5cu+XXq6+u1f/9+NTU16dChQ7p8+bLq6uo0ODjo1/n85z+vEydO6MCBAzpw4IBOnDihDRs2jOMjAgAgySZAku3fv9///2w2a+l02hobG/3Xrl69aqlUyvbs2WNmZhcvXrSysjJramry65w/f94SiYQdOHDAzMxOnz5tkuytt97y6xw5csQk2S9/+ctRtS2TyZgkCoVCoUS8ZDKZiUSVL9BzeGfOnFFXV5dWr17tv5ZMJrVixQodPnxYktTa2qpr167l1KmqqlJNTY1f58iRI0qlUrrvvvv8Oh//+MeVSqX8OkP19fWpt7c3pwAAcF2ggdfV1SVJqqyszHm9srLSf6+rq0uTJk3S9OnTR6wze/bsYT9/9uzZfp2hGhoa/PN9qVRKd95554Q/DxA3xb4uq9i/H27LyyrNoV9qM7vtF31onZvVH+nnbNu2TZlMxi+dnZ3jaDkQb1bk67KK/fvhtkADL51OS9KwUVh3d7c/6kun0+rv71dPT8+IdX7zm98M+/m//e1vh40er0smk5o2bVpOAQDgukADr7q6Wul0Ws3Nzf5r/f39amlp0dKlSyVJtbW1Kisry6lz4cIFnTx50q9z//33K5PJ6OjRo36dt99+W5lMxq8DAMCYjHWVy6VLl+z48eN2/Phxk2Q7d+6048eP29mzZ83MrLGx0VKplO3bt8/a29tt3bp1NmfOHOvt7fV/xqZNm2zu3Ll28OBBa2trs1WrVtnixYttYGDAr/Pwww/bPffcY0eOHLEjR47YokWLrK6ubtTtZJUmhUKhxKMEtUpzzIH35ptv3rRBGzduNLMPLk3Yvn27pdNpSyaTtnz5cmtvb8/5GVeuXLHNmzfbjBkzrLy83Orq6qyjoyOnznvvvWfr16+3iooKq6iosPXr11tPT8+o20ngUSgUSjxKUIHnmcXzLHJvb69SqVSxmwEAmKBMJhPIuozY3kszpjkOAM4Jan8e28B77733it0EAEAAbrw15USUBvJTQmjGjBmSpI6ODqY2b6G3t1d33nmnOjs7uYzjJuifkdE/I6N/Rjaa/jEzXbp0SVVVVYH8ztgGXiLxweA1lUrxZbsNrlscGf0zMvpnZPTPyG7XP0EOWGI7pQkAwI0IPACAE2IbeMlkUtu3b1cymSx2U0KLPhoZ/TMy+mdk9M/IitE/sb0ODwCAG8V2hAcAwI0IPACAEwg8AIATCDwAgBMIPACAE2IbeN/4xjdUXV2tyZMnq7a2Vj/72c+K3aS8a2ho0Mc+9jFVVFRo9uzZeuSRR/TOO+/k1DEz7dixQ1VVVSovL9fKlSt16tSpnDp9fX3asmWLZs2apalTp2rt2rU6d+5cIT9KQTQ0NMjzPNXX1/uv0T/S+fPn9dhjj2nmzJmaMmWKPvKRj6i1tdV/3+U+GhgY0Fe+8hVVV1ervLxc8+fP1/PPP69sNuvXcal/fvrTn+rTn/60qqqq5Hmevvvd7+a8H1Rf9PT0aMOGDUqlUkqlUtqwYYMuXrw49gYH8pChkGlqarKysjJ75ZVX7PTp07Z161abOnWq/5DauPrLv/xLe/XVV+3kyZN24sQJW7Nmjd111112+fJlv05jY6NVVFTY66+/bu3t7fboo4/e9AG9d9xxhzU3N1tbW5t94hOfGPaA3qg7evSo/emf/qndc889tnXrVv911/vn97//vc2bN8/+5m/+xt5++207c+aMHTx40P7nf/7Hr+NyH331q1+1mTNn2ve//307c+aMfec737EPfehD9rWvfc2v41L//OAHP7Bnn33WXn/9dZNk+/fvz3k/qL54+OGHraamxg4fPmyHDx+2mpqaMT0Q/LpYBt6f//mf26ZNm3JeW7hwoT3zzDNFalFxdHd3myRraWkxsw8ezptOp62xsdGvc/XqVUulUrZnzx4zM7t48aKVlZVZU1OTX+f8+fOWSCTswIEDhf0AeXLp0iVbsGCBNTc324oVK/zAo3/Mnn76aVu2bNkt33e9j9asWWNf+MIXcl77zGc+Y4899piZud0/QwMvqL44ffq0SbK33nrLr3PkyBGTZL/85S/H1MbYTWn29/ertbVVq1evznl99erVOnz4cJFaVRyZTEbS/z054syZM+rq6srpm2QyqRUrVvh909raqmvXruXUqaqqUk1NTWz674knntCaNWv0yU9+Mud1+kd64403tGTJEn32s5/V7Nmzde+99+qVV17x33e9j5YtW6Yf/ehHevfddyVJP//5z3Xo0CF96lOfkkT/3Ciovjhy5IhSqZTuu+8+v87HP/5xpVKpMfdX7J6W8Lvf/U6Dg4OqrKzMeb2yslJdXV1FalXhmZmefPJJLVu2TDU1NZLkf/6b9c3Zs2f9OpMmTdL06dOH1YlD/zU1NamtrU3Hjh0b9h79I/3617/W7t279eSTT+qf/umfdPToUX3pS19SMpnU448/7nwfPf3008pkMlq4cKFKSko0ODioF154QevWrZPEd+hGQfVFV1eXZs+ePeznz549e8z9FbvAu87zvJz/N7Nhr8XZ5s2b9Ytf/EKHDh0a9t54+iYO/dfZ2amtW7fqhz/8oSZPnnzLeq72jyRls1ktWbJEL774oiTp3nvv1alTp7R79249/vjjfj1X++i1117T3r179e1vf1t/9md/phMnTqi+vl5VVVXauHGjX8/V/rmZIPriZvXH01+xm9KcNWuWSkpKhiV/d3f3sCONuNqyZYveeOMNvfnmm5o7d67/ejqdlqQR+yadTqu/v189PT23rBNVra2t6u7uVm1trUpLS1VaWqqWlhZ9/etfV2lpqf/5XO0fSZozZ44+/OEP57x29913q6OjQxLfoS9/+ct65pln9LnPfU6LFi3Shg0b9Pd///dqaGiQRP/cKKi+SKfT+s1vfjPs5//2t78dc3/FLvAmTZqk2tpaNTc357ze3NyspUuXFqlVhWFm2rx5s/bt26cf//jHqq6uznm/urpa6XQ6p2/6+/vV0tLi901tba3Kyspy6ly4cEEnT56MfP89+OCDam9v14kTJ/yyZMkSrV+/XidOnND8+fOd7h9JeuCBB4ZdyvLuu+9q3rx5kvgOvf/++/7Dpa8rKSnxL0twvX9uFFRf3H///cpkMjp69Khf5+2331Ymkxl7f41piUtEXL8s4d/+7d/s9OnTVl9fb1OnTrX//d//LXbT8uqLX/yipVIp+8lPfmIXLlzwy/vvv+/XaWxstFQqZfv27bP29nZbt27dTZcJz5071w4ePGhtbW22atWqSC6ZHo0bV2ma0T9Hjx610tJSe+GFF+xXv/qVfetb37IpU6bY3r17/Tou99HGjRvtjjvu8C9L2Ldvn82aNcueeuopv45L/XPp0iU7fvy4HT9+3CTZzp077fjx4/4lYEH1xcMPP2z33HOPHTlyxI4cOWKLFi3isoQb/eu//qvNmzfPJk2aZB/96Ef9pflxJumm5dVXX/XrZLNZ2759u6XTaUsmk7Z8+XJrb2/P+TlXrlyxzZs324wZM6y8vNzq6uqso6OjwJ+mMIYGHv1j9r3vfc9qamosmUzawoUL7eWXX8553+U+6u3tta1bt9pdd91lkydPtvnz59uzzz5rfX19fh2X+ufNN9+86T5n48aNZhZcX7z33nu2fv16q6iosIqKClu/fr319PSMub08Dw8A4ITYncMDAOBmCDwAgBMIPACAEwg8AIATCDwAgBMIPACAEwg8AIATCDwAgBMIPACAEwg8AIATCDwAgBP+P2jUP6Z7gGl9AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(rgbds[1][...,:3]-rgbds[0][...,:3])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1024, 1024, 4)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(rgbds[t2] - rgbds[t1]).shape" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[ 0. , 0. , 0. , 0. ],\n", + " [ 0.00392157, 0. , 0.00392157, 0. ],\n", + " [ 0.00392157, 0. , 0. , 0. ],\n", + " ...,\n", + " [ 0. , 0. , 0. , 0. ],\n", + " [-0.00392157, -0.00392157, 0. , 0. ],\n", + " [ 0.00392157, 0.00392157, 0. , 0. ]],\n", + "\n", + " [[ 0. , 0. , -0.00392157, 0. ],\n", + " [ 0.00392157, 0.00392157, 0.00392157, 0. ],\n", + " [-0.00392157, -0.00392157, 0. , 0. ],\n", + " ...,\n", + " [ 0.00392157, 0.00392157, 0.00392157, 0. ],\n", + " [ 0. , 0. , 0. , 0. ],\n", + " [-0.00392157, -0.00392157, -0.00392157, 0. ]],\n", + "\n", + " [[ 0. , 0. , 0. , 0. ],\n", + " [-0.00392157, 0. , -0.00392157, 0. ],\n", + " [-0.00392157, 0. , 0. , 0. ],\n", + " ...,\n", + " [-0.00392157, 0. , -0.00392157, 0. ],\n", + " [ 0.00392157, 0.00392157, 0.00784314, 0. ],\n", + " [ 0. , 0. , 0.00392157, 0. ]],\n", + "\n", + " ...,\n", + "\n", + " [[-0.00392157, -0.00392157, -0.00392157, 0. ],\n", + " [-0.00392157, -0.00392157, -0.00392157, 0. ],\n", + " [ 0. , 0. , 0.00392157, 0. ],\n", + " ...,\n", + " [-0.00392157, -0.00392157, -0.00392157, 0. ],\n", + " [ 0.00392157, 0.00392157, 0. , 0. ],\n", + " [ 0.00392157, 0.00392157, 0.00392157, 0. ]],\n", + "\n", + " [[ 0. , 0. , 0. , 0. ],\n", + " [ 0. , 0. , 0. , 0. ],\n", + " [ 0. , -0.00392157, 0. , 0. ],\n", + " ...,\n", + " [ 0. , 0. , 0. , 0. ],\n", + " [ 0. , 0. , 0. , 0. ],\n", + " [ 0. , 0. , 0. , 0. ]],\n", + "\n", + " [[ 0.00392157, 0.00392157, 0.00392157, 0. ],\n", + " [-0.00392157, -0.00392157, -0.00392157, 0. ],\n", + " [ 0.00392157, 0.00392157, 0.00392157, 0. ],\n", + " ...,\n", + " [ 0.00392157, 0.00392157, 0.00392157, 0. ],\n", + " [ 0. , -0.00392157, 0. , 0. ],\n", + " [ 0.00392157, 0. , 0. , 0. ]]])" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rgbds[t2] - rgbds[t1]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(seg_arr[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import h5py\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 pilot-containment-cone-plate_0031.hdf5\n", + "1 pilot-containment-bowl-familiarization_0018.hdf5\n", + "1 pilot-containment-bowl_0026.hdf5\n", + "1 pilot-containment-multi-bowl_0048.hdf5\n", + "1 pilot-containment-cylinder-bowl_0021.hdf5\n", + "5 pilot-containment-vase_torus_0033.hdf5\n", + "1 pilot-containment-multi-bowl_0029.hdf5\n", + "1 pilot-containment-bowl-familiarization_0033.hdf5\n", + "5 pilot-containment-vase_torus_0009.hdf5\n", + "1 pilot-containment-multi-bowl_0025.hdf5\n", + "5 pilot-containment-vase_torus_0043.hdf5\n", + "5 pilot-containment-vase_torus_0031.hdf5\n", + "1 pilot-containment-bowl-familiarization_0026.hdf5\n", + "5 pilot-containment-vase_torus_0032.hdf5\n", + "1 pilot-containment-torus_0022.hdf5\n", + "1 pilot-containment-bowl-familiarization_0024.hdf5\n", + "1 pilot-containment-bowl-familiarization_0035.hdf5\n", + "1 pilot-containment-bowl_0000.hdf5\n", + "1 pilot-containment-cylinder-bowl_0010.hdf5\n", + "5 pilot-containment-vase_0000.hdf5\n", + "1 pilot-containment-cylinder-bowl_0028.hdf5\n", + "1 pilot-containment-cylinder-bowl_0026.hdf5\n", + "1 pilot-containment-multi-bowl_0042.hdf5\n", + "1 pilot-containment-torus_0017.hdf5\n", + "1 pilot-containment-cylinder-bowl_0023.hdf5\n", + "5 pilot-containment-vase_0031.hdf5\n", + "1 pilot-containment-bowl_0044.hdf5\n", + "1 pilot-containment-cylinder-bowl_0006.hdf5\n", + "1 pilot-containment-bowl_0024.hdf5\n", + "5 pilot-containment-vase_torus_0037.hdf5\n", + "1 pilot-containment-multi-bowl_0037.hdf5\n", + "5 pilot-containment-vase_torus_0030.hdf5\n", + "5 pilot-containment-vase_0020.hdf5\n", + "1 pilot-containment-multi-bowl_0011.hdf5\n", + "5 pilot-containment-vase_0036.hdf5\n", + "5 pilot-containment-vase_torus_0002.hdf5\n", + "1 pilot-containment-torus_0013.hdf5\n", + "5 pilot-containment-vase_torus_0029.hdf5\n", + "1 pilot-containment-cylinder-bowl_0029.hdf5\n", + "1 pilot-containment-cylinder-bowl_0009.hdf5\n", + "5 pilot-containment-vase_torus_0024.hdf5\n", + "1 pilot-containment-torus_0046.hdf5\n", + "1 pilot-containment-multi-bowl_0049.hdf5\n", + "1 pilot-containment-cone-plate_0029.hdf5\n", + "1 pilot-containment-multi-bowl_0032.hdf5\n", + "1 pilot-containment-bowl-familiarization_0025.hdf5\n", + "1 pilot-containment-torus_0048.hdf5\n", + "1 pilot-containment-cylinder-bowl_0032.hdf5\n", + "1 pilot-containment-bowl-familiarization_0010.hdf5\n", + "1 pilot-containment-bowl_0020.hdf5\n", + "1 pilot-containment-bowl-familiarization_0049.hdf5\n", + "1 pilot-containment-bowl-familiarization_0019.hdf5\n", + "5 pilot-containment-vase_0035.hdf5\n", + "1 pilot-containment-torus_0004.hdf5\n", + "1 pilot-containment-cylinder-bowl_0003.hdf5\n", + "5 pilot-containment-vase_0008.hdf5\n", + "1 pilot-containment-torus_0009.hdf5\n", + "1 pilot-containment-bowl_0046.hdf5\n", + "1 pilot-containment-cone-plate_0007.hdf5\n", + "1 pilot-containment-bowl_0042.hdf5\n", + "5 pilot-containment-vase_torus_0000.hdf5\n", + "5 pilot-containment-vase_0023.hdf5\n", + "1 pilot-containment-multi-bowl_0008.hdf5\n", + "1 pilot-containment-multi-bowl_0019.hdf5\n", + "1 pilot-containment-cylinder-bowl_0041.hdf5\n", + "1 pilot-containment-torus_0042.hdf5\n", + "1 pilot-containment-cone-plate_0034.hdf5\n", + "5 pilot-containment-vase_torus_0045.hdf5\n", + "1 pilot-containment-cylinder-bowl_0035.hdf5\n", + "1 pilot-containment-bowl_0005.hdf5\n", + "5 pilot-containment-vase_torus_0047.hdf5\n", + "5 pilot-containment-vase_torus_0023.hdf5\n", + "1 pilot-containment-multi-bowl_0010.hdf5\n", + "1 pilot-containment-bowl_0034.hdf5\n", + "5 pilot-containment-vase_0019.hdf5\n", + "1 pilot-containment-bowl-familiarization_0029.hdf5\n", + "1 pilot-containment-bowl-familiarization_0013.hdf5\n", + "1 pilot-containment-torus_0010.hdf5\n", + "1 pilot-containment-multi-bowl_0005.hdf5\n", + "1 pilot-containment-torus_0020.hdf5\n", + "1 pilot-containment-bowl-familiarization_0004.hdf5\n", + "1 pilot-containment-bowl_0012.hdf5\n", + "5 pilot-containment-vase_0039.hdf5\n", + "1 pilot-containment-bowl-familiarization_0044.hdf5\n", + "1 pilot-containment-bowl_0031.hdf5\n", + "5 pilot-containment-vase_0015.hdf5\n", + "1 pilot-containment-cylinder-bowl_0046.hdf5\n", + "1 pilot-containment-cone-plate_0045.hdf5\n", + "1 pilot-containment-cylinder-bowl_0042.hdf5\n", + "1 pilot-containment-multi-bowl_0018.hdf5\n", + "1 pilot-containment-bowl_0030.hdf5\n", + "1 pilot-containment-bowl_0040.hdf5\n", + "1 pilot-containment-cylinder-bowl_0011.hdf5\n", + "1 pilot-containment-bowl_0009.hdf5\n", + "1 pilot-containment-bowl_0017.hdf5\n", + "1 pilot-containment-cylinder-bowl_0018.hdf5\n", + "1 pilot-containment-cylinder-bowl_0027.hdf5\n", + "5 pilot-containment-vase_0017.hdf5\n", + "5 pilot-containment-vase_torus_0042.hdf5\n", + "1 pilot-containment-torus_0014.hdf5\n", + "5 pilot-containment-vase_0046.hdf5\n", + "1 pilot-containment-multi-bowl_0016.hdf5\n", + "1 pilot-containment-bowl_0015.hdf5\n", + "5 pilot-containment-vase_0027.hdf5\n", + "1 pilot-containment-bowl_0048.hdf5\n", + "1 pilot-containment-multi-bowl_0046.hdf5\n", + "1 pilot-containment-bowl_0049.hdf5\n", + "1 pilot-containment-cylinder-bowl_0030.hdf5\n", + "1 pilot-containment-torus_0038.hdf5\n", + "1 pilot-containment-multi-bowl_0023.hdf5\n", + "1 pilot-containment-multi-bowl_0036.hdf5\n", + "5 pilot-containment-vase_0005.hdf5\n", + "1 pilot-containment-bowl_0035.hdf5\n", + "5 pilot-containment-vase_0006.hdf5\n", + "1 pilot-containment-cylinder-bowl_0043.hdf5\n", + "1 pilot-containment-multi-bowl_0015.hdf5\n", + "1 pilot-containment-torus_0026.hdf5\n", + "1 pilot-containment-bowl_0023.hdf5\n", + "5 pilot-containment-vase_0033.hdf5\n", + "1 pilot-containment-multi-bowl_0035.hdf5\n", + "1 pilot-containment-torus_0040.hdf5\n", + "1 pilot-containment-torus_0035.hdf5\n", + "1 pilot-containment-cone-plate_0017.hdf5\n", + "1 pilot-containment-multi-bowl_0017.hdf5\n", + "1 pilot-containment-bowl-familiarization_0006.hdf5\n", + "1 pilot-containment-bowl-familiarization_0021.hdf5\n", + "1 pilot-containment-bowl-familiarization_0036.hdf5\n", + "1 pilot-containment-multi-bowl_0040.hdf5\n", + "1 pilot-containment-torus_0015.hdf5\n", + "1 pilot-containment-torus_0043.hdf5\n", + "5 pilot-containment-vase_torus_0005.hdf5\n", + "1 pilot-containment-cylinder-bowl_0033.hdf5\n", + "1 pilot-containment-bowl_0045.hdf5\n", + "1 pilot-containment-bowl-familiarization_0037.hdf5\n", + "5 pilot-containment-vase_torus_0046.hdf5\n", + "1 pilot-containment-multi-bowl_0031.hdf5\n", + "1 pilot-containment-bowl-familiarization_0027.hdf5\n", + "5 pilot-containment-vase_torus_0028.hdf5\n", + "1 pilot-containment-bowl_0021.hdf5\n", + "1 pilot-containment-bowl-familiarization_0020.hdf5\n", + "1 pilot-containment-bowl_0025.hdf5\n", + "5 pilot-containment-vase_0043.hdf5\n", + "1 pilot-containment-bowl-familiarization_0008.hdf5\n", + "1 pilot-containment-torus_0030.hdf5\n", + "1 pilot-containment-cylinder-bowl_0045.hdf5\n", + "5 pilot-containment-vase_0028.hdf5\n", + "1 pilot-containment-bowl-familiarization_0009.hdf5\n", + "1 pilot-containment-torus_0000.hdf5\n", + "1 pilot-containment-torus_0037.hdf5\n", + "1 pilot-containment-bowl_0022.hdf5\n", + "1 pilot-containment-bowl_0029.hdf5\n", + "1 pilot-containment-cone-plate_0020.hdf5\n", + "1 pilot-containment-cone-plate_0022.hdf5\n", + "5 pilot-containment-vase_0032.hdf5\n", + "1 pilot-containment-torus_0011.hdf5\n", + "1 pilot-containment-multi-bowl_0041.hdf5\n", + "1 pilot-containment-torus_0044.hdf5\n", + "1 pilot-containment-multi-bowl_0045.hdf5\n", + "1 pilot-containment-multi-bowl_0006.hdf5\n", + "1 pilot-containment-cylinder-bowl_0022.hdf5\n", + "1 pilot_it2_collision_simple_box_1_dis_1_occ_0034.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0003.hdf5\n", + "1 pilot_it2_collision_yeet_tdw_1_dis_1_occ_0038.hdf5\n", + "1 pilot_it2_collision_tiny_ball_box_0023.hdf5\n", + "1 pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0025.hdf5\n", + "1 pilot_it2_collision_simple_box_1_dis_1_occ_0014.hdf5\n", + "1 pilot_it2_collision_yeet_tdw_1_dis_1_occ_0025.hdf5\n", + "1 pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0039.hdf5\n", + "1 pilot_it2_collision_tiny_ball_box_0037.hdf5\n", + "1 pilot_it2_collision_simple_box_1_dis_1_occ_0018.hdf5\n", + "1 pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0028.hdf5\n", + "1 pilot_it2_collision_tiny_ball_box_0013.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0012.hdf5\n", + "1 pilot_it2_collision_yeet_tdw_1_dis_1_occ_0021.hdf5\n", + "1 pilot_it2_collision_assorted_targets_box_0017.hdf5\n", + "1 pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0030.hdf5\n", + "1 pilot_it2_collision_yeet_tdw_1_dis_1_occ_0039.hdf5\n", + "1 pilot_it2_collision_yeet_tdw_1_dis_1_occ_0007.hdf5\n", + "1 pilot_it2_collision_simple_box_0017.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0021.hdf5\n", + "1 pilot_it2_collision_tiny_ball_box_0017.hdf5\n", + "1 pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0038.hdf5\n", + "1 pilot_it2_collision_yeet_tdw_1_dis_1_occ_0032.hdf5\n", + "1 pilot_it2_collision_yeet_tdw_1_dis_1_occ_0017.hdf5\n", + "1 pilot_it2_collision_tiny_ball_box_0029.hdf5\n", + "1 pilot_it2_collision_simple_box_1_dis_1_occ_0008.hdf5\n", + "1 pilot_it2_collision_assorted_targets_tdw_1_dis_1_occ_0027.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0039.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0015.hdf5\n", + "1 pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0023.hdf5\n", + "1 pilot_it2_collision_yeet_tdw_1_dis_1_occ_0011.hdf5\n", + "1 pilot_it2_collision_tiny_ball_tdw_1_dis_1_occ_0000.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0025.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0034.hdf5\n", + "1 pilot_it2_collision_yeet_box_0029.hdf5\n", + "1 pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0034.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0016.hdf5\n", + "1 pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0015.hdf5\n", + "1 pilot_it2_collision_simple_box_0006.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0032.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0017.hdf5\n", + "1 pilot_it2_collision_assorted_targets_box_0011.hdf5\n", + "1 pilot_it2_collision_simple_box_0005.hdf5\n", + "1 pilot_it2_collision_yeet_box_0026.hdf5\n", + "1 pilot_it2_collision_yeet_tdw_1_dis_1_occ_0036.hdf5\n", + "1 pilot_it2_collision_yeet_box_0030.hdf5\n", + "1 pilot_it2_collision_simple_box_1_dis_1_occ_0038.hdf5\n", + "1 pilot_it2_collision_tiny_ball_box_0034.hdf5\n", + "1 pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0004.hdf5\n", + "1 pilot_it2_collision_assorted_targets_tdw_1_dis_1_occ_0034.hdf5\n", + "1 pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0032.hdf5\n", + "1 pilot_it2_collision_yeet_tdw_1_dis_1_occ_0023.hdf5\n", + "1 pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0010.hdf5\n", + "1 pilot_it2_collision_simple_box_0025.hdf5\n", + "1 pilot_it2_collision_tiny_ball_tdw_1_dis_1_occ_0021.hdf5\n", + "1 pilot_it2_collision_simple_box_1_dis_1_occ_0022.hdf5\n", + "1 pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0020.hdf5\n", + "1 pilot_it2_collision_simple_box_1_dis_1_occ_0013.hdf5\n", + "1 pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0011.hdf5\n", + "1 pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0000.hdf5\n", + "1 pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0024.hdf5\n", + "1 pilot_it2_collision_yeet_box_0021.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0002.hdf5\n", + "1 pilot_it2_collision_simple_box_1_dis_1_occ_0009.hdf5\n", + "1 pilot_it2_collision_simple_box_0015.hdf5\n", + "1 pilot_it2_collision_tiny_ball_box_0014.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0035.hdf5\n", + "1 pilot_it2_collision_yeet_box_0007.hdf5\n", + "1 pilot_it2_collision_assorted_targets_tdw_1_dis_1_occ_0035.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0018.hdf5\n", + "1 pilot_it2_collision_simple_box_1_dis_1_occ_0005.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0023.hdf5\n", + "1 pilot_it2_collision_assorted_targets_box_0007.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0037.hdf5\n", + "1 pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0017.hdf5\n", + "1 pilot_it2_collision_tiny_ball_box_0003.hdf5\n", + "1 pilot_it2_collision_tiny_ball_box_0024.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0007.hdf5\n", + "1 pilot_it2_collision_assorted_targets_box_0003.hdf5\n", + "1 pilot_it2_collision_assorted_targets_tdw_1_dis_1_occ_0007.hdf5\n", + "1 pilot_it2_collision_tiny_ball_box_0002.hdf5\n", + "1 pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0033.hdf5\n", + "1 pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0019.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0019.hdf5\n", + "1 pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0008.hdf5\n", + "1 pilot_it2_collision_simple_box_1_dis_1_occ_0024.hdf5\n", + "1 pilot_it2_collision_yeet_tdw_1_dis_1_occ_0005.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0033.hdf5\n", + "1 pilot_it2_collision_simple_box_0012.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0009.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0010.hdf5\n", + "1 pilot_it2_collision_yeet_tdw_1_dis_1_occ_0035.hdf5\n", + "1 pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0007.hdf5\n", + "1 pilot_it2_collision_yeet_tdw_1_dis_1_occ_0026.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0030.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0013.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0036.hdf5\n", + "1 pilot_it2_collision_yeet_tdw_1_dis_1_occ_0015.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0038.hdf5\n", + "1 pilot_it2_collision_yeet_box_0005.hdf5\n", + "1 pilot_it2_collision_tiny_ball_tdw_1_dis_1_occ_0037.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0029.hdf5\n", + "1 pilot_it2_collision_non-sphere_box_0004.hdf5\n", + "1 pilot_it2_collision_yeet_tdw_1_dis_1_occ_0020.hdf5\n", + "1 pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0035.hdf5\n", + "1 pilot_it2_collision_assorted_targets_tdw_1_dis_1_occ_0014.hdf5\n", + "1 pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0014.hdf5\n", + "1 pilot_it2_collision_simple_box_0031.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom_small_rings_0029.hdf5\n", + "1 pilot_linking_nl6_aNone_bCone_occ1_dis1_boxroom_0001.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_0011.hdf5\n", + "1 pilot_linking_nl6_aNone_bCone_occ1_dis1_boxroom_0030.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom1_0037.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom1_0034.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_0009.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0012.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0000.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_long_a_0030.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_0023.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom1_0035.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom1_0012.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom_small_rings_0036.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom_small_rings_0006.hdf5\n", + "1 pilot_linking_nl6_aNone_bCone_occ1_dis1_boxroom_0021.hdf5\n", + "1 pilot_linking_nl2-3_mg01_aCone_bCyl_boxroom_0038.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom1_0034.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom1_0021.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_0000.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom1_0035.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom_small_rings_0015.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_0033.hdf5\n", + "1 pilot_linking_nl6_aNone_bCone_occ1_dis1_boxroom_0010.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom1_0015.hdf5\n", + "1 pilot_linking_nl6_aNone_bCone_occ1_dis1_boxroom_0017.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom_small_rings_0011.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_0033.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom1_0007.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom_small_rings_0008.hdf5\n", + "1 pilot_linking_nl2-3_mg01_aCone_bCyl_boxroom_0024.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom1_0039.hdf5\n", + "1 pilot_linking_nl6_aNone_bCone_occ1_dis1_boxroom_0014.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0036.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom_small_rings_0010.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom_small_rings_0038.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0022.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_0013.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_long_a_0000.hdf5\n", + "1 pilot_linking_nl2-3_mg01_aCone_bCyl_boxroom_0019.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_0038.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_0008.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom_small_rings_0035.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom_small_rings_0011.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom_small_rings_0026.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0002.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom1_0023.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom_small_rings_0020.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0010.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_0032.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom1_0011.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_0039.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_long_a_0017.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_0030.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom1_0028.hdf5\n", + "1 pilot_linking_nl6_aNone_bCone_occ1_dis1_boxroom_0034.hdf5\n", + "1 pilot_linking_nl2-3_mg01_aCone_bCyl_boxroom_0023.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0005.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom_small_rings_0006.hdf5\n", + "1 pilot_linking_nl6_aNone_bCone_occ1_dis1_boxroom_0022.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_0023.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom_small_rings_0012.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom1_0033.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom1_0018.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_long_a_0014.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_0035.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0003.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0030.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0013.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom_small_rings_0001.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_0022.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom1_0013.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_long_a_0015.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom_small_rings_0033.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom_small_rings_0003.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom1_0008.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_0028.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom1_0010.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom_small_rings_0008.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom1_0005.hdf5\n", + "1 pilot_linking_nl2-3_mg01_aCone_bCyl_boxroom_0004.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom1_0005.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_0034.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_0027.hdf5\n", + "1 pilot_linking_nl2-3_mg01_aCone_bCyl_boxroom_0025.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0019.hdf5\n", + "1 pilot_linking_nl2-3_mg01_aCone_bCyl_boxroom_0012.hdf5\n", + "1 pilot_linking_nl2-3_mg01_aCone_bCyl_boxroom_0010.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_0029.hdf5\n", + "1 pilot_linking_nl2-3_mg01_aCone_bCyl_boxroom_0018.hdf5\n", + "1 pilot_linking_nl2-3_mg01_aCone_bCyl_boxroom_0039.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom_small_rings_0028.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom_small_rings_0009.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_long_a_0029.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0037.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_long_a_0011.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0004.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_0007.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_0020.hdf5\n", + "1 pilot_linking_nl2-3_mg01_aCone_bCyl_boxroom_0035.hdf5\n", + "1 pilot_linking_nl6_aNone_bCone_occ1_dis1_boxroom_0032.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0024.hdf5\n", + "1 pilot_linking_nl6_aNone_bCone_occ1_dis1_boxroom_0016.hdf5\n", + "1 pilot_linking_nl6_aNone_bCone_occ1_dis1_boxroom_0036.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom_small_rings_0025.hdf5\n", + "1 pilot_linking_nl2-3_mg01_aCone_bCyl_boxroom_0031.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_0016.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom1_0020.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom_small_rings_0016.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom1_0009.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom1_0036.hdf5\n", + "1 pilot_linking_nl6_aNone_bCone_occ1_dis1_boxroom_0027.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_long_a_0009.hdf5\n", + "1 pilot_linking_nl6_aNone_bCone_occ1_dis1_boxroom_0023.hdf5\n", + "1 pilot_linking_nl2-3_mg01_aCone_bCyl_boxroom_0033.hdf5\n", + "1 pilot_linking_nl6_aNone_bCone_occ1_dis1_boxroom_0015.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom1_0029.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0018.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom1_0024.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0033.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom_small_rings_0022.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_0038.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom_small_rings_0026.hdf5\n", + "1 pilot_linking_nl6_aNone_bCone_occ1_dis1_boxroom_0004.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_long_a_0007.hdf5\n", + "1 pilot_linking_nl2-3_mg01_aCone_bCyl_boxroom_0017.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_long_a_0031.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom_small_rings_0029.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0034.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom_small_rings_0013.hdf5\n", + "1 pilot_linking_nl6_aNone_bCone_occ1_dis1_boxroom_0028.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0011.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0006.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom_small_rings_0036.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom_small_rings_0027.hdf5\n", + "1 pilot_linking_nl6_aNone_bCone_occ1_dis1_boxroom_0031.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_0025.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_0035.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_long_a_0037.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom_small_rings_0031.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_long_a_0038.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_0011.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom_small_rings_0034.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom1_0029.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_long_a_0001.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom1_0003.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom_small_rings_0028.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_0010.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_0026.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0038.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom1_0033.hdf5\n", + "1 pilot_linking_nl6_aNone_bCone_occ1_dis1_boxroom_0009.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_long_a_0003.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom1_0020.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0031.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom_small_rings_0032.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0027.hdf5\n", + "1 pilot_linking_nl2-3_mg01_aCone_bCyl_boxroom_0027.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_long_a_0027.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_0019.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aNone_bCyl_tdwroom_small_rings_0002.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom_small_rings_long_a_0020.hdf5\n", + "1 pilot_linking_nl2-3_mg01_aCone_bCyl_boxroom_0013.hdf5\n", + "1 pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0014.hdf5\n", + "15 pilot_dominoes_2mid_J025R30_tdwroom_0025.hdf5\n", + "15 pilot_dominoes_2mid_J020R15_d3chairs_o1plants_tdwroom_2_0005.hdf5\n", + "15 pilot_dominoes_4midRM1_boxroom_0026.hdf5\n", + "15 pilot_dominoes_4midRM1_tdwroom_2_0021.hdf5\n", + "15 pilot_dominoes_4midRM1_tdwroom_2_0018.hdf5\n", + "15 pilot_dominoes_4midRM1_tdwroom_2_0024.hdf5\n", + "15 pilot_dominoes_4midRM1_boxroom_0000.hdf5\n", + "15 pilot_dominoes_default_boxroom_0020.hdf5\n", + "15 pilot_dominoes_4mid_boxroom_0013.hdf5\n", + "15 pilot_dominoes_2mid_J020R15_d3chairs_o1plants_tdwroom_2_0002.hdf5\n", + "15 pilot_dominoes_SJ020_d3chairs_o1plants_tdwroom_0022.hdf5\n", + "15 pilot_dominoes_SJ020_d3chairs_o1plants_tdwroom_0004.hdf5\n", + "15 pilot_dominoes_4midRM1_boxroom_2_0016.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_boxroom_0024.hdf5\n", + "15 pilot_dominoes_4mid_tdwroom_0004.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_boxroom_0022.hdf5\n", + "15 pilot_dominoes_4mid_boxroom_2_0008.hdf5\n", + "15 pilot_dominoes_4mid_boxroom_2_0020.hdf5\n", + "15 pilot_dominoes_4midRM1_boxroom_0019.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_boxroom_0011.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_boxroom_0021.hdf5\n", + "15 pilot_dominoes_SJ020_d3chairs_o1plants_tdwroom_0003.hdf5\n", + "15 pilot_dominoes_SJ020_d3chairs_o1plants_tdwroom_0023.hdf5\n", + "15 pilot_dominoes_4midRM1_boxroom_2_0026.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_boxroom_0000.hdf5\n", + "15 pilot_dominoes_4midRM1_boxroom_0018.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_o1full_tdwroom_0023.hdf5\n", + "15 pilot_dominoes_4midRM1_boxroom_2_0014.hdf5\n", + "15 pilot_dominoes_4mid_boxroom_0021.hdf5\n", + "15 pilot_dominoes_4midRM1_boxroom_2_0024.hdf5\n", + "15 pilot_dominoes_4midRM1_boxroom_2_0017.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_o1full_tdwroom_0026.hdf5\n", + "15 pilot_dominoes_4mid_boxroom_0015.hdf5\n", + "15 pilot_dominoes_4midRM1_boxroom_0008.hdf5\n", + "15 pilot_dominoes_4midRM1_tdwroom_2_0015.hdf5\n", + "15 pilot_dominoes_SJ020_d3chairs_o1plants_tdwroom_0025.hdf5\n", + "15 pilot_dominoes_4midRM1_tdwroom_2_0001.hdf5\n", + "15 pilot_dominoes_4mid_tdwroom_0018.hdf5\n", + "15 pilot_dominoes_2mid_J025R30_tdwroom_0021.hdf5\n", + "15 pilot_dominoes_0mid_d3chairs_o1plants_tdwroom_0022.hdf5\n", + "15 pilot_dominoes_2mid_J020R15_d3chairs_o1plants_tdwroom_0000.hdf5\n", + "15 pilot_dominoes_0mid_d3chairs_o1plants_tdwroom_0023.hdf5\n", + "15 pilot_dominoes_2mid_J025R30_tdwroom_0000.hdf5\n", + "15 pilot_dominoes_0mid_d3chairs_o1plants_tdwroom_0001.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_boxroom_0009.hdf5\n", + "15 pilot_dominoes_2mid_J020R15_d3chairs_o1plants_tdwroom_0020.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_boxroom_0010.hdf5\n", + "15 pilot_dominoes_4mid_boxroom_0023.hdf5\n", + "15 pilot_dominoes_0mid_d3chairs_o1plants_tdwroom_0011.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_o1full_tdwroom_0017.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_o1full_tdwroom_0004.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_boxroom_0003.hdf5\n", + "15 pilot_dominoes_2mid_J020R15_d3chairs_o1plants_tdwroom_0021.hdf5\n", + "15 pilot_dominoes_4midRM1_boxroom_2_0000.hdf5\n", + "15 pilot_dominoes_0mid_d3chairs_o1plants_tdwroom_0021.hdf5\n", + "15 pilot_dominoes_default_boxroom_0026.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_boxroom_0006.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_o1full_tdwroom_0009.hdf5\n", + "15 pilot_dominoes_default_boxroom_0003.hdf5\n", + "15 pilot_dominoes_0mid_d3chairs_o1plants_tdwroom_0017.hdf5\n", + "15 pilot_dominoes_SJ020_d3chairs_o1plants_tdwroom_0020.hdf5\n", + "15 pilot_dominoes_4mid_boxroom_0018.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_o1full_tdwroom_0022.hdf5\n", + "15 pilot_dominoes_2mid_J025R30_tdwroom_0003.hdf5\n", + "15 pilot_dominoes_SJ020_d3chairs_o1plants_tdwroom_0019.hdf5\n", + "15 pilot_dominoes_4mid_tdwroom_0003.hdf5\n", + "15 pilot_dominoes_4midRM1_tdwroom_2_0022.hdf5\n", + "15 pilot_dominoes_2mid_J020R15_d3chairs_o1plants_tdwroom_2_0016.hdf5\n", + "15 pilot_dominoes_2mid_J025R30_tdwroom_0020.hdf5\n", + "15 pilot_dominoes_0mid_d3chairs_o1plants_tdwroom_0006.hdf5\n", + "15 pilot_dominoes_4mid_boxroom_2_0022.hdf5\n", + "15 pilot_dominoes_default_boxroom_0014.hdf5\n", + "15 pilot_dominoes_2mid_J025R30_tdwroom_0005.hdf5\n", + "15 pilot_dominoes_4mid_boxroom_2_0002.hdf5\n", + "15 pilot_dominoes_SJ020_d3chairs_o1plants_tdwroom_0001.hdf5\n", + "15 pilot_dominoes_4midRM1_tdwroom_2_0017.hdf5\n", + "15 pilot_dominoes_2mid_J020R15_d3chairs_o1plants_tdwroom_0014.hdf5\n", + "15 pilot_dominoes_SJ020_d3chairs_o1plants_tdwroom_0006.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_o1full_tdwroom_0021.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_boxroom_0002.hdf5\n", + "15 pilot_dominoes_0mid_d3chairs_o1plants_tdwroom_0004.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_o1full_tdwroom_0016.hdf5\n", + "15 pilot_dominoes_0mid_d3chairs_o1plants_tdwroom_0015.hdf5\n", + "15 pilot_dominoes_4midRM1_boxroom_2_0019.hdf5\n", + "15 pilot_dominoes_4midRM1_tdwroom_0005.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_boxroom_0019.hdf5\n", + "15 pilot_dominoes_4midRM1_boxroom_2_0010.hdf5\n", + "15 pilot_dominoes_0mid_d3chairs_o1plants_tdwroom_0009.hdf5\n", + "15 pilot_dominoes_SJ020_d3chairs_o1plants_tdwroom_0013.hdf5\n", + "15 pilot_dominoes_default_boxroom_0016.hdf5\n", + "15 pilot_dominoes_4mid_boxroom_2_0014.hdf5\n", + "15 pilot_dominoes_4mid_boxroom_0011.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_o1full_tdwroom_0010.hdf5\n", + "15 pilot_dominoes_2mid_J020R15_d3chairs_o1plants_tdwroom_0010.hdf5\n", + "15 pilot_dominoes_0mid_d3chairs_o1plants_tdwroom_0008.hdf5\n", + "15 pilot_dominoes_4midRM1_tdwroom_2_0025.hdf5\n", + "15 pilot_dominoes_default_boxroom_0006.hdf5\n", + "15 pilot_dominoes_0mid_d3chairs_o1plants_tdwroom_0012.hdf5\n", + "15 pilot_dominoes_2mid_J020R15_d3chairs_o1plants_tdwroom_2_0012.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_o1full_tdwroom_0024.hdf5\n", + "15 pilot_dominoes_4midRM1_boxroom_2_0013.hdf5\n", + "15 pilot_dominoes_SJ020_d3chairs_o1plants_tdwroom_0024.hdf5\n", + "15 pilot_dominoes_2mid_J020R15_d3chairs_o1plants_tdwroom_2_0026.hdf5\n", + "15 pilot_dominoes_4midRM1_tdwroom_0009.hdf5\n", + "15 pilot_dominoes_2mid_J025R30_tdwroom_0015.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_o1full_tdwroom_0007.hdf5\n", + "15 pilot_dominoes_2mid_J020R15_d3chairs_o1plants_tdwroom_2_0013.hdf5\n", + "15 pilot_dominoes_SJ020_d3chairs_o1plants_tdwroom_0008.hdf5\n", + "15 pilot_dominoes_default_boxroom_0015.hdf5\n", + "15 pilot_dominoes_2mid_J025R30_tdwroom_0008.hdf5\n", + "15 pilot_dominoes_0mid_d3chairs_o1plants_tdwroom_0003.hdf5\n", + "15 pilot_dominoes_SJ020_d3chairs_o1plants_tdwroom_0005.hdf5\n", + "15 pilot_dominoes_4mid_boxroom_2_0018.hdf5\n", + "15 pilot_dominoes_4midRM1_boxroom_2_0006.hdf5\n", + "15 pilot_dominoes_4midRM1_tdwroom_2_0019.hdf5\n", + "15 pilot_dominoes_2mid_J020R15_d3chairs_o1plants_tdwroom_2_0019.hdf5\n", + "15 pilot_dominoes_4mid_tdwroom_0007.hdf5\n", + "15 pilot_dominoes_2mid_J020R15_d3chairs_o1plants_tdwroom_0007.hdf5\n", + "15 pilot_dominoes_4mid_tdwroom_0008.hdf5\n", + "15 pilot_dominoes_2mid_J025R30_tdwroom_0001.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_boxroom_0012.hdf5\n", + "15 pilot_dominoes_default_boxroom_0025.hdf5\n", + "15 pilot_dominoes_4midRM1_boxroom_0022.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_boxroom_0001.hdf5\n", + "15 pilot_dominoes_default_boxroom_0017.hdf5\n", + "15 pilot_dominoes_2mid_J020R15_d3chairs_o1plants_tdwroom_0004.hdf5\n", + "15 pilot_dominoes_default_boxroom_0001.hdf5\n", + "15 pilot_dominoes_2mid_J025R30_tdwroom_0016.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_o1full_tdwroom_0018.hdf5\n", + "15 pilot_dominoes_2mid_J020R15_d3chairs_o1plants_tdwroom_2_0004.hdf5\n", + "15 pilot_dominoes_2mid_J025R30_tdwroom_0024.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_o1full_tdwroom_0020.hdf5\n", + "15 pilot_dominoes_SJ020_d3chairs_o1plants_tdwroom_0000.hdf5\n", + "15 pilot_dominoes_2mid_J020R15_d3chairs_o1plants_tdwroom_2_0000.hdf5\n", + "15 pilot_dominoes_default_boxroom_0023.hdf5\n", + "15 pilot_dominoes_default_boxroom_0004.hdf5\n", + "15 pilot_dominoes_SJ020_d3chairs_o1plants_tdwroom_0016.hdf5\n", + "15 pilot_dominoes_2mid_J025R30_tdwroom_0026.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_o1full_tdwroom_0000.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_boxroom_0007.hdf5\n", + "15 pilot_dominoes_0mid_d3chairs_o1plants_tdwroom_0019.hdf5\n", + "15 pilot_dominoes_2mid_J020R15_d3chairs_o1plants_tdwroom_2_0010.hdf5\n", + "15 pilot_dominoes_4midRM1_tdwroom_0011.hdf5\n", + "15 pilot_dominoes_0mid_d3chairs_o1plants_tdwroom_0013.hdf5\n", + "15 pilot_dominoes_0mid_d3chairs_o1plants_tdwroom_0018.hdf5\n", + "15 pilot_dominoes_4mid_tdwroom_0014.hdf5\n", + "15 pilot_dominoes_SJ020_d3chairs_o1plants_tdwroom_0009.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_boxroom_0014.hdf5\n", + "15 pilot_dominoes_4midRM1_tdwroom_0022.hdf5\n", + "15 pilot_dominoes_SJ020_d3chairs_o1plants_tdwroom_0017.hdf5\n", + "15 pilot_dominoes_4mid_tdwroom_0021.hdf5\n", + "15 pilot_dominoes_0mid_d3chairs_o1plants_tdwroom_0025.hdf5\n", + "15 pilot_dominoes_2mid_J025R30_tdwroom_0018.hdf5\n", + "15 pilot_dominoes_4midRM1_tdwroom_2_0026.hdf5\n", + "15 pilot_dominoes_0mid_d3chairs_o1plants_tdwroom_0026.hdf5\n", + "15 pilot_dominoes_1mid_J025R45_o1full_tdwroom_0015.hdf5\n", + "15 pilot_dominoes_4mid_tdwroom_0015.hdf5\n", + "15 pilot_dominoes_0mid_d3chairs_o1plants_tdwroom_0010.hdf5\n", + "15 pilot_dominoes_4midRM1_boxroom_0001.hdf5\n", + "15 pilot_dominoes_4mid_tdwroom_0019.hdf5\n", + "0 pilot_it2_drop_sidezone_box_0015.hdf5\n", + "0 pilot_it2_drop_sizes_tdw_1_dis_1_occ_0004.hdf5\n", + "0 pilot_it2_drop_simple_tdw_1_dis_1_occ_0030.hdf5\n", + "0 pilot_it2_drop_all_bowls_box_0011.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0017.hdf5\n", + "0 pilot_it2_drop_sizes_tdw_1_dis_1_occ_0010.hdf5\n", + "0 pilot_it2_drop_sizes_box_0011.hdf5\n", + "0 pilot_it2_drop_simple_box_0042.hdf5\n", + "0 pilot_it2_drop_all_bowls_box_0002.hdf5\n", + "0 pilot_it2_drop_all_bowls_box_0042.hdf5\n", + "0 pilot_it2_drop_simple_box_0047.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0012.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0029.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0015.hdf5\n", + "0 pilot_it2_drop_sizes_tdw_1_dis_1_occ_0018.hdf5\n", + "0 pilot_it2_drop_all_bowls_box_0012.hdf5\n", + "0 pilot_it2_drop_simple_box_0019.hdf5\n", + "0 pilot_it2_drop_all_bowls_box_0007.hdf5\n", + "0 pilot_it2_drop_all_bowls_box_0046.hdf5\n", + "0 pilot_it2_drop_simple_tdw_1_dis_1_occ_0018.hdf5\n", + "0 pilot_it2_drop_all_bowls_box_0017.hdf5\n", + "0 pilot_it2_drop_simple_box_0029.hdf5\n", + "0 pilot_it2_drop_sidezone_box_0042.hdf5\n", + "0 pilot_it2_drop_simple_box_0018.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0010.hdf5\n", + "0 pilot_it2_drop_simple_tdw_1_dis_1_occ_0001.hdf5\n", + "0 pilot_it2_drop_sizes_box_0041.hdf5\n", + "0 pilot_it2_drop_sizes_box_0017.hdf5\n", + "0 pilot_it2_drop_sizes_box_0029.hdf5\n", + "0 pilot_it2_drop_sizes_box_0024.hdf5\n", + "0 pilot_it2_drop_all_bowls_tdw_1_dis_1_occ_0003.hdf5\n", + "0 pilot_it2_drop_simple_tdw_1_dis_1_occ_0005.hdf5\n", + "0 pilot_it2_drop_all_bowls_tdw_1_dis_1_occ_0018.hdf5\n", + "0 pilot_it2_drop_simple_tdw_1_dis_1_occ_0041.hdf5\n", + "0 pilot_it2_drop_all_bowls_tdw_1_dis_1_occ_0029.hdf5\n", + "0 pilot_it2_drop_sizes_box_0045.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0005.hdf5\n", + "0 pilot_it2_drop_all_bowls_box_0035.hdf5\n", + "0 pilot_it2_drop_sidezone_box_0003.hdf5\n", + "0 pilot_it2_drop_sizes_tdw_1_dis_1_occ_0033.hdf5\n", + "0 pilot_it2_drop_simple_box_0040.hdf5\n", + "0 pilot_it2_drop_all_bowls_box_0029.hdf5\n", + "0 pilot_it2_drop_simple_box_0035.hdf5\n", + "0 pilot_it2_drop_simple_box_0028.hdf5\n", + "0 pilot_it2_drop_all_bowls_box_0025.hdf5\n", + "0 pilot_it2_drop_sizes_box_0003.hdf5\n", + "0 pilot_it2_drop_simple_tdw_1_dis_1_occ_0032.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0036.hdf5\n", + "0 pilot_it2_drop_sizes_box_0030.hdf5\n", + "0 pilot_it2_drop_all_bowls_box_0028.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0030.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0008.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0006.hdf5\n", + "0 pilot_it2_drop_all_bowls_tdw_1_dis_1_occ_0040.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0026.hdf5\n", + "0 pilot_it2_drop_sizes_tdw_1_dis_1_occ_0038.hdf5\n", + "0 pilot_it2_drop_simple_box_0003.hdf5\n", + "0 pilot_it2_drop_all_bowls_box_0010.hdf5\n", + "0 pilot_it2_drop_sizes_tdw_1_dis_1_occ_0032.hdf5\n", + "0 pilot_it2_drop_all_bowls_tdw_1_dis_1_occ_0004.hdf5\n", + "0 pilot_it2_drop_sizes_box_0026.hdf5\n", + "0 pilot_it2_drop_sizes_tdw_1_dis_1_occ_0022.hdf5\n", + "0 pilot_it2_drop_simple_tdw_1_dis_1_occ_0038.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0007.hdf5\n", + "0 pilot_it2_drop_sidezone_box_0020.hdf5\n", + "0 pilot_it2_drop_all_bowls_tdw_1_dis_1_occ_0013.hdf5\n", + "0 pilot_it2_drop_simple_box_0032.hdf5\n", + "0 pilot_it2_drop_sizes_tdw_1_dis_1_occ_0041.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0039.hdf5\n", + "0 pilot_it2_drop_all_bowls_tdw_1_dis_1_occ_0002.hdf5\n", + "0 pilot_it2_drop_simple_tdw_1_dis_1_occ_0036.hdf5\n", + "0 pilot_it2_drop_all_bowls_tdw_1_dis_1_occ_0047.hdf5\n", + "0 pilot_it2_drop_simple_tdw_1_dis_1_occ_0044.hdf5\n", + "0 pilot_it2_drop_simple_box_0015.hdf5\n", + "0 pilot_it2_drop_sidezone_box_0022.hdf5\n", + "0 pilot_it2_drop_simple_tdw_1_dis_1_occ_0028.hdf5\n", + "0 pilot_it2_drop_sizes_tdw_1_dis_1_occ_0023.hdf5\n", + "0 pilot_it2_drop_all_bowls_tdw_1_dis_1_occ_0027.hdf5\n", + "0 pilot_it2_drop_all_bowls_box_0026.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0044.hdf5\n", + "0 pilot_it2_drop_simple_tdw_1_dis_1_occ_0009.hdf5\n", + "0 pilot_it2_drop_simple_tdw_1_dis_1_occ_0025.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0000.hdf5\n", + "0 pilot_it2_drop_sidezone_box_0037.hdf5\n", + "0 pilot_it2_drop_all_bowls_tdw_1_dis_1_occ_0007.hdf5\n", + "0 pilot_it2_drop_simple_tdw_1_dis_1_occ_0029.hdf5\n", + "0 pilot_it2_drop_all_bowls_box_0037.hdf5\n", + "0 pilot_it2_drop_simple_box_0027.hdf5\n", + "0 pilot_it2_drop_sizes_box_0014.hdf5\n", + "0 pilot_it2_drop_sidezone_box_0048.hdf5\n", + "0 pilot_it2_drop_all_bowls_box_0023.hdf5\n", + "0 pilot_it2_drop_simple_box_0008.hdf5\n", + "0 pilot_it2_drop_sidezone_box_0047.hdf5\n", + "0 pilot_it2_drop_simple_tdw_1_dis_1_occ_0049.hdf5\n", + "0 pilot_it2_drop_simple_box_0000.hdf5\n", + "0 pilot_it2_drop_sizes_box_0010.hdf5\n", + "0 pilot_it2_drop_sizes_box_0009.hdf5\n", + "0 pilot_it2_drop_simple_tdw_1_dis_1_occ_0013.hdf5\n", + "0 pilot_it2_drop_all_bowls_tdw_1_dis_1_occ_0025.hdf5\n", + "0 pilot_it2_drop_simple_box_0020.hdf5\n", + "0 pilot_it2_drop_simple_box_0016.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0048.hdf5\n", + "0 pilot_it2_drop_sizes_tdw_1_dis_1_occ_0007.hdf5\n", + "0 pilot_it2_drop_all_bowls_box_0032.hdf5\n", + "0 pilot_it2_drop_sizes_box_0008.hdf5\n", + "0 pilot_it2_drop_all_bowls_tdw_1_dis_1_occ_0016.hdf5\n", + "0 pilot_it2_drop_all_bowls_tdw_1_dis_1_occ_0026.hdf5\n", + "0 pilot_it2_drop_sidezone_box_0034.hdf5\n", + "0 pilot_it2_drop_simple_box_0005.hdf5\n", + "0 pilot_it2_drop_sidezone_box_0018.hdf5\n", + "0 pilot_it2_drop_sizes_tdw_1_dis_1_occ_0015.hdf5\n", + "0 pilot_it2_drop_all_bowls_box_0034.hdf5\n", + "0 pilot_it2_drop_sizes_box_0021.hdf5\n", + "0 pilot_it2_drop_all_bowls_tdw_1_dis_1_occ_0008.hdf5\n", + "0 pilot_it2_drop_simple_tdw_1_dis_1_occ_0022.hdf5\n", + "0 pilot_it2_drop_sidezone_box_0032.hdf5\n", + "0 pilot_it2_drop_simple_box_0010.hdf5\n", + "0 pilot_it2_drop_sidezone_box_0021.hdf5\n", + "0 pilot_it2_drop_sizes_tdw_1_dis_1_occ_0016.hdf5\n", + "0 pilot_it2_drop_sidezone_box_0024.hdf5\n", + "0 pilot_it2_drop_sidezone_box_0046.hdf5\n", + "0 pilot_it2_drop_sizes_box_0049.hdf5\n", + "0 pilot_it2_drop_sidezone_box_0044.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0014.hdf5\n", + "0 pilot_it2_drop_sizes_tdw_1_dis_1_occ_0021.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0045.hdf5\n", + "0 pilot_it2_drop_sidezone_box_0035.hdf5\n", + "0 pilot_it2_drop_sidezone_box_0004.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0021.hdf5\n", + "0 pilot_it2_drop_simple_box_0026.hdf5\n", + "0 pilot_it2_drop_simple_tdw_1_dis_1_occ_0048.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0042.hdf5\n", + "0 pilot_it2_drop_simple_tdw_1_dis_1_occ_0003.hdf5\n", + "0 pilot_it2_drop_all_bowls_tdw_1_dis_1_occ_0046.hdf5\n", + "0 pilot_it2_drop_all_bowls_box_0016.hdf5\n", + "0 pilot_it2_drop_sidezone_box_0019.hdf5\n", + "0 pilot_it2_drop_simple_tdw_1_dis_1_occ_0004.hdf5\n", + "0 pilot_it2_drop_all_bowls_tdw_1_dis_1_occ_0049.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0032.hdf5\n", + "0 pilot_it2_drop_sizes_box_0036.hdf5\n", + "0 pilot_it2_drop_all_bowls_box_0018.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0002.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0009.hdf5\n", + "0 pilot_it2_drop_simple_tdw_1_dis_1_occ_0006.hdf5\n", + "0 pilot_it2_drop_simple_tdw_1_dis_1_occ_0000.hdf5\n", + "0 pilot_it2_drop_simple_box_0034.hdf5\n", + "0 pilot_it2_drop_simple_box_0007.hdf5\n", + "0 pilot_it2_drop_all_bowls_box_0019.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0047.hdf5\n", + "0 pilot_it2_drop_all_bowls_box_0020.hdf5\n", + "0 pilot_it2_drop_simple_box_0033.hdf5\n", + "0 pilot_it2_drop_sidezone_box_0011.hdf5\n", + "0 pilot_it2_drop_sizes_box_0019.hdf5\n", + "0 pilot_it2_drop_sidezone_tdw_1_dis_1_occ_0025.hdf5\n", + "0 pilot_it2_drop_simple_tdw_1_dis_1_occ_0040.hdf5\n", + "0 pilot_it2_drop_simple_tdw_1_dis_1_occ_0037.hdf5\n", + "0 pilot_it2_drop_sidezone_box_0043.hdf5\n", + "0 pilot_it2_drop_all_bowls_box_0024.hdf5\n", + "0 pilot_it2_drop_sizes_box_0042.hdf5\n", + "0 pilot_it2_drop_simple_box_0017.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_0010.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_0009.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_small_zone_0014.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_sphere_small_zone_0018.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_small_zone_0010.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_0013.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_0012.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_0030.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_small_zone_0015.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_0000.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_small_zone_0012.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_box_0025.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_0019.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_small_zone_0011.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_0016.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_box_0008.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_sphere_small_zone_0010.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_0024.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_0026.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_0023.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_0029.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_small_zone_0029.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_0002.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_box_0022.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_0020.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_box_large_force_0021.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_0022.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_0014.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_sphere_small_zone_0025.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_tdw_1_dis_1_occ_0006.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_0023.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_0026.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_0018.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_tdw_1_dis_1_occ_0002.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_small_zone_0020.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_0016.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_small_zone_0030.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_small_zone_0017.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_sphere_small_zone_0021.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_0006.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_tdw_1_dis_1_occ_0020.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_box_large_force_0028.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_0030.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_box_0010.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_small_zone_0011.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_0027.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_0002.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_0011.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_0008.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_small_zone_0004.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_0017.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_0005.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_0000.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_0001.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_sphere_small_zone_0017.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_sphere_small_zone_0027.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_small_zone_0019.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_tdw_1_dis_1_occ_0001.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_sphere_small_zone_0022.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_small_zone_0016.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_sphere_small_zone_0002.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_sphere_small_zone_0023.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_tdw_1_dis_1_occ_0030.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_tdw_1_dis_1_occ_0005.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_0021.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_0020.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_0013.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_small_zone_0008.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_small_zone_0022.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_0024.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_0029.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_sphere_small_zone_0016.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_0013.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_0011.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_sphere_small_zone_0019.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_sphere_small_zone_0028.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_small_zone_0030.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_small_zone_0017.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_small_zone_0007.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_small_zone_0027.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_small_zone_0000.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_0028.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_0022.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_small_zone_0008.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_small_zone_0029.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_sphere_small_zone_0012.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_0015.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_sphere_small_zone_0004.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_box_large_force_0009.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_sphere_small_zone_0019.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_box_large_force_0005.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_0007.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_tdw_1_dis_1_occ_0016.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_0011.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_0010.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_0025.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_0003.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_small_zone_0003.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_0029.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_small_zone_0014.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_0018.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_0014.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_0010.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_sphere_small_zone_0015.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_sphere_small_zone_0029.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_tdw_1_dis_1_occ_0000.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_0028.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_0021.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_0027.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_0002.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_small_zone_0022.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_small_zone_0005.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_small_zone_0026.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_0017.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_sphere_small_zone_0027.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_0021.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_0028.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_0029.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_0028.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_0008.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_sphere_small_zone_0003.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_box_large_force_0001.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_tdw_1_dis_1_occ_0011.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_small_zone_0023.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_sphere_small_zone_0024.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_small_zone_0006.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_small_zone_0022.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_0017.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_0013.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_box_0003.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_small_zone_0017.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_0019.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_sphere_small_zone_0006.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_0015.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_0025.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_0014.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_small_zone_0000.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_tdw_1_dis_1_occ_0013.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_small_zone_0024.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_box_0012.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_box_large_force_0030.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_0021.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_small_zone_0026.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_small_zone_0025.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_small_zone_0013.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_sphere_small_zone_0018.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_tdw_1_dis_1_occ_0015.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_small_zone_0016.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_small_zone_0028.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_sphere_small_zone_0006.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_small_zone_0013.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_box_0016.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_0025.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_0007.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_small_zone_0028.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_small_zone_0003.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_tdw_1_dis_1_occ_0028.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_zone_away_0023.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_box_large_force_0016.hdf5\n", + "1 pilot_it2_rollingSliding_simple_collision_tdw_1_dis_1_occ_0019.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_0029.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ramp_box_small_zone_0014.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_0005.hdf5\n", + "1 pilot_it2_rollingSliding_simple_ledge_box_sphere_small_zone_0028.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_unstable_0018.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0017.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0017.hdf5\n", + "1 pilot_towers_nb4_SJ025_mono1_dis0_occ0_tdwroom_unstable_0037.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono0_dis1_occ1_tdwroom_unstable_0019.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_stable_0030.hdf5\n", + "1 pilot_towers_nb4_SJ025_mono1_dis0_occ0_tdwroom_unstable_0018.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono0_dis1_occ1_tdwroom_unstable_0014.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_stable_0018.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_stable_0010.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_stable_0034.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_unstable_0033.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono0_dis1_occ1_tdwroom_unstable_0038.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_stable_0031.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_unstable_0028.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_unstable_0022.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_stable_0026.hdf5\n", + "1 pilot_towers_nb4_SJ025_mono1_dis0_occ0_tdwroom_unstable_0006.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_unstable_0011.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0032.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0029.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_unstable_0037.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_unstable_0005.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0012.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono0_dis1_occ1_tdwroom_unstable_0042.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_unstable_0044.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0029.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_stable_0037.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0031.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_stable_0003.hdf5\n", + "1 pilot_towers_nb3_fr015_SJ025_mono1_dis0_occ0_tdwroom_unstable_0002.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0040.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_unstable_0023.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono0_dis1_occ1_tdwroom_unstable_0004.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_unstable_0031.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0027.hdf5\n", + "1 pilot_towers_nb3_fr015_SJ025_mono1_dis0_occ0_tdwroom_unstable_0022.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono0_dis1_occ1_tdwroom_unstable_0039.hdf5\n", + "1 pilot_towers_nb4_SJ025_mono1_dis0_occ0_tdwroom_unstable_0029.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_stable_0023.hdf5\n", + "1 pilot_towers_nb3_fr015_SJ025_mono1_dis0_occ0_tdwroom_unstable_0007.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_stable_0037.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_stable_0013.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0003.hdf5\n", + "1 pilot_towers_nb3_fr015_SJ025_mono1_dis0_occ0_tdwroom_unstable_0004.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0002.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0019.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0026.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0007.hdf5\n", + "1 pilot_towers_nb3_fr015_SJ025_mono1_dis0_occ0_tdwroom_unstable_0024.hdf5\n", + "1 pilot_towers_nb4_SJ025_mono1_dis0_occ0_tdwroom_unstable_0009.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_unstable_0026.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_stable_0029.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono0_dis1_occ1_tdwroom_unstable_0027.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0010.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono0_dis1_occ1_tdwroom_unstable_0032.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_stable_0032.hdf5\n", + "1 pilot_towers_nb3_fr015_SJ025_mono1_dis0_occ0_tdwroom_unstable_0012.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0032.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_unstable_0006.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_stable_0030.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0038.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0012.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0013.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0034.hdf5\n", + "1 pilot_towers_nb3_fr015_SJ025_mono1_dis0_occ0_tdwroom_unstable_0005.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_stable_0036.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono0_dis1_occ1_tdwroom_unstable_0021.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0014.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0016.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_unstable_0013.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0034.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0043.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_unstable_0029.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_stable_0017.hdf5\n", + "1 pilot_towers_nb4_SJ025_mono1_dis0_occ0_tdwroom_unstable_0027.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_unstable_0001.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_stable_0032.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_stable_0020.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0005.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0035.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_stable_0021.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono0_dis1_occ1_tdwroom_unstable_0043.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0016.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_unstable_0014.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0006.hdf5\n", + "1 pilot_towers_nb3_fr015_SJ025_mono1_dis0_occ0_tdwroom_unstable_0039.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_stable_0020.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono0_dis1_occ1_tdwroom_unstable_0037.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0008.hdf5\n", + "1 pilot_towers_nb4_SJ025_mono1_dis0_occ0_tdwroom_unstable_0041.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0008.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_stable_0015.hdf5\n", + "1 pilot_towers_nb4_SJ025_mono1_dis0_occ0_tdwroom_unstable_0033.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_stable_0043.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_stable_0008.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0024.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_unstable_0009.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0009.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0039.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_stable_0012.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono0_dis1_occ1_tdwroom_unstable_0020.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_stable_0002.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono0_dis1_occ1_tdwroom_unstable_0024.hdf5\n", + "1 pilot_towers_nb3_fr015_SJ025_mono1_dis0_occ0_tdwroom_unstable_0033.hdf5\n", + "1 pilot_towers_nb3_fr015_SJ025_mono1_dis0_occ0_tdwroom_unstable_0044.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_unstable_0040.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_unstable_0038.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0000.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_stable_0022.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0023.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_stable_0006.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_unstable_0009.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_stable_0028.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono0_dis1_occ1_tdwroom_unstable_0036.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_stable_0011.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0036.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono0_dis1_occ1_tdwroom_unstable_0041.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_stable_0033.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0011.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_stable_0025.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_stable_0021.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_unstable_0030.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0033.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono0_dis1_occ1_tdwroom_unstable_0029.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_stable_0042.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_unstable_0029.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono0_dis1_occ1_tdwroom_unstable_0034.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0042.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_stable_0035.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0037.hdf5\n", + "1 pilot_towers_nb4_SJ025_mono1_dis0_occ0_tdwroom_unstable_0015.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0010.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_unstable_0019.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0018.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_stable_0035.hdf5\n", + "1 pilot_towers_nb4_SJ025_mono1_dis0_occ0_tdwroom_unstable_0011.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0011.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_stable_0033.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0005.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_stable_0038.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_stable_0026.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0000.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_unstable_0027.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_stable_0004.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono0_dis1_occ1_tdwroom_unstable_0028.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0002.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_stable_0023.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0003.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_stable_0028.hdf5\n", + "1 pilot_towers_nb3_fr015_SJ025_mono1_dis0_occ0_tdwroom_unstable_0021.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0020.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_stable_0013.hdf5\n", + "1 pilot_towers_nb4_SJ025_mono1_dis0_occ0_tdwroom_unstable_0023.hdf5\n", + "1 pilot_towers_nb3_fr015_SJ025_mono1_dis0_occ0_tdwroom_unstable_0029.hdf5\n", + "1 pilot_towers_nb2_fr015_SJ010_mono0_dis0_occ0_tdwroom_unstable_0016.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0014.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0007.hdf5\n", + "1 pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_stable_0027.hdf5\n", + "1 pilot_towers_nb4_fr015_SJ000_gr01_mono1_dis0_occ0_boxroom_stable_0015.hdf5\n" + ] + } + ], + "source": [ + "path = '/home/haoliangwang/data/physion_hdf5/'\n", + "for root, dirs, files in os.walk(path):\n", + " for file in files:\n", + " if file.endswith('.hdf5'):\n", + " with h5py.File(os.path.join(root, file), \"r\") as f:\n", + " fwait = np.array(f[\"static\"][\"push_time\"])\n", + " # push_force = np.array(f[\"static\"][\"push_force\"])\n", + " print(fwait, file)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "gpu", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/pyproject.toml b/pyproject.toml index a9fb2dc6..044a69f2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -16,6 +16,9 @@ authors = [{ name = "Nishad Gothoskar", email = "nishadg@mit.edu" }] requires-python = ">= 3.10" dependencies = [] +[project.optional-dependencies] +core = ["python-fcl>=0.7.0.6,<0.8"] + [tool.pixi.project] channels = ["conda-forge"] platforms = ["linux-64", "osx-arm64"] @@ -44,6 +47,12 @@ b3d = { path = ".", editable = true } [tool.pixi.dependencies] rerun-sdk = "==0.17.0" +ipympl = ">=0.9.4,<0.10" +msgpack-numpy = ">=0.4.8,<0.5" +h5py = ">=3.11.0,<4" +fcl = ">=0.7.0,<0.8" +pycocotools = ">=2.0.8,<3" +ipykernel = ">=6.29.5,<7" [tool.pixi.activation.env] XLA_PYTHON_CLIENT_PREALLOCATE = "false" @@ -109,9 +118,8 @@ cwd = "scripts" [tool.pixi.feature.core.pypi-dependencies] carvekit = "==4.1.2" datasync = "==0.0.2" -genjax = "==0.5.1" +genjax = "==0.6.1" pykitti = "==0.3.1" -pyliblzfse = { git = "https://github.com/ydkhatri/pyliblzfse.git" } pyransac3d = ">=0.6.0,<0.7" torch = "*" @@ -121,7 +129,6 @@ ffmpeg = "*" fire = ">=0.6.0,<0.7" imageio = "*" ipykernel = "*" -ipython = ">=8.26.0,<8.27" jax = "*" jupyter = ">=1.0.0,<1.1" jupyterlab = "*" @@ -145,6 +152,7 @@ scipy = ">=1.14.0,<1.15" torchvision = "==0.18.0" trimesh = "==4.2.4" tqdm = "*" +h5py = ">=3.11.0,<3.12" # Core tasks (CPU-enabled) @@ -163,14 +171,7 @@ cwd = "src/b3d/bucket_utils" [tool.pixi.feature.no-cuda] platforms = ["linux-64", "osx-arm64"] -[tool.pixi.feature.no-cuda.target.osx-arm64.dependencies] -jaxlib = { version = "*", build = "cpu*" } -pytorch = { version = "==2.3.0", build = "cpu_generic*" } -[tool.pixi.feature.no-cuda.target.linux-64.dependencies] -gcc = "*" -jaxlib = { version = "*", build = "cpu*" } -pytorch = { version = "==2.3.0", build = "cpu_generic*" } [tool.pixi.feature.no-cuda.tasks.docs] description = "render docs to docs/static" @@ -195,6 +196,7 @@ libnvjitlink = "*" optax = ">=0.2.2,<0.3" pytorch = { version = "==2.3.0", build = "cuda12*" } torchvision = "==0.18.0" +open3d = { version = "==0.18.0", build = "py312he431d9b_6" } # CUDA tasks (GPU-enabled) diff --git a/run.py b/run.py new file mode 100644 index 00000000..2fdb8371 --- /dev/null +++ b/run.py @@ -0,0 +1,83 @@ +import os +import uuid +from os import listdir +from os.path import isfile, join + +buggy_stims = [ + "pilot-containment-cone-plate_0017", + "pilot-containment-cone-plate_0022", + "pilot-containment-cone-plate_0029", + "pilot-containment-cone-plate_0034", + "pilot-containment-multi-bowl_0042", + "pilot-containment-multi-bowl_0048", + "pilot-containment-vase_torus_0031", + "pilot_dominoes_SJ020_d3chairs_o1plants_tdwroom_0005", + "pilot_it2_collision_non-sphere_box_0002", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0004", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0007", + "pilot_it2_drop_simple_box_0000", + "pilot_it2_drop_simple_box_0042", + "pilot_it2_drop_simple_tdw_1_dis_1_occ_0003", + "pilot_it2_rollingSliding_simple_collision_box_0008", + "pilot_it2_rollingSliding_simple_collision_box_large_force_0009", + "pilot_it2_rollingSliding_simple_collision_tdw_1_dis_1_occ_0002", + "pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_0021", + "pilot_it2_rollingSliding_simple_ledge_tdw_1_dis_1_occ_sphere_small_zone_0022", + "pilot_it2_rollingSliding_simple_ramp_box_small_zone_0006", + "pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_small_zone_0004", + "pilot_it2_rollingSliding_simple_ramp_tdw_1_dis_1_occ_small_zone_0017", + "pilot_linking_nl1-8_mg000_aCyl_bCyl_tdwroom1_long_a_0022", + "pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom1_0012", + "pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom_small_rings_0006", + "pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom_small_rings_0010", + "pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom_small_rings_0029", + "pilot_linking_nl1-8_mg000_aCylcap_bCyl_tdwroom_small_rings_0036", + "pilot_linking_nl6_aNone_bCone_occ1_dis1_boxroom_0028", + "pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0000", + "pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0002", + "pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0003", + "pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0010", + "pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0013", + "pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0017", + "pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0018", + "pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0032", + "pilot_towers_nb4_fr015_SJ000_gr000sph_mono1_dis0_occ0_tdwroom_stable_0036", + "pilot_towers_nb4_fr015_SJ000_gr01_mono0_dis1_occ1_tdwroom_unstable_0021", + "pilot_towers_nb4_fr015_SJ000_gr01_mono0_dis1_occ1_tdwroom_unstable_0041", + "pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_unstable_0006", + "pilot_towers_nb5_fr015_SJ030_mono0_dis0_occ0_boxroom_unstable_0009", +] + +data_path = "/home/haoliangwang/data/" +hdf5_file_path = os.path.join( + data_path, + "physion_hdf5", +) + +for scenario in ["dominoes", "support", "contain", "link"]: + scenario_path = join(hdf5_file_path, scenario + "_all_movies") + onlyhdf5 = [ + f + for f in listdir(scenario_path) + if isfile(join(scenario_path, f)) and join(scenario_path, f).endswith(".hdf5") + ] + + if scenario == "dominoes": + START_T = 14 + else: + START_T = 0 + + if scenario == "collide": + FINAL_T = 15 + else: + FINAL_T = 45 + + recording_id = uuid.uuid4() + viz_index = 0 + for trial_index, hdf5_file in enumerate(onlyhdf5): + trial_name = hdf5_file[:-5] + print(trial_index + 1, "\t", trial_name) + os.system( + f"python /home/haoliangwang/b3d/test_b3d_tracking_hmm_single.py --scenario {scenario} --trial_name {trial_name} --recording_id {recording_id} --viz_index {viz_index}" + ) + viz_index += FINAL_T - START_T + 1 diff --git a/run_gen3d_tests.sh b/run_gen3d_tests.sh new file mode 100644 index 00000000..837677d2 --- /dev/null +++ b/run_gen3d_tests.sh @@ -0,0 +1 @@ +pixi run -e gpu pytest tests/gen3d tests/test_modeling_utils.py diff --git a/src/b3d/chisight/dynamic_object_model/__init__.py b/scratch.py similarity index 100% rename from src/b3d/chisight/dynamic_object_model/__init__.py rename to scratch.py diff --git a/scripts/download_ycbv_train.sh b/scripts/download_ycbv_train.sh new file mode 100644 index 00000000..973c7f57 --- /dev/null +++ b/scripts/download_ycbv_train.sh @@ -0,0 +1,5 @@ +export SRC=https://huggingface.co/datasets/bop-benchmark/datasets/resolve/main +wget $SRC/ycbv/ycbv_train_real.zip -P assets/bop +wget $SRC/ycbv/ycbv_train_real.z01 -P assets/bop +zip -s0 assets/bop/ycbv_train_real.zip --out assets/bop/ycbv_train_real_all.zip +unzip assets/bop/ycbv_train_real_all.zip -d assets/bop/ycbv diff --git a/scripts/get_ycbv_metrics.py b/scripts/get_ycbv_metrics.py new file mode 100644 index 00000000..956cb157 --- /dev/null +++ b/scripts/get_ycbv_metrics.py @@ -0,0 +1,115 @@ +from functools import partial +from pathlib import Path + +import b3d +import fire +import numpy as np +import pandas as pd +from b3d.chisight.gen3d.metrics import ( + add_err, + adds_err, + compute_auc, + foundation_pose_ycbv_result, +) +from b3d.io.data_loader import YCB_MODEL_NAMES +from tqdm.auto import tqdm + +YCB_DIR = b3d.get_assets_path() / "bop/ycbv" + +ALL_METRICS = { + "ADD-S": adds_err, + "ADD": add_err, +} + +FRAME_RATE = 50 + + +def collect_all_scores(get_pose_fn: callable): + # e.g. all_score["ADD"]["002_master_chef_can"] gives the ADD error for the + # object "002_master_chef_can" + all_scores = {} + for metric_name in ALL_METRICS: + all_scores[metric_name] = {obj_name: [] for obj_name in YCB_MODEL_NAMES} + + # preload all gt meshes + meshes = [] + for obj_id in range(len(YCB_MODEL_NAMES)): + obj_id_str = str(obj_id + 1).rjust(6, "0") + meshes.append( + b3d.Mesh.from_obj_file(YCB_DIR / f"models/obj_{obj_id_str}.ply").scale( + 0.001 + ) + ) + + for test_scene_id in range(48, 60): + num_scenes = b3d.io.data_loader.get_ycbv_num_test_images(YCB_DIR, test_scene_id) + image_ids = range(1, num_scenes + 1, FRAME_RATE) + print(f"Processing test scene {test_scene_id}") + all_data = b3d.io.data_loader.get_ycbv_test_images( + YCB_DIR, test_scene_id, image_ids + ) + + object_types = all_data[0]["object_types"] + for idx, obj_id in tqdm(enumerate(object_types), desc="Processing objects"): + obj_name = YCB_MODEL_NAMES[obj_id] + obj_mesh = meshes[obj_id] + pred_poses = get_pose_fn(test_scene_id, idx) + # start computing the error for this object + for frame_data, pred_pose in zip(all_data, pred_poses): + # load ground truth pose + camera_pose = frame_data["camera_pose"] + obj_pose = frame_data["object_poses"][idx] + gt_pose = (camera_pose.inv() @ obj_pose).as_matrix() + # metrics + for metric_name, metric_fn in ALL_METRICS.items(): + all_scores[metric_name][obj_name].append( + metric_fn(pred_pose, gt_pose, obj_mesh.vertices) + ) + + # aggregate results per object + final_results = {} + for metric_name in ALL_METRICS: + final_results[metric_name] = {} + for obj_name in YCB_MODEL_NAMES: + final_results[metric_name][obj_name] = compute_auc( + all_scores[metric_name][obj_name] + ) + + return pd.DataFrame(final_results), all_scores + + +def get_fp_pred_pose(test_scene_id: int, obj_id: int): + return foundation_pose_ycbv_result.load(test_scene_id, obj_id) + + +def get_b3d_pred_pose(result_dir: Path, test_scene_id: int, obj_id: int): + poses = np.load( + result_dir / f"SCENE_{test_scene_id}_OBJECT_INDEX_{obj_id}_POSES.npy.npz", + ) + poses = b3d.Pose(poses["position"], poses["quaternion"]) + return poses.as_matrix() + + +def main(b3d_result_dir: str, output_dir: str | None = None, get_fp_pose: bool = False): + """ + Call this with `b3d_result_dir` as the directory containing `.npy.npz` files. + """ + result_dir = Path(b3d_result_dir) + if output_dir is None: + output_dir = b3d_result_dir + output_dir = Path(output_dir) + output_dir.mkdir(parents=True, exist_ok=True) + + pred_score_getter = partial(get_b3d_pred_pose, result_dir) + + if get_fp_pose: + pred_score_getter = get_fp_pred_pose + + results_summary, _ = collect_all_scores(pred_score_getter) + print(results_summary) + if output_dir is not None: + results_summary.to_csv(output_dir / "summary.csv") + + +if __name__ == "__main__": + fire.Fire(main) diff --git a/src/b3d/bayes3d/enumerative_proposals.py b/src/b3d/bayes3d/enumerative_proposals.py index 3680f9ac..dcf3d8d8 100644 --- a/src/b3d/bayes3d/enumerative_proposals.py +++ b/src/b3d/bayes3d/enumerative_proposals.py @@ -13,7 +13,7 @@ def enumerate_and_select_best(trace, address, values): return trace -def _enumerate_and_select_best_move(trace, addressses, key, all_deltas): +def _enumerate_and_select_best_move_pose(trace, addressses, key, all_deltas, k=50): addr = addressses.const[0] current_pose = trace.get_choices()[addr] for i in range(len(all_deltas)): @@ -22,12 +22,33 @@ def _enumerate_and_select_best_move(trace, addressses, key, all_deltas): trace, addressses, test_poses ) current_pose = test_poses[potential_scores.argmax()] + top_k_indices = jnp.argsort(potential_scores)[-k:][::-1] + top_scores = [potential_scores[idx] for idx in top_k_indices] + posterior_poses = [test_poses[idx] for idx in top_k_indices] trace = b3d.update_choices(trace, addressses, current_pose) - return trace, key + return trace, key, posterior_poses, top_scores + + +enumerate_and_select_best_move_pose = jax.jit( + _enumerate_and_select_best_move_pose, static_argnames=["addressses"] +) + + +def _enumerate_and_select_best_move_scale(trace, addressses, key, all_deltas, k=50): + addr = addressses.const[0] + current_scale = trace.get_choices()[addr] + test_scales = current_scale * all_deltas + potential_scores = b3d.enumerate_choices_get_scores(trace, addressses, test_scales) + best_scale = test_scales[potential_scores.argmax()] + top_k_indices = jnp.argsort(potential_scores)[-k:][::-1] + top_scores = [potential_scores[idx] for idx in top_k_indices] + posterior_scales = [test_scales[idx] for idx in top_k_indices] + trace = b3d.update_choices(trace, addressses, best_scale) + return trace, key, posterior_scales, top_scores -enumerate_and_select_best_move = jax.jit( - _enumerate_and_select_best_move, static_argnames=["addressses"] +enumerate_and_select_best_move_scale = jax.jit( + _enumerate_and_select_best_move_scale, static_argnames=["addressses"] ) diff --git a/src/b3d/bayes3d/mesh_library.py b/src/b3d/bayes3d/mesh_library.py index ebebb0ee..d6a1aed8 100644 --- a/src/b3d/bayes3d/mesh_library.py +++ b/src/b3d/bayes3d/mesh_library.py @@ -86,5 +86,5 @@ def add_trimesh(self, mesh, vertex_scale_factor=1.0): vertices = jnp.array(mesh.vertices) * vertex_scale_factor vertices = vertices - jnp.mean(vertices, axis=0) faces = jnp.array(mesh.faces) - vertex_colors = jnp.array(mesh.visual.to_color().vertex_colors)[..., :3] / 255.0 + vertex_colors = jnp.array(mesh.visual.vertex_colors)[..., :3] / 255.0 self.add_object(vertices, faces, vertex_colors) diff --git a/src/b3d/chisight/dense/dense_model.py b/src/b3d/chisight/dense/dense_model.py index 3c27fd51..ce978fff 100644 --- a/src/b3d/chisight/dense/dense_model.py +++ b/src/b3d/chisight/dense/dense_model.py @@ -7,17 +7,29 @@ import b3d import b3d.chisight.dense.likelihoods.image_likelihood from b3d import Mesh, Pose -from b3d.modeling_utils import uniform_pose +from b3d.modeling_utils import uniform_pose, uniform_scale -def make_dense_multiobject_model(renderer, likelihood_func, sample_func=None): +def get_hypers(trace): + return trace.get_args()[0] + + +def get_prev_state(trace): + return trace.get_args()[1] + + +def get_new_state(trace): + return trace.get_retval()["new_state"] + + +def make_dense_multiobject_dynamics_model(renderer, likelihood_func, sample_func=None): if sample_func is None: def f(key, likelihood_args): return jnp.zeros( ( - likelihood_args["image_height"].const, - likelihood_args["image_width"].const, + likelihood_args["image_height"].unwrap(), + likelihood_args["image_width"].unwrap(), 4, ) ) @@ -35,31 +47,61 @@ def logpdf(self, observed_rgbd, likelihood_args): image_likelihood = ImageLikelihood() @genjax.gen - def dense_multiobject_model(args_dict): - meshes = args_dict["meshes"] - likelihood_args = args_dict["likelihood_args"] - num_objects = args_dict["num_objects"] + def dense_multiobject_model( + hyperparams, + previous_state, + ): + background = hyperparams["background"][previous_state["t"]] + meshes = hyperparams["meshes"].values() + likelihood_args = hyperparams["likelihood_args"] + object_ids = hyperparams["object_ids"] + pose_kernel = hyperparams["pose_kernel"] blur = genjax.uniform(0.0001, 100000.0) @ "blur" likelihood_args["blur"] = blur - all_poses = [] - for i in range(num_objects.const): + all_poses = {} + # all_scales = {} + scaled_meshes = [] + for o_id, mesh_composite in zip(object_ids.unwrap(), meshes): object_pose = ( - uniform_pose(jnp.ones(3) * -100.0, jnp.ones(3) * 100.0) - @ f"object_pose_{i}" + pose_kernel(previous_state[f"object_pose_{o_id}"]) + @ f"object_pose_{o_id}" + ) + top = 0.0 + all_comp_poses = [] + all_comp_meshes = [] + for i, component in enumerate(mesh_composite): + object_scale = ( + uniform_scale(jnp.ones(3) * 0.01, jnp.ones(3) * 10.0) + @ f"object_scale_{o_id}_{i}" + ) + # all_scales[f"object_scale_{o_id}_{i}"] = object_scale + scaled_comp = component.scale(object_scale) + all_comp_meshes.append(scaled_comp) + pose = Pose.from_translation(jnp.array([0.0, top, 0.0])) + all_comp_poses.append(pose) + top += scaled_comp.vertices[:, 1].max() + merged_mesh = Mesh.transform_and_merge_meshes( + all_comp_meshes, all_comp_poses ) - all_poses.append(object_pose) - all_poses = Pose.stack_poses(all_poses) + scaled_meshes.append(merged_mesh) + all_poses[f"object_pose_{o_id}"] = object_pose camera_pose = ( uniform_pose(jnp.ones(3) * -100.0, jnp.ones(3) * 100.0) @ "camera_pose" ) - scene_mesh = Mesh.transform_and_merge_meshes(meshes, all_poses).transform( - camera_pose.inv() - ) - likelihood_args["scene_mesh"] = scene_mesh + scene_mesh = Mesh.transform_and_merge_meshes( + scaled_meshes, Pose.stack_poses(list(all_poses.values())) + ).transform(camera_pose.inv()) + + likelihood_args["scene_mesh"] = [ + Mesh.transform_mesh(mesh, pose) + for mesh, pose in zip( + scaled_meshes, Pose.stack_poses(list(all_poses.values())) + ) + ] depth_noise_variance = genjax.uniform(0.0001, 100000.0) @ "depth_noise_variance" likelihood_args["depth_noise_variance"] = depth_noise_variance @@ -81,14 +123,30 @@ def dense_multiobject_model(args_dict): rasterize_results, scene_mesh.faces, ) - likelihood_args["latent_rgbd"] = latent_rgbd + + # add distractor and occluders + latent_rgbd = jnp.flip(latent_rgbd, 1) + bg_rgb = background[..., :3] + bg_d = background[..., 3:] + latent_rgb = jnp.where( + bg_rgb == jnp.array([jnp.inf, jnp.inf, jnp.inf]), + latent_rgbd[..., 0:3], + bg_rgb, + ) + latent_d = jnp.minimum( + jnp.where(latent_rgbd[..., 3:] == 0.0, 10, latent_rgbd[..., 3:]), bg_d + ) + + likelihood_args["latent_rgbd"] = jnp.concatenate( + [latent_rgb, latent_d], axis=-1 + ) likelihood_args["rasterize_results"] = rasterize_results image = image_likelihood(likelihood_args) @ "rgbd" return { "likelihood_args": likelihood_args, - "scene_mesh": scene_mesh, "rgbd": image, + "new_state": all_poses | {"t": previous_state["t"] + 1}, } @jax.jit @@ -98,7 +156,7 @@ def info_from_trace(trace): trace.get_retval()["likelihood_args"], ) - def viz_trace(trace, t=0, cloud=False): + def viz_trace(trace, t=0, cloud=True): info = info_from_trace(trace) b3d.utils.rr_set_time(t) likelihood_args = trace.get_retval()["likelihood_args"] @@ -109,7 +167,6 @@ def viz_trace(trace, t=0, cloud=False): likelihood_args["cy"], ) - info = info_from_trace(trace) rr.log("image", rr.Image(trace.get_choices()["rgbd"][..., :3])) b3d.rr_log_rgb(trace.get_choices()["rgbd"][..., :3], "image/rgb/observed") b3d.rr_log_rgb(info["latent_rgbd"][..., :3], "image/rgb/latent") @@ -141,4 +198,4 @@ def viz_trace(trace, t=0, cloud=False): # rr.log("rgb/is_match", rr.DepthImage(intermediate_info["is_match"] * 1.0)) # rr.log("rgb/color_match", rr.DepthImage(intermediate_info["color_match"] * 1.0)) - return dense_multiobject_model, viz_trace, info_from_trace + return dense_multiobject_model, viz_trace diff --git a/src/b3d/chisight/dense/likelihoods/blur_likelihood_gaussian.py b/src/b3d/chisight/dense/likelihoods/blur_likelihood_gaussian.py index 77a77467..2308131f 100644 --- a/src/b3d/chisight/dense/likelihoods/blur_likelihood_gaussian.py +++ b/src/b3d/chisight/dense/likelihoods/blur_likelihood_gaussian.py @@ -114,7 +114,7 @@ def likelihood_per_pixel(latent_rgbd: jnp.ndarray, blur): @jax.jit def blur_intermediate_likelihood_func(observed_rgbd, latent_rgbd, likelihood_args): - # k = likelihood_args["k"].const + # k = likelihood_args["k"].unwrap() color_variance = likelihood_args["color_variance_0"] depth_variance = likelihood_args["depth_variance_0"] outlier_probability = likelihood_args["outlier_probability_0"] diff --git a/src/b3d/chisight/dense/likelihoods/laplace_likelihood.py b/src/b3d/chisight/dense/likelihoods/laplace_likelihood.py index 34eacbcd..30de767e 100644 --- a/src/b3d/chisight/dense/likelihoods/laplace_likelihood.py +++ b/src/b3d/chisight/dense/likelihoods/laplace_likelihood.py @@ -1,6 +1,8 @@ import jax import jax.numpy as jnp +from b3d.modeling_utils import get_interpenetration + @jax.jit def likelihood_func(observed_rgbd, likelihood_args): @@ -9,7 +11,17 @@ def likelihood_func(observed_rgbd, likelihood_args): depth_variance = likelihood_args["depth_noise_variance"] outlier_probability = likelihood_args["outlier_probability"] - valid_window = latent_rgbd[..., 3] > 0.0 + valid_window = latent_rgbd[..., 0:3].sum(axis=2) > 0.0 # latent_rgbd[..., 3] > 0.0 + if likelihood_args["masked"].unwrap(): + observed_window = observed_rgbd[..., 0:3].sum(axis=2) > 0.0 + invalid_window = jnp.multiply(observed_window, ~valid_window) + near = 0.001 + far = jnp.inf + else: + invalid_window = ~valid_window + far = 1 + near = 0 + pixelwise_score = ( jax.scipy.stats.laplace.logpdf( observed_rgbd, @@ -17,7 +29,7 @@ def likelihood_func(observed_rgbd, likelihood_args): jnp.array([color_variance, color_variance, color_variance, depth_variance]), ).sum(-1) * valid_window - + jnp.log(1.0 / 1.0) * ~valid_window + - (jnp.log(1.0 / 1.0**3) + jnp.log(far - near)) * invalid_window ) pixelwise_score = jnp.logaddexp( @@ -25,8 +37,20 @@ def likelihood_func(observed_rgbd, likelihood_args): jnp.log(outlier_probability), ) + score = pixelwise_score.sum() + + if likelihood_args["check_interp"].unwrap(): + interpeneration = get_interpenetration( + likelihood_args["scene_mesh"], likelihood_args["num_mc_sample"].unwrap() + ) + interpeneration_score = ( + likelihood_args["interp_penalty"].unwrap() * interpeneration + ) + # jax.debug.print("interpeneration: {v}", v=interpeneration) + score -= interpeneration_score + return { - "score": pixelwise_score.sum(), + "score": score, "pixelwise_score": pixelwise_score, "latent_rgbd": latent_rgbd, } diff --git a/src/b3d/chisight/dense/likelihoods/laplace_likelihood_blur.py b/src/b3d/chisight/dense/likelihoods/laplace_likelihood_blur.py new file mode 100644 index 00000000..05c3bd93 --- /dev/null +++ b/src/b3d/chisight/dense/likelihoods/laplace_likelihood_blur.py @@ -0,0 +1,151 @@ +import functools + +import genjax +import jax +import jax.numpy as jnp + +from b3d.modeling_utils import get_interpenetration + + +def log_gaussian_kernel(size: int, sigma: float) -> jnp.ndarray: + """Creates a 2D Gaussian kernel.""" + ax = jnp.arange(-size // 2 + 1.0, size // 2 + 1.0) + xx, yy = jnp.meshgrid(ax, ax) + kernel = -(xx**2 + yy**2) / (2.0 * sigma**2) + kernel = kernel - jax.nn.logsumexp(kernel) + return kernel + + +lower_bound = jnp.array([0.0, 0.0, 0.0, 0.0]) +upper_bound = jnp.array([1.0, 1.0, 1.0, 100.0]) + +filter_size = 1 + + +@jax.jit +def likelihood_func(observed_rgbd, likelihood_args): + latent_rgbd = likelihood_args["latent_rgbd"] + color_variance = likelihood_args["color_noise_variance"] + depth_variance = likelihood_args["depth_noise_variance"] + outlier_probability = likelihood_args["outlier_probability"] + rows, cols = jnp.meshgrid(jnp.arange(likelihood_args["image_width"].unwrap()), jnp.arange(likelihood_args["image_height"].unwrap())) + + @functools.partial( + jnp.vectorize, + signature="(m)->()", + excluded=( + 1, + 2, + 3, + 4, + ), + ) + def per_pixel( + ij, + observed_rgbd, + latent_rgbd_padded, + log_kernel, + filter_size, + ): + latent_rgb_padded_window = jax.lax.dynamic_slice( + latent_rgbd_padded, + (ij[0], ij[1], 0), + (2 * filter_size + 1, 2 * filter_size + 1, 4), + ) + + scores_inlier = genjax.truncated_normal.logpdf( + observed_rgbd[ij[0], ij[1], :], + latent_rgb_padded_window, + jnp.array([color_variance, color_variance, color_variance, depth_variance]), + 0.0 - 0.00001, + 1.0 + 0.00001, + ).sum(-1) + jnp.where(latent_rgb_padded_window[..., 3] == 0.0, -jnp.inf, 0.0) + + score_mixed = jax.nn.logsumexp(scores_inlier + log_kernel) + + final_score = jnp.logaddexp( + score_mixed + jnp.log(1.0 - outlier_probability), + jnp.log(outlier_probability), + ) + return final_score + + @jax.jit + def likelihood_per_pixel( + observed_rgbd: jnp.ndarray, latent_rgbd: jnp.ndarray, blur + ): + observed_rgbd = (observed_rgbd - lower_bound) / (upper_bound - lower_bound) + latent_rgbd = (latent_rgbd - lower_bound) / (upper_bound - lower_bound) + + latent_rgbd_padded = jnp.pad( + latent_rgbd, + ( + (filter_size, filter_size), + (filter_size, filter_size), + (0, 0), + ), + mode="edge", + ) + + indices = jnp.stack([rows, cols], axis=-1) + log_kernel = log_gaussian_kernel(2 * filter_size + 1, blur) + + log_probabilities = per_pixel( + indices, + observed_rgbd, + latent_rgbd_padded, + log_kernel, + filter_size, + ) + return log_probabilities + + scores = likelihood_per_pixel(observed_rgbd, latent_rgbd, likelihood_args["blur"]) + score = scores.sum() + + pixelwise_score = jnp.zeros((observed_rgbd.shape[0], observed_rgbd.shape[1])) + pixelwise_score = pixelwise_score.at[rows, cols].set(scores) + + + + + # valid_window = latent_rgbd[..., 0:3].sum(axis=2) > 0.0 # latent_rgbd[..., 3] > 0.0 + # if likelihood_args["masked"].unwrap(): + # observed_window = observed_rgbd[..., 0:3].sum(axis=2) > 0.0 + # invalid_window = jnp.multiply(observed_window, ~valid_window) + # near = 0.001 + # far = jnp.inf + # else: + # invalid_window = ~valid_window + # far = 1 + # near = 0 + + # pixelwise_score = ( + # jax.scipy.stats.laplace.logpdf( + # observed_rgbd, + # latent_rgbd, + # jnp.array([color_variance, color_variance, color_variance, depth_variance]), + # ).sum(-1) + # * valid_window + # - (jnp.log(1.0 / 1.0**3) + jnp.log(far - near)) * invalid_window + # ) + + # pixelwise_score = jnp.logaddexp( + # pixelwise_score + jnp.log(1.0 - outlier_probability), + # jnp.log(outlier_probability), + # ) + + # score = pixelwise_score.sum() + + # if likelihood_args["check_interp"].unwrap(): + # interpeneration = get_interpenetration( + # likelihood_args["scene_mesh"], likelihood_args["num_mc_sample"].unwrap() + # ) + # interpeneration_score = ( + # likelihood_args["interp_penalty"].unwrap() * interpeneration + # ) + # score -= interpeneration_score + + return { + "score": score, + "pixelwise_score": pixelwise_score, + "latent_rgbd": latent_rgbd, + } diff --git a/src/b3d/chisight/dense/likelihoods/other_likelihoods.py b/src/b3d/chisight/dense/likelihoods/other_likelihoods.py index af88e213..13b5ec19 100644 --- a/src/b3d/chisight/dense/likelihoods/other_likelihoods.py +++ b/src/b3d/chisight/dense/likelihoods/other_likelihoods.py @@ -294,7 +294,7 @@ def sample(self, key, probs, args): def logpdf(self, observed, probs, args): logprobs = [] for i, dist in enumerate(self.dists): - lp = dist.logpdf(observed, *args[i]) + lp = dist.logpdf(observed, *args[i]) + jnp.log(probs[i]) logprobs.append(lp) logprobs = jnp.stack(logprobs) # jax.debug.print("lps = {lps}", lps=logprobs) diff --git a/src/b3d/chisight/dynamic_object_model/drift_kernels.py b/src/b3d/chisight/dynamic_object_model/drift_kernels.py deleted file mode 100644 index 91ebd0a9..00000000 --- a/src/b3d/chisight/dynamic_object_model/drift_kernels.py +++ /dev/null @@ -1,190 +0,0 @@ -from abc import abstractmethod -from typing import Sequence - -import genjax -import jax.numpy as jnp -from genjax import Pytree -from genjax.typing import ArrayLike, PRNGKey -from tensorflow_probability.substrates import jax as tfp - -from b3d.chisight.dense.likelihoods.other_likelihoods import PythonMixturePixelModel -from b3d.chisight.dynamic_object_model.likelihoods.kfold_image_kernel import ( - _FIXED_COLOR_UNIFORM_WINDOW, - truncated_color_laplace, - truncated_laplace, -) - - -@Pytree.dataclass -class DriftKernel(genjax.ExactDensity): - """An abstract class that defines the common interface for drift kernels.""" - - @abstractmethod - def sample(self, key: PRNGKey, prev_value: ArrayLike) -> ArrayLike: - raise NotImplementedError - - @abstractmethod - def logpdf(self, new_value: ArrayLike, prev_value: ArrayLike) -> ArrayLike: - raise NotImplementedError - - -@Pytree.dataclass -class UniformDriftKernel(DriftKernel): - """A drift kernel that samples a new value from a uniform distribution centered - around the previous value. The range of the uniform distribution may shrink - to ensure that the new value is within the bounds of [min_val, max_val]. - - Support: [max(min_val, prev_value - max_shift), min(max_val, prev_value + max_shift)] - """ - - max_shift: float = Pytree.static() - min_val: float = Pytree.static() - max_val: float = Pytree.static() - - def sample(self, key: PRNGKey, prev_value: ArrayLike) -> ArrayLike: - return self._base_dist(prev_value).sample(seed=key) - - def logpdf(self, new_value: ArrayLike, prev_value: ArrayLike) -> ArrayLike: - return self._base_dist(prev_value).log_prob(new_value) - - def _base_dist(self, prev_value: ArrayLike): - """Returns a uniform distribution centered around prev_value, bounded by - min_val and max_val.""" - low = jnp.maximum(prev_value - self.max_shift, self.min_val) - high = jnp.minimum(prev_value + self.max_shift, self.max_val) - return tfp.distributions.Uniform(low, high) - - -@Pytree.dataclass -class UniformColorDriftKernel(UniformDriftKernel): - """A specialized uniform drift kernel with fixed min_val and max_val, with - additional logics to handle the color channels jointly. - - Support: [max(0.0, prev_value - max_shift), min(1.0, prev_value + max_shift)] - """ - - max_shift: float = Pytree.static() - min_val: float = Pytree.static(default=0.0, init=False) - max_val: float = Pytree.static(default=1.0, init=False) - - def logpdf(self, new_value: ArrayLike, prev_value: ArrayLike) -> ArrayLike: - # the summation at the end is to ensure that we get a single value for - # the 3 channels (instead of 3 separate values) - return super().logpdf(new_value, prev_value).sum() - - -@Pytree.dataclass -class LaplaceDriftKernel(DriftKernel): - """A drift kernel that samples from a truncated Laplace distribution centered - at the previous value. Values outside of the bounds will be resampled from a - small uniform window at the boundary. This is a thin wrapper around the - truncated_laplace distribution to provide a consistent interface with other - drift kernels. - - Support: [min_val, max_val] - """ - - scale: float = Pytree.static() - min_val: float = Pytree.static() - max_val: float = Pytree.static() - uniform_window_size: float = Pytree.static() - - def sample(self, key: PRNGKey, prev_value: ArrayLike) -> ArrayLike: - return truncated_laplace.sample( - key, prev_value, self.scale, self.uniform_window_size - ) - - def logpdf(self, new_value: ArrayLike, prev_value: ArrayLike) -> ArrayLike: - return truncated_laplace.logpdf( - new_value, prev_value, self.scale, self.uniform_window_size - ) - - -@Pytree.dataclass -class LaplaceColorDriftKernel(DriftKernel): - """A drift kernel that samples the 3 channels of the color from a specialized - truncated Laplace distribution, centered at the previous color. Values outside - of the bounds will be resampled from a small uniform window at the boundary. - This is a thin wrapper around the truncated_color_laplace distribution to - provide a consistent interface with other drift kernels. - - Support: [0.0, 1.0] - """ - - scale: float = Pytree.static() - uniform_window_size: float = Pytree.static(default=_FIXED_COLOR_UNIFORM_WINDOW) - - def sample(self, key: PRNGKey, prev_value: ArrayLike) -> ArrayLike: - return truncated_color_laplace.sample( - key, prev_value, self.scale, self.uniform_window_size - ) - - def logpdf(self, new_value: ArrayLike, prev_value: ArrayLike) -> ArrayLike: - return truncated_color_laplace.logpdf( - new_value, prev_value, self.scale, self.uniform_window_size - ) - - -@Pytree.dataclass -class GaussianDriftKernel(DriftKernel): - """A drift kernel that samples from a truncated Gaussian distribution centered - at the previous value. Values outside of the bounds will be renormalized. - - Support: [min_val, max_val] - """ - - scale: float = Pytree.static() - min_val: float = Pytree.static() - max_val: float = Pytree.static() - - def sample(self, key: PRNGKey, prev_value: ArrayLike) -> ArrayLike: - return self._base_dist(prev_value).sample(seed=key) - - def logpdf(self, new_value: ArrayLike, prev_value: ArrayLike) -> ArrayLike: - return self._base_dist(prev_value).log_prob(new_value) - - def _base_dist(self, prev_value: ArrayLike): - return tfp.distributions.TruncatedNormal( - loc=prev_value, scale=self.scale, low=self.min_val, high=self.max_val - ) - - -@Pytree.dataclass -class GaussianColorDriftKernel(GaussianDriftKernel): - """A specialized Gaussian drift kernel that samples from a truncated Gaussian - distribution centered at the previous value. Values outside of the bounds - will be renormalized. - - Support: [0.0, 1.0] - """ - - scale: float = Pytree.static() - min_val: float = Pytree.static(default=0.0, init=False) - max_val: float = Pytree.static(default=1.0, init=False) - - def logpdf(self, new_value: ArrayLike, prev_value: ArrayLike) -> ArrayLike: - # the summation at the end is to ensure that we get a single value for - # the 3 channels (instead of 3 separate values) - return super().logpdf(new_value, prev_value).sum() - - -@Pytree.dataclass -class MixtureDriftKernel(DriftKernel): - """A drift kernel that samples from a mixture of distributions according to - the probabilities specified in the `mix_ratio`. - """ - - dists: Sequence[DriftKernel] = Pytree.static() - mix_ratio: ArrayLike = Pytree.static() - - def sample(self, key: PRNGKey, prev_value: ArrayLike) -> ArrayLike: - return PythonMixturePixelModel(self.dists).sample( - key, self.mix_ratio, [(prev_value,)] * len(self.dists) - ) - - def logpdf(self, new_value: ArrayLike, prev_value: ArrayLike) -> ArrayLike: - return PythonMixturePixelModel(self.dists).logpdf( - new_value, - self.mix_ratio, - [(prev_value,)] * len(self.dists), - ) diff --git a/src/b3d/chisight/dynamic_object_model/dynamic_object_inference.py b/src/b3d/chisight/dynamic_object_model/dynamic_object_inference.py deleted file mode 100644 index 06a048ef..00000000 --- a/src/b3d/chisight/dynamic_object_model/dynamic_object_inference.py +++ /dev/null @@ -1,561 +0,0 @@ -import jax -import jax.numpy as jnp -import jax.random -from genjax import ChoiceMapBuilder as C -from genjax import Diff -from genjax import UpdateProblemBuilder as U - -from b3d import Pose - -from .dynamic_object_model import ( - info_from_trace, - make_color_outlier_probabilities_choicemap, - make_colors_choicemap, - make_depth_outlier_probabilities_choicemap, -) - - -@jax.jit -def advance_time(key, trace, observed_rgbd): - """ - Advance to the next timestep, setting the new latent state to the - same thing as the previous latent state, and setting the new - observed RGBD value. - - Returns a trace where previous_state (stored in the arguments) - and new_state (sampled in the choices and returned) are identical. - """ - hyperparams, _ = trace.get_args() - previous_state = trace.get_retval()["new_state"] - trace, _, _, _ = trace.update( - key, - U.g( - (Diff.no_change(hyperparams), Diff.unknown_change(previous_state)), - C.kw(rgbd=observed_rgbd), - ), - ) - return trace - - -#### New Inference Programs - - -# Propose new depth outlier probabilities -@jax.jit -def propose_depth_outlier_probability(trace, key): - depth_outlier_probability_sweep = jnp.array([0.01, 0.5, 1.0]) # (k, ) - - current_depth_outlier_probabilities = trace.get_args()[1][ - "depth_outlier_probabilities" - ] # (num_vertices, ) - - depth_outlier_probability_sweep_full = ( - depth_outlier_probability_sweep[..., None] - * jnp.ones_like(current_depth_outlier_probabilities) - ) # (k, num_vertices) where the values in row i are all depth_outlier_probability_sweep[i] - - # Function takes in depth outlier probability array of shape (num_vertices,) and gives scores for each vertex (num_vertices,) - - def get_per_vertex_likelihoods_with_new_depth_outlier_probabilities( - depth_outlier_probabilities, - ): - return info_from_trace( - trace.update( - key, - make_depth_outlier_probabilities_choicemap(depth_outlier_probabilities), - )[0] - )["scores"] - - # Vmap over the depth_outlier_probability_sweep_full array to get scores for each vertex for each depth_outlier_probability in the sweep - likelihood_scores_per_sweep_point_and_vertex = jax.vmap( - get_per_vertex_likelihoods_with_new_depth_outlier_probabilities - )(depth_outlier_probability_sweep_full) # (k, num_vertices) - # P(pixel / nothing | depth outlier prob, latent point) - - depth_outlier_probability_transition_kernel = trace.get_args()[0][ - "depth_outlier_probability_transition_kernel" - ] - vectorized_outlier_probability_transition_kernel_logpdf = jnp.vectorize( - depth_outlier_probability_transition_kernel.logpdf, signature="(),()->()" - ) - - transition_scores_per_sweep_point_and_vertex = ( - vectorized_outlier_probability_transition_kernel_logpdf( - depth_outlier_probability_sweep_full, # (k, num_vertices) - current_depth_outlier_probabilities, # (num_vertices, ) - ) - ) # (k, num_vertices) - - scores_per_sweep_point_and_vertex = ( - likelihood_scores_per_sweep_point_and_vertex - + transition_scores_per_sweep_point_and_vertex - ) - normalized_log_probabilities = jax.nn.log_softmax( - scores_per_sweep_point_and_vertex, axis=0 - ) - - sampled_indices = jax.random.categorical(key, normalized_log_probabilities, axis=0) - # sampled_indices = jnp.argmax(scores_per_sweep_point_and_vertex, axis=0) - - sampled_depth_outlier_probabilities = depth_outlier_probability_sweep[ - sampled_indices - ] - - # normalized_log_probabilities is (k, num_vertices) - log_q_depth_outlier_probability = normalized_log_probabilities[ - sampled_indices, jnp.arange(normalized_log_probabilities.shape[1]) - ].sum() - - return ( - sampled_depth_outlier_probabilities, - log_q_depth_outlier_probability, - scores_per_sweep_point_and_vertex, - ) - - -# @jax.jit -# def propose_pose(trace, key, pose_sample_variance, pose_sample_concentration): -# pose = Pose.sample_gaussian_vmf_pose( -# key, -# trace.get_choices()["pose"], -# pose_sample_variance, -# pose_sample_concentration, -# ) -# log_q_pose = Pose.logpdf_gaussian_vmf_pose( -# pose, -# trace.get_choices()["pose"], -# pose_sample_variance, -# pose_sample_concentration, -# ) -# return pose, log_q_pose - - -@jax.jit -def propose_color_and_color_outlier_probability(trace, key, outlier_probability_sweep): - # color_outlier_probability_sweep is (k,) shape array - - current_color_outlier_probabilities = trace.get_args()[1][ - "color_outlier_probabilities" - ] - current_colors = trace.get_args()[1]["colors"] - - # num_vertices = current_colors.shape[0] - # num_outlier_grid_points = outlier_probability_sweep.shape[0] - color_outlier_probabilities_sweep = ( - outlier_probability_sweep[..., None] # (num_outlier_grid_points, 1) - * jnp.ones_like(current_color_outlier_probabilities) # (num_vertices,) - ) # (num_outlier_grid_points, num_vertices) - - # We will grid over color values, using a grid that mixes the old and observed - # colors in a set of exact proportions. - # We regard these as coming from uniform proposals where we sample the RGB - # values uniformly between the mixed R, G, and B values with mixtures between - # [0., .125], [.125, .5], [.5, .875], [.875, 1.]. - # So the q scores will be .125^3, .375^3, .375^3, .125^3. - # TODO: we really ought to add a small amount of proposal probability mass - # onto the points at the end, to capture the fact that the posterior could allow - # colors outside the considered interpolation window. - color_interpolations_per_proposal = jnp.array([0.0, 0.5, 1.0]) - # num_color_grid_points = len(color_interpolations_per_proposal) - - observed_colors = info_from_trace(trace)["observed_rgbd_masked"][ - ..., :3 - ] # (num_vertices, 3) - color_sweep = observed_colors[None, ...] * color_interpolations_per_proposal[ - :, None, None - ] + current_colors[None, ...] * ( - 1 - color_interpolations_per_proposal[:, None, None] - ) # (num_color_grid_points, num_vertices, 3) - - # Function takes in color and color outlier probabilities array of shapes (num_vertices,3) and (num_vertices,) respectively - # and gives scores for each vertex (num_vertices,) - def get_per_vertex_likelihoods_with_new_color_and_color_outlier_probabilities( - colors, color_outlier_probabilities - ): - return info_from_trace( - trace.update( - key, - make_color_outlier_probabilities_choicemap(color_outlier_probabilities) - ^ make_colors_choicemap(colors), - )[0] - )["scores"] - - vmap_version = jax.vmap( - jax.vmap( - get_per_vertex_likelihoods_with_new_color_and_color_outlier_probabilities, - in_axes=(None, 0), - ), - in_axes=(0, None), - ) - - # Vmap over the depth_outlier_probability_sweep_full array to get scores for each vertex for each depth_outlier_probability in the sweep - likelihood_scores_per_sweep_point_and_vertex = vmap_version( - color_sweep, color_outlier_probabilities_sweep - ) # (num_color_grid_points, num_outlier_grid_points, num_vertices) - - # Color outlier transition scores - color_outlier_probability_transition_kernel = trace.get_args()[0][ - "color_outlier_probability_transition_kernel" - ] - vectorized_outlier_probability_transition_kernel_logpdf = jnp.vectorize( - color_outlier_probability_transition_kernel.logpdf, signature="(),()->()" - ) - color_outlier_transition_scores_per_sweep_point_and_vertex = vectorized_outlier_probability_transition_kernel_logpdf( - color_outlier_probabilities_sweep, # (num_outlier_grid_points, num_vertices) - current_color_outlier_probabilities, - ) # (num_outlier_grid_points, num_vertices) - - color_transition_kernel = trace.get_args()[0]["color_transition_kernel"] - vectorized_color_transition_kernel_logpdf = jnp.vectorize( - color_transition_kernel.logpdf, signature="(3),(3)->()" - ) - color_transition_scores_per_sweep_point_and_vertex = ( - vectorized_color_transition_kernel_logpdf(color_sweep, current_colors) - ) # (num_color_grid_points, num_vertices) - - scores_per_sweep_point_and_vertex = ( - likelihood_scores_per_sweep_point_and_vertex # (num_color_grid_points, num_outlier_grid_points, num_vertices) - + color_outlier_transition_scores_per_sweep_point_and_vertex[None, ...] - + color_transition_scores_per_sweep_point_and_vertex[:, None, ...] - ) # (num_color_grid_points, num_outlier_grid_points, num_vertices) - - unraveled_scores = scores_per_sweep_point_and_vertex.reshape( - -1, scores_per_sweep_point_and_vertex.shape[-1] - ) - normalized_log_probabilities = jax.nn.log_softmax(unraveled_scores, axis=0) - sampled_indices = jax.random.categorical(key, normalized_log_probabilities, axis=0) - - color_sweep_indices, color_outlier_sweep_indices = jnp.unravel_index( - sampled_indices, scores_per_sweep_point_and_vertex.shape[:2] - ) - - # color_sweep is (num_outlier_grid_points, num_vertices, 3) - # outlier_probability_sweep is (num_outlier_grid_points,) - # color_outlier_probabilities_sweep is (num_outlier_grid_points, num_vertices) - sampled_colors = color_sweep[color_sweep_indices, jnp.arange(color_sweep.shape[1])] - sampled_color_outlier_probabilities = outlier_probability_sweep[ - color_outlier_sweep_indices - ] - - log_q_color_and_color_outlier_probability = normalized_log_probabilities[ - sampled_indices, jnp.arange(normalized_log_probabilities.shape[1]) - ].sum() - - # log_q = estimate of q(all these colors, all these outliers ; inputs) - # Only source of real randomness = sampling indices. Captured in log_q_color_and_color_outlier_probability. - # But we also want to be careful with the continuous values... - # (1) outlier probs. --> change the model to have discrete grid. [Do later.] - # (2) colors. --> 1/q() - # uniform(old r, 2/3 oldr + 1/3 newr) 0 | uniform(0, 0.1) - # uniform(1/3, 2/3) # .5 | uniform(.1, .9) - # uniform(2/3, 1) # 1 | uniform(.9, 1) - # - # q(c1) * q(c2) * q(c3) - # but we just output c2 - # q(the c values we output, marginalizing over the other choices) - # -> just output q(c2) - - # We will treat this like the case where each sweep is uniform, so the q scores - # are each (oldr - obsr)/3 * (oldg - obsg)/3 * (oldb - obsb)/3. - q_prob_per_vertex = ( - 1.0 / ((jnp.abs(current_colors - observed_colors) / 3) + 0.001) - ).prod(-1) - log_q_for_the_color_proposal = jnp.log(q_prob_per_vertex).sum() - - return ( - sampled_colors, - sampled_color_outlier_probabilities, - log_q_color_and_color_outlier_probability + log_q_for_the_color_proposal, - scores_per_sweep_point_and_vertex, - ) - - -@jax.jit -def propose_depth_variance(trace, key, depth_variance_sweep): - scores = jax.vmap( - lambda variance: trace.update(key, C["depth_variance"].set(variance))[ - 0 - ].get_score() - )(depth_variance_sweep) - scores = jax.nn.log_softmax(scores) - sampled_index = jax.random.categorical(key, scores) - sampled_depth_variance = depth_variance_sweep[sampled_index] - log_q_depth_variance = scores[sampled_index] - return sampled_depth_variance, log_q_depth_variance - - -@jax.jit -def propose_color_variance(trace, key, color_variance_sweep): - scores = jax.vmap( - lambda variance: trace.update(key, C["color_variance"].set(variance))[ - 0 - ].get_score() - )(color_variance_sweep) - scores = jax.nn.log_softmax(scores) - sampled_index = jax.random.categorical(key, scores) - sampled_color_variance = color_variance_sweep[sampled_index] - log_q_color_variance = scores[sampled_index] - return sampled_color_variance, log_q_color_variance - - -@jax.jit -def propose_update(trace, key, pose): - total_log_q = 0.0 - - # Update pose - # pose, log_q_pose = propose_pose( - # trace, key, pose_sample_variance, pose_sample_concentration - # ) - trace = trace.update(key, C["pose"].set(pose))[0] - # total_log_q += log_q_pose - - # Update depth outlier probability - sampled_depth_outlier_probability, log_q_depth_outlier_probability, _ = ( - propose_depth_outlier_probability(trace, key) - ) - trace = trace.update( - key, - make_depth_outlier_probabilities_choicemap(sampled_depth_outlier_probability), - )[0] - total_log_q += log_q_depth_outlier_probability - - # Update color and color outlier probability - color_outlier_probability_sweep = jnp.array([0.01, 0.5, 1.0]) - colors, color_outlier_probability, log_q_color_color_outlier_probability, _ = ( - propose_color_and_color_outlier_probability( - trace, key, color_outlier_probability_sweep - ) - ) - trace = trace.update( - key, - make_colors_choicemap(colors) - ^ make_color_outlier_probabilities_choicemap(color_outlier_probability), - )[0] - total_log_q += log_q_color_color_outlier_probability - - # # Update depth variance - # depth_variance_sweep = jnp.array([0.0005, 0.001, 0.0025, 0.005, 0.01]) - # depth_variance, log_q_depth_variance = propose_depth_variance( - # trace, key, depth_variance_sweep - # ) - # trace = trace.update(key, C["depth_variance"].set(depth_variance))[0] - # total_log_q += log_q_depth_variance - - # # Update color variance - # color_variance_sweep = jnp.array([0.005, 0.01, 0.05, 0.1, 0.2]) - # color_variance, log_q_color_variance = propose_color_variance( - # trace, key, color_variance_sweep - # ) - # trace.update(key, C["color_variance"].set(color_variance))[0] - # total_log_q += log_q_color_variance - return trace, total_log_q - - -@jax.jit -def propose_update_get_score(trace, key, pose): - new_trace, log_q = propose_update(trace, key, pose) - # score is an estimate of P(data, pose | previous state) - return new_trace.get_score() - log_q - - -propose_update_get_score_vmap = jax.jit( - jax.vmap(propose_update_get_score, in_axes=(None, None, 0)) -) - - -def inference_step_without_advance(trace, key): - number = 20000 - - var, conc = 0.02, 2000.0 - - for _ in range(10): - key = jax.random.split(key, 2)[-1] - keys = jax.random.split(key, number) - poses = Pose.concatenate_poses( - [ - Pose.sample_gaussian_vmf_pose_vmap( - keys, trace.get_choices()["pose"], var, conc - ), - trace.get_choices()["pose"][None, ...], - ] - ) - pose_scores = Pose.logpdf_gaussian_vmf_pose_vmap( - poses, trace.get_choices()["pose"], var, conc - ) - scores = propose_update_get_score_vmap(trace, key, poses) - scores = ( - scores - pose_scores - ) # After this, scores are fair estimates of P(data | previous state) - # and can be used to resample the choice sets. - index = jax.random.categorical(key, scores) - trace = propose_update(trace, key, poses[index])[0] - - return trace - - -def inference_step(trace, key, observed_rgbd): - trace = advance_time(key, trace, observed_rgbd) - trace = inference_step_without_advance(trace, key) - return trace - - -# ## Old Inference moves ### -# @jax.jit -# def update_colors(trace): -# key = jax.random.PRNGKey(0) -# info = info_from_trace(trace) - -# color_delta = ( -# info["observed_rgbd_masked"][..., :3] - trace.get_choices()["colors", ...] -# ) -# max_color_shift = trace.get_args()[0]["max_color_shift"] -# color_delta_clipped = jnp.clip(color_delta, -max_color_shift, max_color_shift) - -# trace = trace.update( -# key, -# make_colors_choicemap(trace.get_choices()["colors", ...] + color_delta_clipped), -# )[0] -# return trace - - -# @jax.jit -# def score_with_give_pose_and_then_color_update(trace, pose, outlier_probability_sweep): -# key = jax.random.PRNGKey(0) -# trace = trace.update(key, C["pose"].set(pose))[0] - -# trace = update_colors(trace) - -# trace = grid_move_on_color_outlier_probability(trace, outlier_probability_sweep) -# trace = grid_move_on_depth_outlier_probability(trace, outlier_probability_sweep) - -# return trace.get_score() - - -# @jax.jit -# def grid_move_on_depth_outlier_probability(trace, sweep): -# current_setting = trace.get_choices()["depth_outlier_probabilities", ...] -# potential_values = sweep[..., None] * jnp.ones_like(current_setting) -# key = jax.random.PRNGKey(0) -# get_vertex_scores_vmap = jax.vmap( -# lambda x: info_from_trace( -# trace.update(key, make_depth_outlier_probabilities_choicemap(x))[0] -# )["scores"] -# ) -# scores = get_vertex_scores_vmap(potential_values) -# best_setting = sweep[jnp.argmax(scores, axis=0)] -# return trace.update(key, make_depth_outlier_probabilities_choicemap(best_setting))[ -# 0 -# ] - - -# @jax.jit -# def grid_move_on_color_outlier_probability(trace, sweep): -# current_setting = trace.get_choices()["color_outlier_probabilities", ...] - -# potential_values = sweep[..., None] * jnp.ones_like(current_setting) -# key = jax.random.PRNGKey(0) -# get_vertex_scores_vmap = jax.vmap( -# lambda x: info_from_trace( -# trace.update(key, make_color_outlier_probabilities_choicemap(x))[0] -# )["scores"] -# ) -# scores = get_vertex_scores_vmap(potential_values) -# best_setting = sweep[jnp.argmax(scores, axis=0)] -# return trace.update(key, make_color_outlier_probabilities_choicemap(best_setting))[ -# 0 -# ] - - -# @jax.jit -# def update_address_with_sweep(trace, address, sweep): -# scores = b3d.enumerate_choices_get_scores(trace, address, sweep) -# best_setting = sweep[jnp.argmax(scores)] -# return b3d.update_choices(trace, address, best_setting) - - -# @partial(jax.jit, static_argnames=("number",)) -# def gaussian_vmf_enumerative_move_with_other_updates( -# trace, key, address, varianc, conc, number, outlier_probability_sweep -# ): -# keys = jax.random.split(key, number) -# poses = Pose.concatenate_poses( -# [ -# Pose.sample_gaussian_vmf_pose_vmap( -# keys, trace.get_choices()["pose"], 0.02, 2000.0 -# ), -# trace.get_choices()["pose"][None, ...], -# ] -# ) - -# scores = jax.vmap( -# score_with_give_pose_and_then_color_update, in_axes=(None, 0, None) -# )(trace, poses, outlier_probability_sweep) - -# key = b3d.split_key(keys[-1]) -# sampled_pose = poses[scores.argmax()] -# trace = trace.update(key, C["pose"].set(sampled_pose))[0] -# return trace, key - - -# def inference_step_old(trace, key, observed_rgbd): -# trace = advance_time(key, trace, observed_rgbd) - -# outlier_probability_sweep = jnp.array([0.01, 0.5, 1.0]) -# num_grid_points = 20000 -# for _ in range(2): -# trace, key = gaussian_vmf_enumerative_move_with_other_updates( -# trace, -# key, -# Pytree.const(("pose",)), -# 0.04, -# 200.0, -# num_grid_points, -# outlier_probability_sweep, -# ) -# trace, key = gaussian_vmf_enumerative_move_with_other_updates( -# trace, -# key, -# Pytree.const(("pose",)), -# 0.01, -# 500.0, -# num_grid_points, -# outlier_probability_sweep, -# ) -# trace, key = gaussian_vmf_enumerative_move_with_other_updates( -# trace, -# key, -# Pytree.const(("pose",)), -# 0.005, -# 1000.0, -# num_grid_points, -# outlier_probability_sweep, -# ) -# trace, key = gaussian_vmf_enumerative_move_with_other_updates( -# trace, -# key, -# Pytree.const(("pose",)), -# 0.001, -# 2000.0, -# num_grid_points, -# outlier_probability_sweep, -# ) - -# trace = grid_move_on_color_outlier_probability(trace, outlier_probability_sweep) -# trace = grid_move_on_depth_outlier_probability(trace, outlier_probability_sweep) - -# trace = update_address_with_sweep( -# trace, -# Pytree.const(("color_variance",)), -# jnp.array([0.005, 0.01, 0.05, 0.1, 0.2]), -# ) -# trace = update_address_with_sweep( -# trace, -# Pytree.const(("depth_variance",)), -# jnp.array([0.0005, 0.001, 0.0025, 0.005, 0.01]), -# ) - -# trace = update_colors(trace) - -# trace = grid_move_on_color_outlier_probability(trace, outlier_probability_sweep) -# trace = grid_move_on_depth_outlier_probability(trace, outlier_probability_sweep) -# return trace diff --git a/src/b3d/chisight/dynamic_object_model/dynamic_object_model.py b/src/b3d/chisight/dynamic_object_model/dynamic_object_model.py deleted file mode 100644 index 2542d16d..00000000 --- a/src/b3d/chisight/dynamic_object_model/dynamic_object_model.py +++ /dev/null @@ -1,204 +0,0 @@ -import genjax -import jax -import jax.numpy as jnp -import rerun as rr -from genjax import ChoiceMapBuilder as C -from genjax import Pytree - -import b3d -from b3d import Pose - -# LIKELIHOOD = "aggregate_mean" -LIKELIHOOD = "project_no_occlusions" - -if LIKELIHOOD == "project_no_occlusions": - from b3d.chisight.dynamic_object_model.likelihoods.project_no_occlusions_kernel import ( - likelihood_func, - sample_func, - ) -elif LIKELIHOOD == "aggregate_mean": - from b3d.chisight.dynamic_object_model.likelihoods.aggreate_mean_image_kernel import ( - likelihood_func, - sample_func, - ) -else: - raise NotImplementedError(f"Unknown likelihood: {LIKELIHOOD}") - - -@Pytree.dataclass -class ImageLikelihood(genjax.ExactDensity): - def sample(self, key, likelihood_args): - return sample_func(key, likelihood_args) - - def logpdf(self, observed_rgbd, likelihood_args): - return likelihood_func(observed_rgbd, likelihood_args)["score"] - - -image_likelihood = ImageLikelihood() - - -@jax.jit -def info_from_trace(trace): - return likelihood_func( - trace.get_choices()["rgbd"], - trace.get_retval()["likelihood_args"], - ) - - -@genjax.gen -def dynamic_object_generative_model(hyperparams, previous_state): - vertices = hyperparams["vertices"] - - pose = ( - Pose.uniform_pose_centered( - previous_state["pose"], - -hyperparams["max_pose_position_shift"] * jnp.ones(3), - hyperparams["max_pose_position_shift"] * jnp.ones(3), - ) - @ "pose" - ) - - color_transition_kernel = hyperparams["color_transition_kernel"] - colors = color_transition_kernel.vmap()(previous_state["colors"]) @ "colors" - - color_outlier_probability_transition_kernel = hyperparams[ - "color_outlier_probability_transition_kernel" - ] - color_outlier_probabilities = ( - color_outlier_probability_transition_kernel.vmap()( - previous_state["color_outlier_probabilities"] - ) - @ "color_outlier_probabilities" - ) - - depth_outlier_probability_transition_kernel = hyperparams[ - "depth_outlier_probability_transition_kernel" - ] - depth_outlier_probabilities = ( - depth_outlier_probability_transition_kernel.vmap()( - previous_state["depth_outlier_probabilities"] - ) - @ "depth_outlier_probabilities" - ) - - depth_variance = genjax.uniform(0.0001, 100000.0) @ "depth_variance" - color_variance = genjax.uniform(0.0001, 100000.0) @ "color_variance" - - likelihood_args = { - "fx": hyperparams["fx"], - "fy": hyperparams["fy"], - "cx": hyperparams["cx"], - "cy": hyperparams["cy"], - "image_height": hyperparams["image_height"], - "image_width": hyperparams["image_width"], - "vertices": vertices, - "pose": pose, - "colors": colors, - "color_outlier_probabilities": color_outlier_probabilities, - "depth_outlier_probabilities": depth_outlier_probabilities, - "depth_variance": depth_variance, - "color_variance": color_variance, - } - rgbd = image_likelihood(likelihood_args) @ "rgbd" - - new_state = { - "pose": pose, - "colors": colors, - "color_outlier_probabilities": color_outlier_probabilities, - "depth_outlier_probabilities": depth_outlier_probabilities, - } - return { - "new_state": new_state, - "rgbd": rgbd, - "likelihood_args": likelihood_args, - } - - -def make_colors_choicemap(colors): - return jax.vmap(lambda idx: C["colors", idx].set(colors[idx]))( - jnp.arange(len(colors)) - ) - - -def make_color_outlier_probabilities_choicemap(color_outlier_probabilities): - return jax.vmap( - lambda idx: C["color_outlier_probabilities", idx].set( - color_outlier_probabilities[idx] - ) - )(jnp.arange(len(color_outlier_probabilities))) - - -def make_depth_outlier_probabilities_choicemap(depth_outlier_probabilities): - return jax.vmap( - lambda idx: C["depth_outlier_probabilities", idx].set( - depth_outlier_probabilities[idx] - ) - )(jnp.arange(len(depth_outlier_probabilities))) - - -### Viz ### -def viz_trace(trace, t=0, ground_truth_vertices=None, ground_truth_pose=None): - info = info_from_trace(trace) - b3d.utils.rr_set_time(t) - likelihood_args = trace.get_retval()["likelihood_args"] - fx, fy, cx, cy = ( - likelihood_args["fx"], - likelihood_args["fy"], - likelihood_args["cx"], - likelihood_args["cy"], - ) - vertices = trace.get_args()[0]["vertices"] - - info = info_from_trace(trace) - rr.log("image", rr.Image(trace.get_choices()["rgbd"][..., :3])) - b3d.rr_log_rgb(trace.get_choices()["rgbd"][..., :3], "image/rgb/observed") - b3d.rr_log_rgb(info["latent_rgbd"][..., :3], "image/rgb/latent") - b3d.rr_log_depth(trace.get_choices()["rgbd"][..., 3], "image/depth/observed") - b3d.rr_log_depth(info["latent_rgbd"][..., 3], "image/depth/latent") - - b3d.rr_log_cloud( - info["transformed_points"], - "scene/latent", - trace.get_choices()["colors", ...], - ) - b3d.rr_log_cloud( - b3d.xyz_from_depth( - trace.get_retval()["rgbd"][..., 3], - fx, - fy, - cx, - cy, - ), - "scene/observed", - trace.get_retval()["rgbd"][..., :3].reshape(-1, 3), - ) - - b3d.rr_log_cloud( - vertices, - "object/model", - trace.get_choices()["colors", ...], - ) - b3d.rr_log_cloud( - vertices, - "object/color_outlier_probabilities", - jnp.array([[1.0, 0.0, 0.0]]) - * trace.get_choices()["color_outlier_probabilities", ...][:, None], - ) - b3d.rr_log_cloud( - vertices, - "object/depth_outlier_probabilities", - jnp.array([[0.0, 1.0, 0.0]]) - * trace.get_choices()["depth_outlier_probabilities", ...][:, None], - ) - - if ground_truth_vertices is not None: - b3d.rr_log_cloud( - trace.get_choices()["pose"].apply(ground_truth_vertices), - "scene/full_object_model", - ) - - if ground_truth_pose: - b3d.rr_log_cloud( - ground_truth_pose.apply(ground_truth_vertices), - "scene/ground_truth_object_mesh", - ) diff --git a/src/b3d/chisight/dynamic_object_model/likelihoods/__init__.py b/src/b3d/chisight/dynamic_object_model/likelihoods/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/src/b3d/chisight/dynamic_object_model/likelihoods/aggreate_mean_image_kernel.py b/src/b3d/chisight/dynamic_object_model/likelihoods/aggreate_mean_image_kernel.py deleted file mode 100644 index bc236479..00000000 --- a/src/b3d/chisight/dynamic_object_model/likelihoods/aggreate_mean_image_kernel.py +++ /dev/null @@ -1,141 +0,0 @@ -import genjax -import jax -import jax.numpy as jnp - -import b3d - -# # Version 2 [approximate this with a mean]: -# # `pts` is the set of all points projecting to one pixel (i, j) -# # `nonregistration_prob[pt]` = probability a point is not registered, if it is the only one observed (nonregistration_prob = "outlier prob") -# # `color[pt]` = RGB or D value for the point -# # 1. Compute overall_p_nonregistered = prod_{pt} nonregistration_prob[pt]. [Set to 1.0 if pts is empty.] -# # 2. Compute the mean of all the colors for each point, where the color for `pt` is weighted proportionally to (1 - nonregistration_prob[pt]) -# # 3. Sample from a mixture of [1] a uniform, with probability `nonregistration_prob[pt]`, and [2] a laplace around the mean color - - -@jax.jit -def sample_func(key, args): - transformed_points = args["pose"].apply(args["vertices"]) - pixels = jnp.rint( - b3d.xyz_to_pixel_coordinates( - transformed_points, args["fx"], args["fy"], args["cx"], args["cy"] - ) - - 0.5 - ).astype(jnp.int32) - - latent_image_sum = jnp.zeros( - (args["image_height"].const, args["image_width"].const, 4) - ) - latent_image_sum = latent_image_sum.at[pixels[..., 0], pixels[..., 1], :3].add( - args["colors"] * (1 - args["color_outlier_probability"])[:, None] - ) - latent_image_sum = latent_image_sum.at[pixels[..., 0], pixels[..., 1], 3].add( - transformed_points[..., 2] * (1 - args["depth_outlier_probability"]) - ) - - projected_points_count = jnp.zeros( - (args["image_height"].const, args["image_width"].const) - ) - projected_points_count = projected_points_count.at[ - pixels[..., 0], pixels[..., 1] - ].add(1) - - non_registration_probability = jnp.ones( - (args["image_height"].const, args["image_width"].const) - ) - non_registration_probability = non_registration_probability.at[ - pixels[..., 0], pixels[..., 1] - ].multiply(args["color_outlier_probability"]) - - latent_image_mean = latent_image_sum / (projected_points_count[..., None] + 1e-10) - - is_outlier_pixel = ( - jax.random.uniform(key, non_registration_probability.shape) - < non_registration_probability - ) - variances = jnp.array( - [ - args["color_variance"], - args["color_variance"], - args["color_variance"], - args["depth_variance"], - ] - ) - latent_image_noised = genjax.laplace.sample(key, latent_image_mean, variances) - latent_image_uniform = jax.random.uniform(key, latent_image_mean.shape) * jnp.array( - [1.0, 1.0, 1.0, 5.0] - ) - return ( - latent_image_noised * ~is_outlier_pixel[..., None] - + latent_image_uniform * is_outlier_pixel[..., None] - ) - - -@jax.jit -def likelihood_func(observed_rgbd, args): - transformed_points = args["pose"].apply(args["vertices"]) - pixels = jnp.rint( - b3d.xyz_to_pixel_coordinates( - transformed_points, args["fx"], args["fy"], args["cx"], args["cy"] - ) - ).astype(jnp.int32) - - latent_image_sum = jnp.zeros( - (args["image_height"].const, args["image_width"].const, 4) - ) - latent_image_sum = latent_image_sum.at[pixels[..., 0], pixels[..., 1], :3].add( - args["colors"] * (1 - args["color_outlier_probability"])[:, None] - ) - latent_image_sum = latent_image_sum.at[pixels[..., 0], pixels[..., 1], 3].add( - transformed_points[..., 2] * (1 - args["depth_outlier_probability"]) - ) - - projected_points_count = jnp.zeros( - (args["image_height"].const, args["image_width"].const) - ) - projected_points_count = projected_points_count.at[ - pixels[..., 0], pixels[..., 1] - ].add(1) - - non_registration_probability = jnp.ones( - (args["image_height"].const, args["image_width"].const) - ) - non_registration_probability = non_registration_probability.at[ - pixels[..., 0], pixels[..., 1] - ].multiply(args["color_outlier_probability"]) - - latent_image_mean = latent_image_sum / (projected_points_count[..., None] + 1e-10) - - variances = jnp.array( - [ - args["color_variance"], - args["color_variance"], - args["color_variance"], - args["depth_variance"], - ] - ) - - # pixel_probability = jax.scipy.stats.laplace.logpdf( - # observed_rgbd, latent_image_mean, variances - # ) + jnp.log(1 - non_registration_probability)[...,None] - - pixel_probability = jnp.logaddexp( - jax.scipy.stats.laplace.logpdf(observed_rgbd, latent_image_mean, variances) - + jnp.log(1 - non_registration_probability)[..., None], - (jnp.log(non_registration_probability) + jnp.log(1 / 1.0**3))[..., None] - * jnp.ones_like(observed_rgbd), - ) - - return { - "score": pixel_probability.sum(), - "scores": pixel_probability, - "latent_rgbd": latent_image_mean, - "transformed_points": transformed_points, - "observed_rgbd_masked": observed_rgbd[pixels[..., 0], pixels[..., 1]], - } - - -aggregate_mean_image_kerenel_likelihood_func_and_sample_func = ( - likelihood_func, - sample_func, -) diff --git a/src/b3d/chisight/dynamic_object_model/likelihoods/kfold_image_kernel.py b/src/b3d/chisight/dynamic_object_model/likelihoods/kfold_image_kernel.py deleted file mode 100644 index f874e70b..00000000 --- a/src/b3d/chisight/dynamic_object_model/likelihoods/kfold_image_kernel.py +++ /dev/null @@ -1,429 +0,0 @@ -import genjax -import jax -import jax.numpy as jnp -from genjax import Pytree -from tensorflow_probability.substrates import jax as tfp - -import b3d -from b3d.chisight.dense.likelihoods.other_likelihoods import ( - ImageDistFromPixelDist, -) - - -def raycast_to_image_nondeterministic(key, intrinsics, vertices_in_camera_frame, K): - """ - Returns an array of shape (H, W, K) containing K point indices, or -1 to indicate no point was registered. - """ - N_pts = vertices_in_camera_frame.shape[0] - key1, key2 = jax.random.split(key, 2) - - projected_pixel_coordinates = jnp.rint( - b3d.xyz_to_pixel_coordinates( - vertices_in_camera_frame, - intrinsics["fx"], - intrinsics["fy"], - intrinsics["cx"], - intrinsics["cy"], - ) - - 0.5 - ).astype(jnp.int32) - permutation = jax.random.permutation(key1, N_pts) - shuffled_pixel_coordinates = projected_pixel_coordinates[permutation] - # shuffled_pixel_coordinates = projected_pixel_coordinates # = jax.random.permutation(key, projected_pixel_coordinates) - - random_indices = jax.random.randint( - key2, (N_pts,), 0, K - ) # (N_pts,) array of random indices from 0 to K-1 - registered_pixel_indices = -jnp.ones( - (intrinsics["height"], intrinsics["width"], K), dtype=int - ) - registered_pixel_indices = registered_pixel_indices.at[ - shuffled_pixel_coordinates[:, 0], - shuffled_pixel_coordinates[:, 1], - random_indices, - ].set(permutation) # jnp.arange(N_pts)) - - return registered_pixel_indices - - -@Pytree.dataclass -class TruncatedLaplace(genjax.ExactDensity): - """ - This is a distribution on the interval (low, high). - The generative process is: - 1. Sample x ~ laplace(loc, scale). - 2. If x < low, sample y ~ uniform(low, low + uniform_window_size) and return y. - 3. If x > high, sample y ~ uniform(high - uniform_window_size, high) and return y. - 4. Otherwise, return x. - - Args: - - loc: float - - scale: float - - low: float - - high: float - - uniform_window_size: float - - Support: - - x in (low, high) [a float] - """ - - def sample(self, key, loc, scale, low, high, uniform_window_size): - assert low < high - assert low + uniform_window_size < high - uniform_window_size - k1, k2 = jax.random.split(key, 2) - x = tfp.distributions.Laplace(loc, scale).sample(seed=k1) - u = jax.random.uniform(k2, ()) * uniform_window_size - return jnp.where( - x > high, high - uniform_window_size + u, jnp.where(x < low, low + u, x) - ) - - def logpdf(self, obs, loc, scale, low, high, uniform_window_size): - assert low < high - assert low + uniform_window_size < high - uniform_window_size - laplace_logpdf = tfp.distributions.Laplace(loc, scale).log_prob(obs) - laplace_logp_below_low = tfp.distributions.Laplace(loc, scale).log_cdf(low) - laplace_logp_above_high = tfp.distributions.Laplace( - loc, scale - ).log_survival_function(high) - log_window_size = jnp.log(uniform_window_size) - - return jnp.where( - jnp.logical_and( - low + uniform_window_size < obs, obs < high - uniform_window_size - ), - laplace_logpdf, - jnp.where( - obs < low + uniform_window_size, - jnp.logaddexp(laplace_logp_below_low - log_window_size, laplace_logpdf), - jnp.logaddexp( - laplace_logp_above_high - log_window_size, laplace_logpdf - ), - ), - ) - - -truncated_laplace = TruncatedLaplace() - - -_FIXED_COLOR_UNIFORM_WINDOW = 1 / 255 -_FIXED_DEPTH_UNIFORM_WINDOW = 0.01 - - -@Pytree.dataclass -class TruncatedColorLaplace(genjax.ExactDensity): - """ - Args: - - loc: (3,) array (loc for R, G, B channels) - - shared_scale: float (scale, shared across R, G, B channels) - - uniform_window_size: float [optional; defaults to 1/255] - - Support: - - rgb in [0, 1]^3 [a 3D array] - """ - - def sample( - self, key, loc, shared_scale, uniform_window_size=_FIXED_COLOR_UNIFORM_WINDOW - ): - return jax.vmap( - lambda k, lc: truncated_laplace.sample( - k, lc, shared_scale, 0.0, 1.0, uniform_window_size - ), - in_axes=(0, 0), - )(jax.random.split(key, loc.shape[0]), loc) - - def logpdf( - self, obs, loc, shared_scale, uniform_window_size=_FIXED_COLOR_UNIFORM_WINDOW - ): - return jax.vmap( - lambda o, lc: truncated_laplace.logpdf( - o, lc, shared_scale, 0.0, 1.0, uniform_window_size - ), - in_axes=(0, 0), - )(obs, loc).sum() - - -truncated_color_laplace = TruncatedColorLaplace() - - -def _access(arr, idx): - return jax.lax.dynamic_index_in_dim(arr, idx, axis=0, keepdims=False) - - -@Pytree.dataclass -class PixelDistribution(genjax.ExactDensity): - """ - Distribution over the color observed at a pixel of an RGBD image, - given a set of points that may be registered at the pixel. - Each of the N points has an associated color_outlier_prob, - depth_outlier_prob, and RGBD value. - There is a global color_scale and depth_scale. - An array `registered_point_indices` of shape (K,) - is provided giving the indices of all the points registered at this pixel; - the value -1 indicates that no point is registered at this slot of the - `registered_point_indices` array. - - Args: - registered_point_indices: (K,) - all_rgbds: (N, 4) - color_outlier_probs: (N,) - depth_outlier_probs: (N,) - color_scale: float - depth_scale: float - near: float - far: float - - Support: - - `rgbd` in [0, 1]^3 x [near, far] [a 4D array] - - K is the max number of points registered at a pixel, and - N is the number of points in the scene. - Indices in registered_point_indices are in the range [-1, N-1]; - -1 indicates that no point is registered in this slot. - - The generative process is: - 1. If there are no registered points, sample uniformly from the color and depth ranges. - 2. Otherwise, sample an index idx from registered_point_indices s.t. idx > -1. - 3. Get the rgbd, color_outlier_prob, and depth_outlier_prob for this index. - 4. Sample is_depth_outlier ~ Bernoulli(depth_outlier_prob). - 5. Sample is_color_outlier ~ Bernoulli(color_outlier_prob). - 6. If is_depth_outlier, sample depth uniformly from [near, far]. - 7. Otherwise, sample depth from a truncated Laplace distribution centered at all_rgbds[idx, 3]. - 8. If is_color_outlier, sample color uniformly from [0, 1]^3. - 9. Otherwise, sample color from a truncated Laplace distribution centered at all_rgbds[idx, :3]. - - The generative process for the truncated Laplace distribuitons - sample from a Laplace, and if the sample is outside the range [low, high] - (which is either [near, far] for depth or [0, 1] for color), the sample is replaced with a uniform sample - from the range [low, low + uniform_window_size] or [high - uniform_window_size, high]. - The value `uniform_window_size` is currently fixed at 0.01 for depth and 1/255 for color. - """ - - def sample( - self, - key, - registered_point_indices, - all_rgbds, - color_outlier_probs, - depth_outlier_probs, - color_scale, - depth_scale, - near, - far, - ): - k1, k2, k3, k4, k5, k6, k7 = jax.random.split(key, 7) - n_registered_points = jnp.sum(registered_point_indices != -1) - idxprobs = jnp.where( - registered_point_indices >= 0, 1.0 / n_registered_points, 0.0 - ) - idx = genjax.categorical.sample(k1, jnp.log(idxprobs)) - depth_outlier_prob = jnp.where( - n_registered_points == 0, - 1.0, - _access(depth_outlier_probs, _access(registered_point_indices, idx)), - ) - color_outlier_prob = jnp.where( - n_registered_points == 0, - 1.0, - _access(color_outlier_probs, _access(registered_point_indices, idx)), - ) - uniform_depth_sample = jax.random.uniform(k2, (), minval=near, maxval=far) - laplace_depth_sample = truncated_laplace.sample( - k3, - _access(all_rgbds, _access(registered_point_indices, idx))[3], - depth_scale, - near, - far, - _FIXED_DEPTH_UNIFORM_WINDOW, - ) - uniform_rgb_sample = jax.random.uniform(k4, (3,), minval=0.0, maxval=1.0) - laplace_rgb_sample = truncated_color_laplace.sample( - k5, - _access(all_rgbds, _access(registered_point_indices, idx))[:3], - color_scale, - ) - depth_is_outlier = jax.random.bernoulli(k6, depth_outlier_prob) - color_is_outlier = jax.random.bernoulli(k7, color_outlier_prob) - depth_sample = jnp.where( - depth_is_outlier, uniform_depth_sample, laplace_depth_sample - ) - rgb_sample = jnp.where(color_is_outlier, uniform_rgb_sample, laplace_rgb_sample) - return jnp.concatenate([rgb_sample, jnp.array([depth_sample])]) - - def logpdf( - self, - obs, - registered_point_indices, - all_rgbds, - color_outlier_probs, - depth_outlier_probs, - color_scale, - depth_scale, - near, - far, - ): - uniform_depth_logpdf = -jnp.log(far - near) - uniform_rgb_logpdf = -jnp.log(1.0**3) - - def get_logpdf_given_idx(idx): - depth_outlier_prob = _access( - depth_outlier_probs, _access(registered_point_indices, idx) - ) - color_outlier_prob = _access( - color_outlier_probs, _access(registered_point_indices, idx) - ) - laplace_depth_logpdf = truncated_laplace.logpdf( - obs[3], - _access(all_rgbds, _access(registered_point_indices, idx))[3], - depth_scale, - near, - far, - _FIXED_DEPTH_UNIFORM_WINDOW, - ) - laplace_rgb_logpdf = truncated_color_laplace.logpdf( - obs[:3], - _access(all_rgbds, _access(registered_point_indices, idx))[:3], - color_scale, - ) - log_p_depth = jnp.logaddexp( - jnp.log(depth_outlier_prob) + uniform_depth_logpdf, - jnp.log(1 - depth_outlier_prob) + laplace_depth_logpdf, - ) - log_p_rgb = jnp.logaddexp( - jnp.log(color_outlier_prob) + uniform_rgb_logpdf, - jnp.log(1 - color_outlier_prob) + laplace_rgb_logpdf, - ) - return log_p_depth + log_p_rgb - - n_registered_points = jnp.sum(registered_point_indices != -1) - logpdfs_given_each_idx = jax.vmap(get_logpdf_given_idx)( - jnp.arange(registered_point_indices.shape[0]) - ) - logpdf_of_choosing_each_idx = jnp.where( - registered_point_indices < 0, -jnp.inf, -jnp.log(n_registered_points) - ) - assert len((logpdf_of_choosing_each_idx + logpdfs_given_each_idx).shape) == 1 - return jnp.where( - n_registered_points > 0, - jax.scipy.special.logsumexp( - logpdf_of_choosing_each_idx + logpdfs_given_each_idx - ), - uniform_depth_logpdf + uniform_rgb_logpdf, - ) - - -pixel_distribution = PixelDistribution() - -mapped_pixel_distribution = ImageDistFromPixelDist( - # The only mapped arg is the first one; the others are shared across pixels. - pixel_distribution, - (True, False, False, False, False, False, False, False), -) -# ^ This distribution accepts (height, width, registered_pixel_indices, *args), -# where `registered_pixel_indices` has shape (height, width, K), -# and `args` is the list of all args to PixelDistribution after `registered_pixel_indices`. - - -@Pytree.dataclass -class KfoldMixturePointsToImageKernel(genjax.Distribution): - """ - KfoldMixturePointsToImageKernel(K) is a kernel from a set of points to an image. - Each pixel in the image will register a random subset of up to K points from the - subset of the provided points which project directly to that pixel. - - Given those up to K registered points per pixel, each pixel is independently - sampled from `PixelDistribution` (see docstring for `PixelDistribution` for details). - - Constructor args: - - K: int - - Distribution args: - - intrinsics: dict with keys "height", "width", "fx", "fy", "cx", "cy", "near", "far" - - vertices_in_camera_frame: (N, 3) array of points in camera frame - - point_rgbds: (N, 4) array of RGBD values for each point - - point_color_outlier_probs: (N,) array of color outlier probabilities for each point - - point_depth_outlier_probs: (N,) array of depth outlier probabilities for each point - - color_scale: float (shared) - - depth_scale: float (shared) - - Distribution support: - - image: (height, width, 4) array of RGBD values (RGB values in [0, 1]^3; D values in [near, far]) - """ - - K: int - - def __init__(self, K): - self.K = K - - def random_weighted( - self, - key, - intrinsics, - vertices_in_camera_frame, - point_rgbds, - point_color_outlier_probs, - point_depth_outlier_probs, - color_scale, - depth_scale, - ): - h, w = intrinsics["height"], intrinsics["width"] - raycasted_image = raycast_to_image_nondeterministic( - key, intrinsics, vertices_in_camera_frame, self.K - ) - value = mapped_pixel_distribution.sample( - key, - h, - w, - raycasted_image, - point_rgbds, - point_color_outlier_probs, - point_depth_outlier_probs, - color_scale, - depth_scale, - intrinsics["near"], - intrinsics["far"], - ) - logpdf_estimate = mapped_pixel_distribution.logpdf( - value, - h, - w, - raycasted_image, - point_rgbds, - point_color_outlier_probs, - point_depth_outlier_probs, - color_scale, - depth_scale, - intrinsics["near"], - intrinsics["far"], - ) - return value, logpdf_estimate - - def estimate_logpdf( - self, - key, - obs, - intrinsics, - vertices_in_camera_frame, - point_rgbds, - point_color_outlier_probs, - point_depth_outlier_probs, - color_scale, - depth_scale, - ): - h, w = intrinsics["height"], intrinsics["width"] - raycasted_image = raycast_to_image_nondeterministic( - key, intrinsics, vertices_in_camera_frame, self.K - ) - logpdf_estimate = mapped_pixel_distribution.logpdf( - obs, - h, - w, - raycasted_image, - point_rgbds, - point_color_outlier_probs, - point_depth_outlier_probs, - color_scale, - depth_scale, - intrinsics["near"], - intrinsics["far"], - ) - return logpdf_estimate diff --git a/src/b3d/chisight/dynamic_object_model/likelihoods/project_no_occlusions_kernel.py b/src/b3d/chisight/dynamic_object_model/likelihoods/project_no_occlusions_kernel.py deleted file mode 100644 index 24bb8003..00000000 --- a/src/b3d/chisight/dynamic_object_model/likelihoods/project_no_occlusions_kernel.py +++ /dev/null @@ -1,78 +0,0 @@ -import jax -import jax.numpy as jnp - -import b3d - - -@jax.jit -def likelihood_func(observed_rgbd, args): - transformed_points = args["pose"].apply(args["vertices"]) - - projected_pixel_coordinates = jnp.rint( - b3d.xyz_to_pixel_coordinates( - transformed_points, args["fx"], args["fy"], args["cx"], args["cy"] - ) - ).astype(jnp.int32) - - observed_rgbd_masked = observed_rgbd[ - projected_pixel_coordinates[..., 0], projected_pixel_coordinates[..., 1] - ] - - color_outlier_probabilities = args["color_outlier_probabilities"] - depth_outlier_probabilities = args["depth_outlier_probabilities"] - - color_probability = jnp.logaddexp( - jax.scipy.stats.laplace.logpdf( - observed_rgbd_masked[..., :3], args["colors"], args["color_variance"] - ).sum(axis=-1) - + jnp.log(1 - color_outlier_probabilities), - jnp.log(color_outlier_probabilities) - + jnp.log(1 / 1.0**3), # <- log(1) == 0 tho - ) - depth_probability = jnp.logaddexp( - jax.scipy.stats.laplace.logpdf( - observed_rgbd_masked[..., 3], - transformed_points[..., 2], - args["depth_variance"], - ) - + jnp.log(1 - depth_outlier_probabilities), - jnp.log(depth_outlier_probabilities) + jnp.log(1 / 1.0), - ) - - scores = color_probability + depth_probability - - # Visualization - latent_rgbd = jnp.zeros_like(observed_rgbd) - latent_rgbd = latent_rgbd.at[ - projected_pixel_coordinates[..., 0], projected_pixel_coordinates[..., 1], :3 - ].set(args["colors"]) - latent_rgbd = latent_rgbd.at[ - projected_pixel_coordinates[..., 0], projected_pixel_coordinates[..., 1], 3 - ].set(transformed_points[..., 2]) - - return { - "score": scores.sum(), - "scores": scores, - "transformed_points": transformed_points, - "observed_rgbd_masked": observed_rgbd_masked, - "color_probability": color_probability, - "depth_probability": depth_probability, - "latent_rgbd": latent_rgbd, - } - - -@jax.jit -def sample_func(key, likelihood_args): - return jnp.zeros( - ( - likelihood_args["image_height"].const, - likelihood_args["image_width"].const, - 4, - ) - ) - - -project_no_occlusions_kernel_likelihood_func_and_sample_func = ( - likelihood_func, - sample_func, -) diff --git a/src/b3d/chisight/gen3d/README.md b/src/b3d/chisight/gen3d/README.md new file mode 100644 index 00000000..e77e0b0e --- /dev/null +++ b/src/b3d/chisight/gen3d/README.md @@ -0,0 +1,3 @@ +# Gen3D + +You can run the `run_ycbv_evaluation.py` file as a script to evaluate Gen3D against the YCB-Video dataset. diff --git a/src/b3d/chisight/gen3d/__init__.py b/src/b3d/chisight/gen3d/__init__.py new file mode 100644 index 00000000..d16d177d --- /dev/null +++ b/src/b3d/chisight/gen3d/__init__.py @@ -0,0 +1,6 @@ +from . import dataloading as dataloading +from . import hyperparams as hyperparams +from . import inference as inference +from . import metrics as metrics +from . import model as model +from . import settings as settings diff --git a/src/b3d/chisight/gen3d/block_moves.py b/src/b3d/chisight/gen3d/block_moves.py deleted file mode 100644 index e69de29b..00000000 diff --git a/src/b3d/chisight/gen3d/dataloading.py b/src/b3d/chisight/gen3d/dataloading.py new file mode 100644 index 00000000..54a1a0ff --- /dev/null +++ b/src/b3d/chisight/gen3d/dataloading.py @@ -0,0 +1,197 @@ +import io +from functools import reduce + +import h5py +import jax +import jax.numpy as jnp +import numpy as np +from genjax import Pytree +from PIL import Image + +import b3d + + +def load_trial(hdf5_file_path, FINAL_T): + depth_arr = [] + image_arr = [] + seg_arr = [] + # ( + # base_id, + # attachment_id, + # use_attachment, + # use_base, + # use_cap, + # cap_id, + # ) = None, None, None, None, None, None + # composite_mapping = {} + with h5py.File(hdf5_file_path, "r") as f: + # extract depth info + for frame in f["frames"].keys(): + if int(frame) >= FINAL_T: + break + depth = jnp.array(f["frames"][frame]["images"]["_depth_cam0"]) + depth_arr.append(depth) + image = jnp.array( + Image.open(io.BytesIO(f["frames"][frame]["images"]["_img_cam0"][:])) + ) + image_arr.append(image) + im_seg = jnp.array( + Image.open(io.BytesIO(f["frames"][frame]["images"]["_id_cam0"][:])) + ) + seg_arr.append(im_seg) + depth_arr = jnp.asarray(depth_arr) + image_arr = jnp.asarray(image_arr) / 255 + seg_arr = jnp.asarray(seg_arr) + + # extract camera info + camera_matrix = jnp.array( + f["frames"]["0000"]["camera_matrices"]["camera_matrix_cam0"] + ).reshape((4, 4)) + + # extract object info + object_ids = jnp.array(f["static"]["object_ids"]) + object_segmentation_colors = jnp.array( + f["static"]["object_segmentation_colors"] + ) + assert len(object_ids) == len(object_segmentation_colors) + + background_areas = np.zeros( + (image_arr.shape[0], image_arr.shape[1], image_arr.shape[2]) + ) + + distractors = ( + np.array(f["static"]["distractors"]) + if np.array(f["static"]["distractors"]).size != 0 + else [] + ) + occluders = ( + np.array(f["static"]["occluders"]) + if np.array(f["static"]["occluders"]).size != 0 + else [] + ) + distractors_occluders = np.concatenate([distractors, occluders]) + if len(distractors_occluders): + background_areas = jnp.asarray( + [ + get_mask_area( + seg, object_segmentation_colors[-len(distractors_occluders) :] + ) + for seg in seg_arr + ] + ) + object_ids = object_ids[: -len(distractors_occluders)] + object_segmentation_colors = object_segmentation_colors[ + : -len(distractors_occluders) + ] + + # if "use_base" in np.array(f["static"]): + # use_base = np.array(f["static"]["use_base"]) + # if use_base: + # base_id = np.array(f["static"]["base_id"]) + # assert base_id.size == 1 + # base_id = base_id.item() + # composite_mapping[f"{base_id}_0"] = base_id + # if "use_attachment" in np.array(f["static"]): + # use_attachment = np.array(f["static"]["use_attachment"]) + # if use_attachment: + # attachment_id = np.array(f["static"]["attachment_id"]) + # assert attachment_id.size == 1 + # attachment_id = attachment_id.item() + # composite_mapping[f"{base_id}_1"] = attachment_id + # if "use_cap" in np.array(f["static"]): + # use_cap = np.array(f["static"]["use_cap"]) + # if use_cap: + # cap_id = attachment_id + 1 + # composite_mapping[f"{base_id}_1"] = cap_id + + # reversed_composite_mapping = dict( + # [(value, feature) for feature, value in composite_mapping.items()] + # ) + rgbds = jnp.concatenate( + [image_arr, jnp.reshape(depth_arr, depth_arr.shape + (1,))], axis=-1 + ) + + R = camera_matrix[:3, :3] + T = camera_matrix[0:3, 3] + a = jnp.array([-R[0, :], -R[1, :], -R[2, :]]) + b = jnp.array(T) + camera_position_from_matrix = jnp.linalg.solve(a, b) + camera_rotation_from_matrix = -jnp.transpose(R) + camera_pose = b3d.Pose( + camera_position_from_matrix, + b3d.Rot.from_matrix(camera_rotation_from_matrix).as_quat(), + ) + return ( + rgbds, + seg_arr, + sorted(object_ids), + object_segmentation_colors, + background_areas, + camera_pose, + # composite_mapping, + # reversed_composite_mapping, + ) + + +def get_mask_area(seg_img, colors): + arrs = [] + for color in colors: + arr = seg_img == color + arr = arr.min(-1).astype("float32") + arr = arr.reshape((arr.shape[-1], arr.shape[-1])).astype(bool) + arrs.append(arr) + return reduce(jnp.logical_or, arrs) + + +def resize_rgbds_and_get_masks(rgbds, seg_arr, background_areas, im_height, im_width): + rgbds = jax.image.resize( + rgbds, + (rgbds.shape[0], im_height, im_width, *rgbds.shape[3:]), + method="linear", + ) + background_areas = jax.image.resize( + background_areas, + (background_areas.shape[0], im_height, im_width), + method="linear", + ).astype(bool) + im_segs = jax.image.resize( + seg_arr, + (seg_arr.shape[0], im_height, im_width, *seg_arr.shape[3:]), + method="linear", + ) + all_areas = [] + for im_seg in im_segs: + all_area = jnp.any(im_seg != jnp.array([0, 0, 0]), axis=-1) + all_areas.append(all_area) + return rgbds, all_areas, background_areas + + +def get_initial_state( + pred_file, object_ids, object_segmentation_colors, meshes, seg, rgbd, hyperparams +): + pred = pred_file["scene"][0]["objects"] + + initial_state = {} + hyperparams["meshes"] = {} + for i, (o_id, color) in enumerate(zip(object_ids, object_segmentation_colors)): + area = get_mask_area(seg, [color]) + object_colors = rgbd[..., 0:3][area] + mean_object_colors = jnp.mean(object_colors, axis=0) + assert not jnp.isnan(mean_object_colors).any() + + initial_state[f"object_pose_{o_id}"] = b3d.Pose( + jnp.array(pred[i]["location"][0]), + jnp.array(pred[i]["rotation"][0]), + ) + initial_state[f"object_scale_{o_id}_0"] = jnp.array(pred[i]["scale"][0]) + hyperparams["meshes"][int(o_id)] = [ + b3d.Mesh( + meshes[pred[i]["type"][0]].vertices, + meshes[pred[i]["type"][0]].faces, + jnp.ones(meshes[pred[i]["type"][0]].vertices.shape) + * mean_object_colors, + ) + ] + + hyperparams["object_ids"] = Pytree.const([o_id for o_id in object_ids]) + return initial_state, hyperparams diff --git a/src/b3d/chisight/gen3d/datawriting.py b/src/b3d/chisight/gen3d/datawriting.py new file mode 100644 index 00000000..966839f7 --- /dev/null +++ b/src/b3d/chisight/gen3d/datawriting.py @@ -0,0 +1,389 @@ +import json +import os +from copy import deepcopy + +import numpy as np +import trimesh +from scipy.spatial.transform import Rotation + +import b3d + +NUM_SAMPLE_FROM_POSTERIOR = 20 +SMOOTHING_WINDOW_SIZE = 3 +FPS = 100 +STATIC_POSITION_THRESHHOLD = 0.007 +STATIC_ROTATION_THRESHHOLD = 0.001 + + +def mkdir(path): + if not os.path.isdir(path): + os.makedirs(path) + + +def find_missing_values(nums): + full_range = set(range(min(nums), max(nums) + 1)) + missing_values = sorted(list(full_range - set(nums))) + return missing_values + + +def compute_linear_velocity( + mesh, + scale, + object_pose_last_frame, + object_pose_window_frame, + dt, +): + def compute_center_of_mass(mesh, object_pose): + mesh_transform = mesh.transform(object_pose) + mesh_transform_tri = trimesh.Trimesh( + mesh_transform.vertices, mesh_transform.faces + ) + center_of_mass = mesh_transform_tri.center_mass + return center_of_mass + + mesh = b3d.Mesh( + vertices=scale_mesh(mesh.vertices, scale), + faces=mesh.faces, + vertex_attributes=None, + ) + pos_now = compute_center_of_mass(mesh, object_pose_last_frame) + pos_last = compute_center_of_mass(mesh, object_pose_window_frame) + linear_vel = (pos_now - pos_last) / dt + return {"x": linear_vel[0], "y": linear_vel[1], "z": linear_vel[2]} + + +def compute_angular_velocity(q1, q2, dt): + """ + Compute angular velocity in radians per second from two quaternions. + + Parameters: + q1 (array-like): Quaternion at the earlier time [w, x, y, z]. + q2 (array-like): Quaternion at the later time [w, x, y, z]. + dt (float): Time difference between the two quaternions. + + Returns: + angular_velocity (numpy array): Angular velocity vector (radians per second). + """ + # Convert quaternions to scipy Rotation objects + rot1 = Rotation.from_quat(q1) + rot2 = Rotation.from_quat(q2) + + # Compute the relative rotation + relative_rotation = rot2 * rot1.inv() + + # Convert the relative rotation to angle-axis representation + angle = relative_rotation.magnitude() # Rotation angle in radians + axis = ( + relative_rotation.as_rotvec() / angle if angle != 0 else np.zeros(3) + ) # Rotation axis + + # Compute angular velocity + angular_velocity = (axis * angle) / dt + return { + "x": angular_velocity[0].astype(float).item(), + "y": angular_velocity[1].astype(float).item(), + "z": angular_velocity[2].astype(float).item(), + } + + +def scale_mesh(vertices, scale_factor): + vertices_copy = deepcopy(vertices) + vertices_copy[:, 0] *= scale_factor["x"] + vertices_copy[:, 1] *= scale_factor["y"] + vertices_copy[:, 2] *= scale_factor["z"] + return vertices_copy + + +# def get_object_id_from_composite_id(feature): +# if int(feature.split("_")[-2]) == base_id: +# o_id = composite_mapping["_".join(feature.split("_")[-2:])] +# else: +# o_id = feature.split("_")[-2] +# return o_id + +# def get_composite_id_from_object_id(feature): +# if feature in list(reversed_composite_mapping.keys()): +# o_id = reversed_composite_mapping[str(feature)] +# else: +# o_id = str(feature) + "_0" +# return o_id + +# def get_all_component_poses( +# best_mc_obj_cat_sample, +# pose_samples_from_posterior, +# composite_scales, +# reversed_composite_mapping, +# ): +# best_mc_obj_cat_sample[3][base_id] +# composite_ids = list(reversed_composite_mapping.keys())[1:] +# for composite_id in composite_ids: +# pose_samples_from_posterior[composite_id] = [[]] +# for i, base_pose in enumerate(pose_samples_from_posterior[base_id]): +# assert len(pose_samples_from_posterior[base_id]) == len( +# composite_scales[base_id] +# ) +# best_base_pose = base_pose[-1] +# top = ( +# best_mc_obj_cat_sample[3][base_id][0].vertices[:, 1].max() +# * composite_scales[base_id][i]["y"] +# ) +# for j, composite_id in enumerate(composite_ids): +# pose = b3d.Pose.from_translation(jnp.array([0.0, top, 0.0])) +# pose_samples_from_posterior[composite_id][0].append(base_pose[0] @ pose) +# pose_samples_from_posterior[composite_id].append(best_base_pose @ pose) +# top += ( +# best_mc_obj_cat_sample[3][base_id][j + 1].vertices[:, 1].max() +# * composite_scales[composite_id][i]["y"] +# ) + + +def sample_from_posterior(log_probs_categories, option="rank"): + log_probs = [item[0] for item in log_probs_categories] + categories = [item[1] for item in log_probs_categories] + num_categories = len(log_probs) + + if option == "uniform": + + def draw_single_sample(): + index = np.random.choice(num_categories) + return categories[index] + elif option == "veridical": + + def draw_single_sample(): + # see this: https://stackoverflow.com/questions/58339083/how-to-sample-from-a-log-probability-distribution + gumbels = np.random.gumbel(size=num_categories) + index = np.argmax(log_probs + gumbels) + return categories[index] + elif option == "rank": + + def draw_single_sample(): + weights = np.array([1 / (n + 1) for n in range(num_categories)]) + weights_norm = weights / weights.sum() + index = np.random.choice(num_categories, p=weights_norm) + return categories[index] + elif option == "mix": + + def draw_single_sample(): + t = 0.5 + t * np.array(log_probs) + (1 - t) * (1 / num_categories) + return + else: + raise NotImplementedError + + samples = [] + np.random.seed(42) + for _ in range(NUM_SAMPLE_FROM_POSTERIOR): + sample = draw_single_sample() + samples.append(sample) + return samples + + +def get_posterior_poses_for_frame(frame, posterior_across_frames): + pose_samples_from_posterior = {} + for o_id, poses in posterior_across_frames["pose"][frame].items(): + best_pose = poses[1] + pose_samples_from_posterior[o_id] = [ + [pose for pose in sample_from_posterior(poses[0])], + best_pose, + ] + # if o_id == base_id: + # get_all_component_poses( + # best_mc_obj_cat_sample, + # pose_samples_from_posterior, + # json_file["scale"], + # {value: feature for feature, value in composite_mapping.items()}, + # ) + return pose_samples_from_posterior + + +def write_json( + pred_file, + hyperparams, + posterior_across_frames, + save_path, + scenario, + trial_name, + debug=False, +): + pred = pred_file["scene"][0]["objects"] + + # prepare the json file to write + json_file = {} + json_file["model"] = {} + json_file["scale"] = {} + + for i, o_id in enumerate(hyperparams["object_ids"].unwrap()): + json_file["model"][int(o_id)] = [ + pred[i]["type"][0] for _ in range(NUM_SAMPLE_FROM_POSTERIOR) + ] + json_file["scale"][int(o_id)] = [ + { + "x": pred[i]["scale"][0][0], + "y": pred[i]["scale"][0][1], + "z": pred[i]["scale"][0][2], + } + for _ in range(NUM_SAMPLE_FROM_POSTERIOR) + ] + + pose_samples_from_posterior_last_frame = get_posterior_poses_for_frame( + -1, + posterior_across_frames, + ) + pose_samples_from_posterior_window_frame = get_posterior_poses_for_frame( + -(SMOOTHING_WINDOW_SIZE + 1), + posterior_across_frames, + ) + assert len(pose_samples_from_posterior_last_frame) == len( + pose_samples_from_posterior_window_frame + ) + + position_dict = dict( + [ + ( + int(o_id), + [ + { + "x": pose._position[0].astype(float).item(), + "y": pose._position[1].astype(float).item(), + "z": pose._position[2].astype(float).item(), + } + for pose in poses[0] + ], + ) + for o_id, poses in pose_samples_from_posterior_last_frame.items() + ] + ) + rotation_dict = dict( + [ + ( + int(o_id), + [ + { + "x": pose._quaternion[0].astype(float).item(), + "y": pose._quaternion[1].astype(float).item(), + "z": pose._quaternion[2].astype(float).item(), + "w": pose._quaternion[3].astype(float).item(), + } + for pose in poses[0] + ], + ) + for o_id, poses in pose_samples_from_posterior_last_frame.items() + ] + ) + + linear_velocity_dict = {} + linear_velocity_dict_optim = {} + for o_id in pose_samples_from_posterior_last_frame.keys(): + if np.allclose( + pose_samples_from_posterior_last_frame[o_id][-1]._position, + pose_samples_from_posterior_window_frame[o_id][-1]._position, + atol=STATIC_POSITION_THRESHHOLD * SMOOTHING_WINDOW_SIZE, + ): + linear_velocity_dict[int(o_id)] = [ + {"x": 0, "y": 0, "z": 0} for _ in range(NUM_SAMPLE_FROM_POSTERIOR) + ] + linear_velocity_dict_optim[int(o_id)] = [ + {"x": 0, "y": 0, "z": 0} for _ in range(NUM_SAMPLE_FROM_POSTERIOR) + ] + else: + linear_velocity_dict[int(o_id)] = [ + compute_linear_velocity( + hyperparams["meshes"][int(o_id)][0], + json_file["scale"][o_id][i], + pose_samples_from_posterior_last_frame[o_id][0][i], + pose_samples_from_posterior_window_frame[o_id][ + -1 + ], # using optim pose for window frame + SMOOTHING_WINDOW_SIZE / FPS, + ) + for i in range(NUM_SAMPLE_FROM_POSTERIOR) + ] + linear_velocity_dict_optim[int(o_id)] = [ + compute_linear_velocity( + hyperparams["meshes"][int(o_id)][0], + json_file["scale"][o_id][i], + pose_samples_from_posterior_last_frame[o_id][-1], + pose_samples_from_posterior_window_frame[o_id][ + -1 + ], # using optim pose for window frame + SMOOTHING_WINDOW_SIZE / FPS, + ) + for i in range(NUM_SAMPLE_FROM_POSTERIOR) + ] + + angular_velocity_dict = {} + angular_velocity_dict_optim = {} + for o_id in pose_samples_from_posterior_last_frame.keys(): + if np.allclose( + pose_samples_from_posterior_last_frame[o_id][-1]._quaternion, + pose_samples_from_posterior_window_frame[o_id][-1]._quaternion, + atol=STATIC_ROTATION_THRESHHOLD * SMOOTHING_WINDOW_SIZE, + ): + angular_velocity_dict[int(o_id)] = [ + {"x": 0, "y": 0, "z": 0} for _ in range(NUM_SAMPLE_FROM_POSTERIOR) + ] + angular_velocity_dict_optim[int(o_id)] = [ + {"x": 0, "y": 0, "z": 0} for _ in range(NUM_SAMPLE_FROM_POSTERIOR) + ] + else: + angular_velocity_dict[int(o_id)] = [ + compute_angular_velocity( + pose_samples_from_posterior_window_frame[o_id][ + -1 + ]._quaternion, # using optim pose for window frame + pose_samples_from_posterior_last_frame[o_id][0][i]._quaternion, + SMOOTHING_WINDOW_SIZE / FPS, + ) + for i in range(NUM_SAMPLE_FROM_POSTERIOR) + ] + angular_velocity_dict_optim[int(o_id)] = [ + compute_angular_velocity( + pose_samples_from_posterior_window_frame[o_id][ + -1 + ]._quaternion, # using optim pose for window frame + pose_samples_from_posterior_last_frame[o_id][-1]._quaternion, + SMOOTHING_WINDOW_SIZE / FPS, + ) + for i in range(NUM_SAMPLE_FROM_POSTERIOR) + ] + json_file["position"] = position_dict + json_file["rotation"] = rotation_dict + json_file["velocity"] = linear_velocity_dict + json_file["angular_velocity"] = angular_velocity_dict + + missing = find_missing_values( + np.array([int(item) for item in hyperparams["object_ids"].unwrap()]) + ) + for feature, val in json_file.items(): + for o_id in missing: + json_file[feature][o_id] = val[int(hyperparams["object_ids"].unwrap()[0])] + + json_file_optim = deepcopy(json_file) + json_file_optim["velocity"] = linear_velocity_dict_optim + json_file_optim["angular_velocity"] = angular_velocity_dict_optim + + mkdir(f"{save_path}/{scenario}/") + with open(f"{save_path}/{scenario}/{trial_name}.json", "w") as f: + json.dump(json_file, f) + + mkdir(f"{save_path}/{scenario}_optim/") + with open(f"{save_path}/{scenario}_optim/{trial_name}.json", "w") as f: + json.dump(json_file_optim, f) + + if debug: + for frame_index, frame_info in enumerate(posterior_across_frames["pose"]): + for o_id, o_id_info in frame_info.items(): + posterior_across_frames["pose"][frame_index][o_id][1] = ( + o_id_info[1]._position.astype(float).tolist(), + o_id_info[1]._quaternion.astype(float).tolist(), + ) + for j, rank in enumerate(o_id_info[0]): + posterior_across_frames["pose"][frame_index][o_id][0][j] = ( + rank[0].astype(float).item(), + rank[1]._position.astype(float).tolist(), + rank[1]._quaternion.astype(float).tolist(), + ) + mkdir(f"{save_path}/{scenario}_verbose/") + with open(f"{save_path}/{scenario}_verbose/{trial_name}.json", "w") as f: + json.dump(posterior_across_frames, f) + return diff --git a/src/b3d/chisight/gen3d/hyperparams.py b/src/b3d/chisight/gen3d/hyperparams.py new file mode 100644 index 00000000..311c434f --- /dev/null +++ b/src/b3d/chisight/gen3d/hyperparams.py @@ -0,0 +1,13 @@ +from genjax import Pytree + + +@Pytree.dataclass +class InferenceHyperparams(Pytree): + n_poses: int = Pytree.static() + + pose_proposal_args: any = Pytree.static( + default_factory=(lambda: [(0.05, 1000.0), (0.02, 1500.0), (0.005, 2000.0)]) + # default_factory=(lambda: [(0.04, 1000.0)]) + ) + + include_q_scores_at_top_level: bool = True diff --git a/src/b3d/chisight/gen3d/image_kernel.py b/src/b3d/chisight/gen3d/image_kernel.py index e69de29b..cd947b25 100644 --- a/src/b3d/chisight/gen3d/image_kernel.py +++ b/src/b3d/chisight/gen3d/image_kernel.py @@ -0,0 +1,479 @@ +from abc import abstractmethod +from functools import cached_property +from typing import Mapping + +import genjax +import jax +import jax.numpy as jnp +from genjax import Pytree +from genjax.typing import FloatArray, IntArray, PRNGKey + +import b3d.utils +from b3d.chisight.gen3d.pixel_kernels.pixel_rgbd_kernels import ( + FullPixelRGBDDistribution, + is_unexplained, +) + +# using this in combination with mode="drop" in the .at[] +# methods can help filter out vertices that are not visible in the image +INVALID_IDX = jnp.iinfo(jnp.int32).min # -2147483648 + + +@Pytree.dataclass +class PixelsPointsAssociation(Pytree): + """A utility class to associate 3D points with their projected 2D pixel.""" + + projected_pixel_coordinates: IntArray # (num_vertices, 2) + image_height: int + image_width: int + + @classmethod + def from_hyperparams_and_pose(cls, hyperparams, pose_CO): + """`pose_CO` is the same thing as `pose` in the model.""" + vertices_O = hyperparams["vertices"] + vertices_C = pose_CO.apply(vertices_O) + return cls.from_points_and_intrinsics( + vertices_C, + hyperparams["intrinsics"], + ) + + @classmethod + def from_points_and_intrinsics( + cls, points: FloatArray, intrinsics: dict + ) -> "PixelsPointsAssociation": + """Create a PixelsPointsAssociation object from a set of 3D points and + the camera intrinsics. + + Args: + points (FloatArray): The points/vertices in 3D space (num_vertices, 3). + intrinsics (dict): Camera intrinsics. + image_height (int): Height of the image. + image_width (int): Width of the image. + """ + projected_coords = jnp.rint( + b3d.utils.xyz_to_pixel_coordinates( + points, + intrinsics["fx"], + intrinsics["fy"], + intrinsics["cx"], + intrinsics["cy"], + ) + - 0.5 + ) + + image_height, image_width = ( + intrinsics["image_height"].unwrap(), + intrinsics["image_width"].unwrap(), + ) + + # handle NaN before converting to int (otherwise NaN will be converted + # to 0) + projected_coords = jnp.nan_to_num(projected_coords, nan=INVALID_IDX) + + # handle the case where the projected coordinates are outside the image + projected_coords = jnp.where( + projected_coords > 0, projected_coords, INVALID_IDX + ) + projected_coords = jnp.where( + projected_coords < jnp.array([image_height, image_width]), + projected_coords, + INVALID_IDX, + ) + + return cls(projected_coords.astype(jnp.int32), image_height, image_width) + + def __len__(self) -> int: + return self.projected_pixel_coordinates.shape[0] + + def shape(self) -> tuple[int, int]: + return self.projected_pixel_coordinates.shape + + @property + def x(self) -> IntArray: + return self.projected_pixel_coordinates[:, 0] + + @property + def y(self) -> IntArray: + return self.projected_pixel_coordinates[:, 1] + + def get_pixel_attributes(self, point_attributes: FloatArray) -> FloatArray: + """Given a (num_vertices, attribute_length) array of point attributes, + return a (image_height, image_width, attribute_length) array of attributes. + Pixels that don't hit a vertex will have a value filled with -1. + """ + return point_attributes.at[self.pixel_to_point_idx].get( + mode="drop", fill_value=-1 + ) + + def get_point_rgbds(self, rgbd_image: FloatArray) -> FloatArray: + """ + Get a (num_vertices, 4) array of RGBD values for each vertex + by indexing into the given image. + Vertices that don't hit a pixel will have a value of (-1, -1, -1, -1). + """ + return rgbd_image.at[self.x, self.y].get(mode="drop", fill_value=-1.0) + + def get_point_depths(self, rgbd_image: FloatArray) -> FloatArray: + """ + Get a (num_vertices,) array of depth values for each vertex + by indexing into the given image, or -1 if the vertex doesn't hit a pixel. + """ + return self.get_point_rgbds(rgbd_image)[..., 3] + + def get_point_rgbs(self, rgbd: FloatArray) -> FloatArray: + """ + Get a (num_vertices, 3) array of RGB values for each vertex + by indexing into the given image, or [-1, -1, -1] if the vertex doesn't hit a pixel. + """ + return self.get_point_rgbds(rgbd)[..., :3] + + @cached_property + def num_point_per_pixel(self) -> IntArray: + """Return a 2D array of shape (image_height, image_width) where each + element is the number of points that project to that pixel. + """ + counts = jnp.zeros((self.image_height, self.image_width), dtype=jnp.int32) + counts = counts.at[self.x, self.y].add(1, mode="drop") + return counts + + @cached_property + def pixel_to_point_idx(self) -> IntArray: + """Return a 2D array of shape (image_height, image_width) where each + element is the index of the point that projects to that pixel (if any). + If none of the points project to that pixel, the value is set to INVALID_IDX. + + Warning: this implementaion does not handle race condition. That is, if + multiple points project to the same pixel, this method will randomly + return one of them (the non-determinism is subject to GPU parallelism). + """ + registered_pixel_idx = jnp.full( + (self.image_height, self.image_width), INVALID_IDX, dtype=jnp.int32 + ) + registered_pixel_idx = registered_pixel_idx.at[self.x, self.y].set( + jnp.arange(len(self)) + ) + return registered_pixel_idx + + def get_pixel_idx(self, point_idx: int) -> IntArray: + return self.projected_pixel_coordinates[point_idx] + + def get_pixels_with_multiple_points(self) -> tuple[IntArray, IntArray]: + """Return a tuple of (x_coords, y_coords) of pixels that have more than + one vertices associated with them. Note that this method is not JIT-compatible + because the return values are not of fixed shape. + """ + return jnp.nonzero(self.num_point_per_pixel > 1) + + def get_one_latent_point_idx(self, pixel_x: int, pixel_y: int) -> int: + """Return the index of one of the points that project to the given pixel. + If there are multiple points, this method will return one of them randomly + (the non-determinism is subject to GPU parallelism). + """ + return self.pixel_to_point_idx[pixel_x, pixel_y] + + +@jax.jit +def get_latent_and_observed_correspondences(state, hyperparams, observed_rgbd): + transformed_points = state["pose"].apply(hyperparams["vertices"]) + points_to_pixels = PixelsPointsAssociation.from_points_and_intrinsics( + transformed_points, hyperparams["intrinsics"] + ) + observed_rgbd_per_point = points_to_pixels.get_point_rgbds(observed_rgbd) + latent_rgbd_per_point = jnp.concatenate( + (state["colors"], transformed_points[..., 2, None]), axis=-1 + ) + return latent_rgbd_per_point, observed_rgbd_per_point + + +@jax.jit +def get_latent_rgb_image(state, hyperparams): + transformed_points = state["pose"].apply(hyperparams["vertices"]) + ppa = PixelsPointsAssociation.from_points_and_intrinsics( + transformed_points, hyperparams["intrinsics"] + ) + latent_rgb_image = jnp.clip(ppa.get_pixel_attributes(state["colors"]), 0.0, 1.0) + return latent_rgb_image + + +@Pytree.dataclass +class ImageKernel(genjax.ExactDensity): + """An abstract class that defines the common interface for image kernels, + which generates a new RGBD image from the current state, controlled by + the hyperparameters. + + The support of the distribution is [0, 1]^3 x [near, far]. + """ + + @abstractmethod + def sample(self, key: PRNGKey, state: Mapping, hyperparams: Mapping) -> FloatArray: + raise NotImplementedError + + @abstractmethod + def logpdf( + self, obseved_rgbd: FloatArray, state: Mapping, hyperparams: Mapping + ) -> FloatArray: + raise NotImplementedError + + def get_rgbd_vertex_kernel(self) -> FullPixelRGBDDistribution: + raise NotImplementedError + + +@Pytree.dataclass +class NoOcclusionPerVertexImageKernel(ImageKernel): + rgbd_vertex_kernel: FullPixelRGBDDistribution + + def sample(self, key: PRNGKey, state: Mapping, hyperparams: Mapping) -> FloatArray: + """Generate latent RGBD image by projecting the vertices directly to the image + plane, without checking for occlusions. + """ + + transformed_points = state["pose"].apply(hyperparams["vertices"]) + points_to_pixels = PixelsPointsAssociation.from_points_and_intrinsics( + transformed_points, + hyperparams["intrinsics"], + ) + vertex_kernel = self.get_rgbd_vertex_kernel() + + # assuming that at most one vertex hit the pixel, we can convert the + # per-vertex attributes into per-pixel attributes, then vmap the + # RGBD pixel kernel over the pixels to generate the image. + pixel_visibility_prob = points_to_pixels.get_pixel_attributes( + state["visibility_prob"] + ) + pixel_depth_nonreturn_prob = points_to_pixels.get_pixel_attributes( + state["depth_nonreturn_prob"] + ) + pixel_latent_rgb = points_to_pixels.get_pixel_attributes(state["colors"]) + pixel_latent_depth = points_to_pixels.get_pixel_attributes( + transformed_points[..., 2] + ) + pixel_latent_rgbd = jnp.concatenate( + [pixel_latent_rgb, pixel_latent_depth[..., None]], axis=-1 + ) + + keys = jax.random.split( + key, + ( + hyperparams["intrinsics"]["image_height"].unwrap(), + hyperparams["intrinsics"]["image_width"].unwrap(), + ), + ) + return jax.vmap( + jax.vmap( + vertex_kernel.sample, in_axes=(0, 0, None, None, 0, 0, None, None) + ), + in_axes=(0, 0, None, None, 0, 0, None, None), + )( + keys, + pixel_latent_rgbd, + state["color_scale"], + state["depth_scale"], + pixel_visibility_prob, + pixel_depth_nonreturn_prob, + hyperparams["intrinsics"], + hyperparams["unexplained_depth_nonreturn_prob"], + ) + + def logpdf( + self, observed_rgbd: FloatArray, state: Mapping, hyperparams: Mapping + ) -> FloatArray: + transformed_points = state["pose"].apply(hyperparams["vertices"]) + ppa = PixelsPointsAssociation.from_points_and_intrinsics( + transformed_points, hyperparams["intrinsics"] + ) + observed_rgbd_per_point = ppa.get_point_rgbds(observed_rgbd) + latent_rgbd_per_point = jnp.concatenate( + (state["colors"], transformed_points[..., 2, None]), axis=-1 + ) + + vertex_kernel = self.get_rgbd_vertex_kernel() + scores = jax.vmap( + vertex_kernel.logpdf, in_axes=(0, 0, None, None, 0, 0, None, None) + )( + observed_rgbd_per_point, + latent_rgbd_per_point, + state["color_scale"], + state["depth_scale"], + state["visibility_prob"], + state["depth_nonreturn_prob"], + hyperparams["intrinsics"], + hyperparams["unexplained_depth_nonreturn_prob"], + ) + + # Points that don't hit the camera plane should not contribute to the score. + scores = jnp.where(is_unexplained(observed_rgbd_per_point), 0.0, scores) + score_for_pixels_with_points = scores.sum() + + # a = jnp.unique(ppa.projected_pixel_coordinates, axis=0, size=30000, fill_value=-1) + # num_pixels = ( a.sum(-1) >= 0).sum() + + # TODO: add scores for pixels that don't get a point + return score_for_pixels_with_points + + def get_rgbd_vertex_kernel(self) -> FullPixelRGBDDistribution: + # Note: The distributions were originally defined for per-pixel computation, + # but they should work for per-vertex computation as well, except that + # they don't expect observed_rgbd to be invalid, so we need to handle + # that manually. + return self.rgbd_vertex_kernel + + +### Unique point per pixel image kernel ### + + +@jax.jit +def calculate_latent_and_observed_correspondences( + observed_rgbd: FloatArray, + state: Mapping, + hyperparams: Mapping, +): + intrinsics = hyperparams["intrinsics"] + image_height, image_width = ( + intrinsics["image_height"].unwrap(), + intrinsics["image_width"].unwrap(), + ) + + transformed_points = state["pose"].apply(hyperparams["vertices"]) + + # Sort the vertices by depth. + sort_order = jnp.argsort(transformed_points[..., 2]) + transformed_points_sorted = transformed_points[sort_order] + + # Project the vertices to the image plane. + projected_coords = jnp.rint( + b3d.utils.xyz_to_pixel_coordinates( + transformed_points_sorted, + intrinsics["fx"], + intrinsics["fy"], + intrinsics["cx"], + intrinsics["cy"], + ) + - 0.5 + ).astype(jnp.int32) + projected_coords = jnp.nan_to_num(projected_coords, nan=INVALID_IDX) + # handle the case where the projected coordinates are outside the image + projected_coords = jnp.where(projected_coords > 0, projected_coords, INVALID_IDX) + projected_coords = jnp.where( + projected_coords < jnp.array([image_height, image_width]), + projected_coords, + INVALID_IDX, + ) + + # Compute the unique pixel coordinates and the indices of the first vertex that hit that pixel. + unique_pixel_coordinates, unique_indices = jnp.unique( + projected_coords, + axis=0, + return_index=True, + size=projected_coords.shape[0], + fill_value=INVALID_IDX, + ) + + observed_rgbd_per_point = observed_rgbd.at[ + unique_pixel_coordinates[:, 0], unique_pixel_coordinates[:, 1] + ].get(mode="drop", fill_value=-1.0) + + # For each collided pixel, get the color and depth of the vertex that hit that pixel. + latent_rgbd_per_point = jnp.concatenate( + [ + state["colors"][sort_order][unique_indices], + transformed_points_sorted[unique_indices, 2, None], + ], + axis=-1, + ) + + is_valid = ( + (unique_pixel_coordinates >= 0).all(axis=-1) + * (observed_rgbd_per_point[..., 3] >= 0.0), + )[0] + return ( + observed_rgbd_per_point, + latent_rgbd_per_point, + is_valid, + unique_pixel_coordinates, + sort_order[unique_indices], + ) + + +@Pytree.dataclass +class UniquePixelsImageKernel(ImageKernel): + rgbd_vertex_kernel: FullPixelRGBDDistribution + + def sample(self, key: PRNGKey, state: Mapping, hyperparams: Mapping) -> FloatArray: + # TODO: implement this + return jnp.zeros( + ( + hyperparams["intrinsics"]["image_height"].unwrap(), + hyperparams["intrinsics"]["image_width"].unwrap(), + 4, + ) + ) + + @jax.jit + def logpdf( + self, observed_rgbd: FloatArray, state: Mapping, hyperparams: Mapping + ) -> FloatArray: + intrinsics = hyperparams["intrinsics"] + ( + observed_rgbd_per_point, + latent_rgbd_per_point, + is_valid, + _, + point_indices_for_observed_rgbds, + ) = calculate_latent_and_observed_correspondences( + observed_rgbd, state, hyperparams + ) + + # Score the collided pixels + scores = jax.vmap( + hyperparams["image_kernel"].get_rgbd_vertex_kernel().logpdf, + in_axes=(0, 0, None, None, 0, 0, None, None), + )( + observed_rgbd_per_point, + latent_rgbd_per_point, + state["color_scale"], + state["depth_scale"], + state["visibility_prob"][point_indices_for_observed_rgbds], + state["depth_nonreturn_prob"][point_indices_for_observed_rgbds], + hyperparams["intrinsics"], + hyperparams["unexplained_depth_nonreturn_prob"], + ) + total_score_for_explained_pixels = jnp.where(is_valid, scores, 0.0).sum() + + # Score the pixels that don't have any vertices hitting them. + number_of_pixels_with_no_hypothesis = ( + hyperparams["intrinsics"]["image_height"].unwrap() + * hyperparams["intrinsics"]["image_width"].unwrap() + ) - is_valid.sum() + + number_of_total_non_return_pixels = (observed_rgbd[..., 3] == 0.0).sum() + number_of_non_return_pixels_with_latent_hypothesis = ( + observed_rgbd_per_point[..., 3] == 0.0 + ).sum() + number_of_non_return_pixels_without_latent_hypothesis = ( + number_of_total_non_return_pixels + - number_of_non_return_pixels_with_latent_hypothesis + ) + + # The pixels that have no vertices produce an observation uniformly at random. + color_score = jnp.log(1 / 1.0**3) + + depth_score_return = jnp.log( + 1 - hyperparams["unexplained_depth_nonreturn_prob"] + ) + jnp.log(1 / (intrinsics["far"] - intrinsics["near"])) + depth_score_non_return = jnp.log( + hyperparams["unexplained_depth_nonreturn_prob"] + ) + + total_score_for_unexplained_pixels = ( + number_of_pixels_with_no_hypothesis + - number_of_non_return_pixels_without_latent_hypothesis + ) * ( + color_score + depth_score_return + ) + number_of_non_return_pixels_without_latent_hypothesis * ( + color_score + depth_score_non_return + ) + # Final score is the sum of the log probabilities over all pixels, collided and not collided. + return total_score_for_explained_pixels + total_score_for_unexplained_pixels + + def get_rgbd_vertex_kernel(self) -> FullPixelRGBDDistribution: + return self.rgbd_vertex_kernel diff --git a/src/b3d/chisight/gen3d/inference.py b/src/b3d/chisight/gen3d/inference.py deleted file mode 100644 index e69de29b..00000000 diff --git a/src/b3d/chisight/gen3d/inference/__init__.py b/src/b3d/chisight/gen3d/inference/__init__.py new file mode 100644 index 00000000..9c2f95dc --- /dev/null +++ b/src/b3d/chisight/gen3d/inference/__init__.py @@ -0,0 +1,3 @@ +from . import inference as inference +from . import point_attribute_proposals as point_attribute_proposals +from . import utils as utils diff --git a/src/b3d/chisight/gen3d/inference/inference.py b/src/b3d/chisight/gen3d/inference/inference.py new file mode 100644 index 00000000..7fb445f2 --- /dev/null +++ b/src/b3d/chisight/gen3d/inference/inference.py @@ -0,0 +1,245 @@ +import itertools +import time + +# import jax.scipy.stats as ss +import jax +import jax.numpy as jnp +import jax.random +from genjax import ChoiceMapBuilder as C +from genjax import Diff +from genjax import UpdateProblemBuilder as U +from jax.random import split + +from b3d import Pose +from b3d.chisight.dense.dense_model import ( + get_hypers, + get_new_state, + get_prev_state, +) +from b3d.chisight.gen3d.hyperparams import InferenceHyperparams + +from .utils import logmeanexp, update_field + + +@jax.jit +def inference_step( + key, + trace, + observed_rgbd, + inference_hyperparams: InferenceHyperparams, + addresses, + include_previous_pose=True, + k=50, +): + key, subkey = split(key) + trace = advance_time(subkey, trace, observed_rgbd) + + @jax.jit + def c2f_step( + key, + trace, + pose_proposal_args, + addr, + ): + addr = addr.unwrap() + k1, k2, k3 = split(key, 3) + + # Propose the poses + pose_generation_keys = split(k1, inference_hyperparams.n_poses) + proposed_poses, log_q_poses = jax.vmap( + propose_pose, in_axes=(0, None, None, None) + )(pose_generation_keys, trace, addr, pose_proposal_args) + # jax.debug.print("rank before: {v}", v=ss.rankdata(log_q_poses)) + # jax.debug.print("score before: {v}", v=log_q_poses) + + proposed_poses, log_q_poses = maybe_swap_in_previous_pose( + proposed_poses, + log_q_poses, + trace, + addr, + include_previous_pose, + pose_proposal_args, + ) + # jax.debug.print("rank after: {v}", v=ss.rankdata(log_q_poses)) + # jax.debug.print("score after: {v}", v=log_q_poses) + + def update_and_get_scores(key, proposed_pose, trace, addr): + key, subkey = split(key) + updated_trace = update_field(subkey, trace, addr, proposed_pose) + return updated_trace, updated_trace.get_score() + + param_generation_keys = split(k2, inference_hyperparams.n_poses) + _, p_scores = jax.vmap(update_and_get_scores, in_axes=(0, 0, None, None))( + param_generation_keys, proposed_poses, trace, addr + ) + + # Scoring + resampling + weights = jnp.where( + inference_hyperparams.include_q_scores_at_top_level, + p_scores - log_q_poses, + p_scores, + ) + + # chosen_index = jax.random.categorical(k3, weights) + chosen_index = weights.argmax() + resampled_trace, _ = update_and_get_scores( + param_generation_keys[chosen_index], + proposed_poses[chosen_index], + trace, + addr, + ) + return ( + resampled_trace, + logmeanexp(weights), + proposed_poses[chosen_index], + proposed_poses, + weights, + ) + + this_frame_posterior = {} + for i, (addr, pose_proposal_args) in enumerate( + itertools.product(addresses, inference_hyperparams.pose_proposal_args) + ): + key, subkey = split(key) + this_iteration_start_time = time.time() + trace, _, best_pose, proposed_poses, weights = c2f_step( + subkey, + trace, + pose_proposal_args, + addr, + ) + if i % len(inference_hyperparams.pose_proposal_args) == 0: + top_k_indices = jnp.argsort(weights)[-k:][::-1] + top_scores = [weights[idx] for idx in top_k_indices] + posterior_poses = [proposed_poses[idx] for idx in top_k_indices] + this_frame_posterior[int(addr.unwrap().split("_")[-1])] = [ + [ + (score, posterior_pose) + for (posterior_pose, score) in zip(posterior_poses, top_scores) + ] + ] + elif (i + 1) % len(inference_hyperparams.pose_proposal_args) == 0: + this_frame_posterior[int(addr.unwrap().split("_")[-1])].append(best_pose) + this_iteration_end_time = time.time() + print( + f"\t\t\t c_2_f step time: {this_iteration_end_time - this_iteration_start_time}" + ) + + return (trace, this_frame_posterior) + + +def maybe_swap_in_previous_pose( + proposed_poses, log_q_poses, trace, addr, include_previous_pose, pose_proposal_args +): + previous_pose = get_prev_state(trace)[addr] + log_q = assess_previous_pose(trace, addr, previous_pose, pose_proposal_args) + chosen_index = log_q_poses.argmin() + proposed_poses = jax.tree.map( + lambda x, y: x.at[chosen_index].set( + jnp.where(include_previous_pose, y, x[chosen_index]) + ), + proposed_poses, + previous_pose, + ) + + log_q_poses = log_q_poses.at[0].set( + jnp.where( + include_previous_pose, + log_q, + log_q_poses[0], + ) + ) + + return proposed_poses, log_q_poses + + +def assess_previous_pose(advanced_trace, addr, previous_pose, args): + """ + Returns the log proposal density of the given pose, conditional upon the previous pose. + """ + std, conc = args + new_pose = get_new_state(advanced_trace)[addr] + log_q = Pose.logpdf_gaussian_vmf_pose_approx(previous_pose, new_pose, std, conc) + return log_q + + +@jax.jit +def advance_time(key, trace, observed_rgbd): + """ + Advance to the next timestep, setting the new latent state to the + same thing as the previous latent state, and setting the new + observed RGBD value. + + Returns a trace where previous_state (stored in the arguments) + and new_state (sampled in the choices and returned) are identical. + """ + trace, _, _, _ = trace.update( + key, + U.g( + ( + Diff.no_change(get_hypers(trace)), + Diff.unknown_change(get_new_state(trace)), + ), + C.kw(rgbd=observed_rgbd), + ), + ) + return trace + + +def get_initial_trace( + key, + importance_jit, + hyperparams, + initial_state, + initial_observed_rgbd, + get_weight=False, +): + """ + Get the initial trace, given the initial state. + The previous state and current state in the trace will be `initial_state`. + """ + choicemap = C.d( + { + "camera_pose": hyperparams["camera_pose"], + "color_noise_variance": hyperparams["color_noise_variance"], + "depth_noise_variance": hyperparams["color_noise_variance"], + "outlier_probability": hyperparams["outlier_probability"], + "rgbd": initial_observed_rgbd, + } + | initial_state + ) + + trace, weight = importance_jit( + key, + choicemap, + ( + hyperparams, + dict( + [ + (k, v) + for k, v in initial_state.items() + if not k.startswith("object_scale") + ] + ) + | {"t": -1}, + ), + ) + if get_weight: + return trace, weight + else: + return trace + + +### Inference moves ### + + +def propose_pose(key, advanced_trace, addr, args): + """ + Propose a random pose near the previous timestep's pose. + Returns (proposed_pose, log_proposal_density). + """ + std, conc = args + previous_pose = get_new_state(advanced_trace)[addr] + pose = Pose.sample_gaussian_vmf_pose_approx(key, previous_pose, std, conc) + log_q = Pose.logpdf_gaussian_vmf_pose_approx(pose, previous_pose, std, conc) + return pose, log_q diff --git a/src/b3d/chisight/gen3d/inference/point_attribute_proposals.py b/src/b3d/chisight/gen3d/inference/point_attribute_proposals.py new file mode 100644 index 00000000..8ffe0352 --- /dev/null +++ b/src/b3d/chisight/gen3d/inference/point_attribute_proposals.py @@ -0,0 +1,348 @@ +import jax +import jax.numpy as jnp +import jax.random +from jax.random import split + +from b3d.modeling_utils import renormalized_color_laplace + +from ..image_kernel import ( + PixelsPointsAssociation, + calculate_latent_and_observed_correspondences, +) +from ..model import ( + get_hypers, + get_n_vertices, + get_new_state, + get_observed_rgbd, + get_prev_state, +) +from .utils import all_pairs, normalize_log_scores + + +def propose_all_pointlevel_attributes(key, trace, inference_hyperparams): + """ + Propose a new color, visibility probability, and depth non-return probability + for every vertex, conditioned upon the other values in `trace`. + + Returns (colors, visibility_probs, depth_nonreturn_probs, log_q, metadata), + where colors has shape (n_vertices, 3), visibility_probs and depth_nonreturn_probs + have shape (n_vertices,), log_q (a float) is (an estimate of) + the overall log proposal density, and metadata is a dict. + """ + if inference_hyperparams.in_inference_only_assoc_one_point_per_pixel: + observed_rgbds_for_registered_points, _, _, _, vertex_indices = ( + calculate_latent_and_observed_correspondences( + get_observed_rgbd(trace), get_new_state(trace), get_hypers(trace) + ) + ) + observed_rgbds_per_point = -jnp.ones((get_n_vertices(trace), 4)) + observed_rgbds_per_point = observed_rgbds_per_point.at[vertex_indices].set( + observed_rgbds_for_registered_points, mode="drop" + ) + else: + observed_rgbds_per_point = PixelsPointsAssociation.from_hyperparams_and_pose( + get_hypers(trace), get_new_state(trace)["pose"] + ).get_point_rgbds(get_observed_rgbd(trace)) + + sample, metadata = jax.vmap( + propose_a_points_attributes, in_axes=(0, 0, 0, None, None, None, None) + )( + split(key, get_n_vertices(trace)), + jnp.arange(get_n_vertices(trace)), + observed_rgbds_per_point, + get_prev_state(trace), + get_new_state(trace), + get_hypers(trace), + inference_hyperparams, + ) + + return ( + sample["colors"], + sample["visibility_prob"], + sample["depth_nonreturn_prob"], + metadata["log_q_score"].sum(), + metadata, + ) + + +def propose_a_points_attributes( + key, + vertex_index, + observed_rgbd_for_point, + prev_state, + new_state, + hyperparams, + inference_hyperparams, +): + """ + Propose a new color, visibility probability, and depth non-return probability + for the vertex with index `vertex_index`. + + Returns (color, visibility_prob, depth_nonreturn_prob, log_q, metadata), + where color is a 3-array, visibility_prob and depth_nonreturn_prob are floats, + log_q (a float) is (a fair estimate of) the log proposal density, + and metadata is a dict. + """ + return _propose_a_points_attributes( + key, + observed_rgbd_for_point=observed_rgbd_for_point, + latent_depth=new_state["pose"].apply(hyperparams["vertices"][vertex_index])[2], + previous_color=prev_state["colors"][vertex_index], + previous_visibility_prob=prev_state["visibility_prob"][vertex_index], + previous_dnrp=prev_state["depth_nonreturn_prob"][vertex_index], + color_scale=new_state["color_scale"], + depth_scale=new_state["depth_scale"], + hyperparams=hyperparams, + inference_hyperparams=inference_hyperparams, + ) + + +def _propose_a_points_attributes( + key, + observed_rgbd_for_point, + latent_depth, + previous_color, + previous_visibility_prob, + previous_dnrp, + color_scale, + depth_scale, + hyperparams, + inference_hyperparams, +): + k1, k2 = split(key, 2) + dnrp_transition_kernel = hyperparams["depth_nonreturn_prob_kernel"] + visibility_transition_kernel = hyperparams["visibility_prob_kernel"] + color_kernel = hyperparams["color_kernel"] + obs_rgbd_kernel = hyperparams["image_kernel"].get_rgbd_vertex_kernel() + intrinsics = hyperparams["intrinsics"] + + def score_attribute_assignment(color, visprob, dnrprob): + visprob_transition_score = visibility_transition_kernel.logpdf( + visprob, previous_visibility_prob + ) + dnrprob_transition_score = dnrp_transition_kernel.logpdf(dnrprob, previous_dnrp) + color_transition_score = color_kernel.logpdf(color, previous_color) + likelihood_score = obs_rgbd_kernel.logpdf( + observed_rgbd=observed_rgbd_for_point, + latent_rgbd=jnp.append(color, latent_depth), + color_scale=color_scale, + depth_scale=depth_scale, + visibility_prob=visprob, + depth_nonreturn_prob=dnrprob, + intrinsics=intrinsics, + invisible_depth_nonreturn_prob=hyperparams[ + "unexplained_depth_nonreturn_prob" + ], + ) + return ( + visprob_transition_score + + dnrprob_transition_score + + color_transition_score + + likelihood_score + ) + + # Say there are V values in visibility_transition_kernel.support + # and D values in dnrp_transition_kernel.support. + + # (D*V, 2) array of all pairs of values in the support of the two kernels. + all_visprob_dnrprob_pairs = all_pairs( + visibility_transition_kernel.support, dnrp_transition_kernel.support + ) + + # Propose a color for each visprob-dnrprob pair. + rgbs, log_qs_rgb, rgb_proposal_metadata = jax.vmap( + lambda k, visprob_dnrprob_pair: propose_vertex_color_given_other_attributes( + key=k, + visprob=visprob_dnrprob_pair[0], + dnrprob=visprob_dnrprob_pair[1], + observed_rgb=observed_rgbd_for_point[:3], + score_attribute_assignment=score_attribute_assignment, + previous_rgb=previous_color, + inference_hyperparams=inference_hyperparams, + color_kernel=color_kernel, + ) + )(split(k1, len(all_visprob_dnrprob_pairs)), all_visprob_dnrprob_pairs) + + log_pscores = jax.vmap( + lambda visprob_dnrprob_pair, rgb: score_attribute_assignment( + rgb, visprob_dnrprob_pair[0], visprob_dnrprob_pair[1] + ), + in_axes=(0, 0), + )(all_visprob_dnrprob_pairs, rgbs) + + log_weights = log_pscores - log_qs_rgb + log_normalized_scores = normalize_log_scores(log_weights) + index = jax.random.categorical(k2, log_normalized_scores) + + rgb = rgbs[index] + visibility_prob, dnr_prob = all_visprob_dnrprob_pairs[index] + log_q_score = log_normalized_scores[index] + log_qs_rgb[index] + + return ( + { + "colors": rgb, + "visibility_prob": visibility_prob, + "depth_nonreturn_prob": dnr_prob, + }, + { + "log_q_score": log_q_score, + "log_qs_rgb": log_qs_rgb, + "log_normalized_scores": log_normalized_scores, + "index": index, + "all_visprob_dnrprob_pairs": all_visprob_dnrprob_pairs, + "rgb_proposal_metadata": rgb_proposal_metadata, + }, + ) + + +def propose_vertex_color_given_other_attributes( + key, + visprob, + dnrprob, + observed_rgb, + score_attribute_assignment, + previous_rgb, + inference_hyperparams, + color_kernel, +): + k1, _ = split(key) + value_if_observed_is_valid, log_q_if_valid, metadata_if_valid = ( + propose_vertex_color_given_other_attributes_for_valid_observed_rgb( + k1, + visprob, + dnrprob, + observed_rgb, + score_attribute_assignment, + previous_rgb, + inference_hyperparams, + ) + ) + value_if_observed_is_invalid = previous_rgb # color_kernel.sample(k2, previous_rgb) + log_q_if_invalid = color_kernel.logpdf(value_if_observed_is_invalid, previous_rgb) + + isvalid = ~jnp.any(observed_rgb < 0) + value = jnp.where(isvalid, value_if_observed_is_valid, value_if_observed_is_invalid) + log_q = jnp.where(isvalid, log_q_if_valid, log_q_if_invalid) + metadata = { + "isvalid": isvalid, + "metadata_if_valid": metadata_if_valid, + "value_if_observed_is_invalid": value_if_observed_is_invalid, + "log_q_if_invalid": log_q_if_invalid, + } + return value, log_q, metadata + + +def propose_vertex_color_given_other_attributes_for_valid_observed_rgb( + key, + visprob, + dnrprob, + observed_rgb, + score_attribute_assignment, + previous_rgb, + inference_hyperparams, +): + """ + This samples an rgb value from a proposal which first proposes 3 different rgb values, + then resamples one. The log q score is estimated using + simple logic for "filling in the auxiliary randomness" with a backward ("L") proposal, + as in SMCP3 or RAVI. + Returns (sampled_rgb, log_q_score). + + Specifically, this proposal works by proposing 2 RGB values: + - One from a laplace around previous_rgb + - One from a laplace around observed_rgb + + Then, one of these 2 RGB values is resampled and return. + + This process is a "forward" ("K") proposal, which has sampled (1) the chosen RGB value, + (2) the index amoung [0, 1] for which of the 2 proposals generated it, and (3) + one additional RGB values. + + We then imagine having an "L" proposal which, given (1), proposes (2) and (3). + To estimate the _marginal_ probability of K having proposed (1), marginalizing + over the choice of (2) and (3), we can return the value log_K - log_L + (where these terms are the log densities of the K and L proposals, respectively, + evaluated at the values we sampled out of the K proposal). + """ + metadata = {} + + k1, k2 = split(key, 2) + + ## Proposal 1: near the previous value. + scale1 = inference_hyperparams.prev_color_proposal_laplace_scale + proposed_rgb_1 = renormalized_color_laplace.sample(k1, previous_rgb, scale1) + proposed_rgb_1 = jnp.where( + inference_hyperparams.do_stochastic_color_proposals, + proposed_rgb_1, + previous_rgb, + ) + log_q_rgb_1 = renormalized_color_laplace.logpdf( + proposed_rgb_1, previous_rgb, scale1 + ) + + ## Proposal 1: near the observed value. + scale2 = inference_hyperparams.obs_color_proposal_laplace_scale + proposed_rgb_2 = renormalized_color_laplace.sample(k2, observed_rgb, scale2) + proposed_rgb_2 = jnp.where( + inference_hyperparams.do_stochastic_color_proposals, + proposed_rgb_2, + observed_rgb, + ) + log_q_rgb_2 = renormalized_color_laplace.logpdf( + proposed_rgb_2, observed_rgb, scale2 + ) + + ## Resample one of the values. + + proposed_rgbs = jnp.array([proposed_rgb_1, proposed_rgb_2]) + log_qs = jnp.array([log_q_rgb_1, log_q_rgb_2]) + metadata["log_qs"] = log_qs + metadata["proposed_rgbs"] = proposed_rgbs + + scores = ( + jax.vmap(lambda rgb: score_attribute_assignment(rgb, visprob, dnrprob))( + proposed_rgbs + ) + - log_qs + ) + normalized_scores = normalize_log_scores(scores) + sampled_index = jax.random.categorical(key, normalized_scores) + sampled_rgb = proposed_rgbs[sampled_index] + metadata["normalized_scores"] = normalized_scores + metadata["sampled_index"] = sampled_index + metadata["sampled_rgb"] = sampled_rgb + + log_K_score = log_qs.sum() + normalized_scores[sampled_index] + metadata["log_K_score"] = log_K_score + + ## "L proposal": given the sampled rgb, the L proposal proposes + # an index for which of the 3 proposals may have produced this sample RGB, + # and also proposes the other two RGB values. + # Here, we need to compute the logpdf of this L proposal having produced + # the values we sampled out of the K proposal. + log_qs_for_this_rgb = jnp.array( + [ + renormalized_color_laplace.logpdf(sampled_rgb, previous_rgb, scale1), + renormalized_color_laplace.logpdf(sampled_rgb, observed_rgb, scale2), + ] + ) + normalized_L_logprobs = normalize_log_scores(log_qs_for_this_rgb) + + # L score for proposing the index + log_L_score_for_index = normalized_L_logprobs[sampled_index] + + # Also add in the L score for proposing the other two RGB values. + # The L proposal over these values will just generate them from their prior. + log_L_score_for_unused_values = jnp.sum(log_qs) - log_qs[sampled_index] + + # full L score + log_L_score = log_L_score_for_index + log_L_score_for_unused_values + metadata["log_L_score"] = log_L_score + + ## Compute the overall estimate of the marginal density of proposing `sampled_rgb`. + overall_score = log_K_score - log_L_score + # overall_score = normalized_scores[sampled_index] # + log_qs["sampled_index"] + metadata["overall_score"] = overall_score + + ## Return + return sampled_rgb, overall_score, metadata diff --git a/src/b3d/chisight/gen3d/inference/utils.py b/src/b3d/chisight/gen3d/inference/utils.py new file mode 100644 index 00000000..ade6a95e --- /dev/null +++ b/src/b3d/chisight/gen3d/inference/utils.py @@ -0,0 +1,86 @@ +import jax +import jax.numpy as jnp +import jax.random +from genjax import ChoiceMapBuilder as C +from genjax import Diff +from genjax import UpdateProblemBuilder as U + + +def logmeanexp(vec): + vec = jnp.where(jnp.isnan(vec), -jnp.inf, vec) + return jax.scipy.special.logsumexp(vec) - jnp.log(len(vec)) + + +def update_field(key, trace, fieldname, value): + """ + Update `trace` by changing the value at address `fieldname` to `value`. + Returns a new trace. + """ + return update_fields(key, trace, [fieldname], [value]) + + +def update_fields(key, trace, fieldnames, values): + """ + Update `trace` by changing the values at the addresses in `fieldnames` to the + corresponding values in `values`. Returns a new trace. + """ + hyperparams, previous_state = trace.get_args() + trace, _, _, _ = trace.update( + key, + U.g( + (Diff.no_change(hyperparams), Diff.no_change(previous_state)), + C.kw(**dict(zip(fieldnames, values))), + ), + ) + return trace + + +def update_vmapped_fields(key, trace, fieldnames, values): + """ + For each `fieldname` in fieldnames, and each array `arr` in the + corresponding slot in `values`, updates `trace` at addresses + (0, fieldname) through (len(arr) - 1, fieldname) to the corresponding + values in `arr`. + (That is, this assumes for each fieldname, there is a vmap combinator + sampled at that address in the trace.) + """ + c = C.n() + for addr, val in zip(fieldnames, values): + c = c ^ jax.vmap(lambda idx: C[addr, idx].set(val[idx]))( + jnp.arange(val.shape[0]) + ) + + hyperparams, previous_state = trace.get_args() + trace, _, _, _ = trace.update( + key, + U.g((Diff.no_change(hyperparams), Diff.no_change(previous_state)), c), + ) + return trace + + +def update_vmapped_field(key, trace, fieldname, value): + """ + For information, see `update_vmapped_fields`. + """ + return update_vmapped_fields(key, trace, [fieldname], [value]) + + +def all_pairs(X, Y): + """ + Return an array `ret` of shape (|X| * |Y|, 2) where each row + is a pair of values from X and Y. + That is, `ret[i, :]` is a pair [x, y] for some x in X and y in Y. + """ + return jnp.swapaxes(jnp.stack(jnp.meshgrid(X, Y), axis=-1), 0, 1).reshape(-1, 2) + + +def normalize_log_scores(scores): + """ + Util for constructing log resampling distributions, avoiding NaN issues. + + (Conversely, since there will be no NaNs, this could make it harder to debug.) + """ + val = scores - jax.scipy.special.logsumexp(scores) + return jnp.where( + jnp.any(jnp.isnan(val)), -jnp.log(len(val)) * jnp.ones_like(val), val + ) diff --git a/src/b3d/chisight/gen3d/metrics.py b/src/b3d/chisight/gen3d/metrics.py new file mode 100644 index 00000000..5ecade7e --- /dev/null +++ b/src/b3d/chisight/gen3d/metrics.py @@ -0,0 +1,129 @@ +from pathlib import Path +from typing import Sequence + +import numpy as np +from genjax import Pytree +from scipy import spatial + +from b3d.utils import get_assets_path + +FP_RESULTS_ROOT_DIR = ( + get_assets_path() / "shared_data_bucket/foundation_pose_tracking_results" +) +DEFAULT_FP_YCBV_RESULT_DIR = ( + FP_RESULTS_ROOT_DIR / "ycbv/2024-07-11-every-50-frames-gt-init" +) + + +@Pytree.dataclass +class YCBVTrackingResultLoader(Pytree): + """A utility class that loads precomputed YCBV tracking results from the + specified directory as commanded. Note that this dataclass itself does not + keep a copy of the result + """ + + result_dir: Path + + def load(self, test_scene_id: IndentationError, object_id: int) -> np.ndarray: + """Given the test scene and object id, load the corresponding tracking + result from the specified directory. The returning JAX array will have + shape (num_frames, 4, 4), where the estimated pose in each frame is + stored as a 4x4 transformation matrix. + """ + filename = self.result_dir / str(test_scene_id) / f"object_{object_id}.npy" + return np.load(filename) + + def get_scene_ids(self) -> list[int]: + return sorted( + [int(test_scene.name) for test_scene in self.result_dir.iterdir()] + ) + + def get_object_ids(self, test_scene_id: int) -> list[int]: + scene_dir = self.result_dir / str(test_scene_id) + prefix_length = len("object_") + return sorted( + [int(object_id.stem[prefix_length:]) for object_id in scene_dir.iterdir()] + ) + + +# a default loader for the most recently computed foundation pose tracking results +foundation_pose_ycbv_result = YCBVTrackingResultLoader(DEFAULT_FP_YCBV_RESULT_DIR) + + +def apply_transform(pose: np.ndarray, vertices: np.ndarray) -> np.ndarray: + return (pose[:3, :3] @ vertices.T + pose[:3, 3][:, None]).T + + +def add_err(pred_pose: np.ndarray, gt_pose: np.ndarray, vertices: np.ndarray) -> float: + """Compute the Average Distance (ADD) error between the predicted pose and the + ground truth pose, given the vertices of the object. + + References: + - https://github.com/thodan/bop_toolkit/blob/59c5f486fe3a7886329d9fc908935e40d3bc0248/bop_toolkit_lib/pose_error.py#L210-L224 + - https://github.com/NVlabs/FoundationPose/blob/cd3ca4bc080529c53d5e5235212ca476d82bccf7/Utils.py#L232-L240 + - https://github.com/chensong1995/HybridPose/blob/106c86cddaa52765eb82f17bd00fdc72b98a02ca/lib/utils.py#L36-L49 + + Args: + pred_pose (np.ndarray): A 4x4 transformation matrix representing the predicted pose. + gt_pose (np.ndarray): A 4x4 transformation matrix representing the ground truth pose. + vertices (np.ndarray): The vertices of shape (num_vertices, 3) in the object frame, + representing the 3D model of the object. Note that we should be using the vertices + from the ground truth mesh file instead of the reconstructed point cloud. + """ + pred_locs = apply_transform(pred_pose, vertices) + gt_locs = apply_transform(gt_pose, vertices) + return np.linalg.norm(pred_locs - gt_locs, axis=-1).mean() + + +def adds_err(pred_pose: np.ndarray, gt_pose: np.ndarray, vertices: np.ndarray) -> float: + """Compute the Average Closest Point Distance (ADD-S) error between the predicted pose and the + ground truth pose, given the vertices of the object. ADD-S is an ambiguity-invariant pose + error metric which takes care of both symmetric and non-symmetric objects + + References: + - https://github.com/thodan/bop_toolkit/blob/59c5f486fe3a7886329d9fc908935e40d3bc0248/bop_toolkit_lib/pose_error.py#L227-L247 + - https://github.com/NVlabs/FoundationPose/blob/cd3ca4bc080529c53d5e5235212ca476d82bccf7/Utils.py#L242-L253 + - https://github.com/chensong1995/HybridPose/blob/106c86cddaa52765eb82f17bd00fdc72b98a02ca/lib/utils.py#L51-L68 + + Args: + pred_pose (np.ndarray): A 4x4 transformation matrix representing the predicted pose. + gt_pose (np.ndarray): A 4x4 transformation matrix representing the ground truth pose. + vertices (np.ndarray): The vertices of shape (num_vertices, 3) in the object frame, + representing the 3D model of the object. Note that we should be using the vertices + from the ground truth mesh file instead of the reconstructed point cloud. + """ + pred_locs = apply_transform(pred_pose, vertices) + gt_locs = apply_transform(gt_pose, vertices) + + # Calculate distances to the nearest neighbors from vertices in the + # ground-truth pose to vertices in the estimated pose. + nn_index = spatial.cKDTree(pred_locs) + nn_dists, _ = nn_index.query(gt_locs, k=1) + + return nn_dists.mean() + + +def compute_auc(errs: Sequence, max_val: float = 0.1, step=0.001): + """Compute the Area Under the Curve (AUC) of the pose tracking errors at + different thresholds. + + Reference: + - https://github.com/NVlabs/FoundationPose/blob/cd3ca4bc080529c53d5e5235212ca476d82bccf7/Utils.py#L255-L266 + + Args: + errs (Sequence): An sequence of pose tracking errors. + max_val (float, optional): The upper bound of the threshold. Defaults to 0.1. + step (float, optional): The step between two threshold. Defaults to 0.001. + """ + from sklearn import metrics + + errs = np.sort(np.array(errs)) + X = np.arange(0, max_val + step, step) + Y = np.ones(len(X)) + for i, x in enumerate(X): + y = (errs <= x).sum() / len(errs) + Y[i] = y + if y >= 1: + break + auc = metrics.auc(X, Y) / (max_val * 1) + return auc diff --git a/src/b3d/chisight/gen3d/model.py b/src/b3d/chisight/gen3d/model.py index e69de29b..c88e6a04 100644 --- a/src/b3d/chisight/gen3d/model.py +++ b/src/b3d/chisight/gen3d/model.py @@ -0,0 +1,249 @@ +import pprint + +import genjax +import jax +import jax.numpy as jnp +import rerun as rr +import rerun.blueprint as rrb +from genjax import ChoiceMapBuilder as C + +import b3d +from b3d.chisight.gen3d.image_kernel import PixelsPointsAssociation + +# TODOs +# 1. Tests of drift kernels +# 2. Test of choicemap creation, and model updating + + +@genjax.gen +def dynamic_object_generative_model(hyperparams, previous_state): + hyperparams["vertices"] + + pose_kernel = hyperparams["pose_kernel"] + color_kernel = hyperparams["color_kernel"] + visibility_prob_kernel = hyperparams["visibility_prob_kernel"] + depth_nonreturn_prob_kernel = hyperparams["depth_nonreturn_prob_kernel"] + depth_scale_kernel = hyperparams["depth_scale_kernel"] + color_scale_kernel = hyperparams["color_scale_kernel"] + + pose = pose_kernel(previous_state["pose"]) @ "pose" + color_for_each_latent_point = ( + color_kernel.vmap()(previous_state["colors"]) @ "colors" + ) + visibility_prob_for_each_latent_point = ( + visibility_prob_kernel.vmap()(previous_state["visibility_prob"]) + @ "visibility_prob" + ) + depth_nonreturn_prob_for_each_latent_point = ( + depth_nonreturn_prob_kernel.vmap()(previous_state["depth_nonreturn_prob"]) + @ "depth_nonreturn_prob" + ) + global_depth_scale = ( + depth_scale_kernel(previous_state["depth_scale"]) @ "depth_scale" + ) + global_color_scale = ( + color_scale_kernel(previous_state["color_scale"]) @ "color_scale" + ) + + new_state = { + "pose": pose, + "colors": color_for_each_latent_point, + "visibility_prob": visibility_prob_for_each_latent_point, + "depth_nonreturn_prob": depth_nonreturn_prob_for_each_latent_point, + "depth_scale": global_depth_scale, + "color_scale": global_color_scale, + } + + if "image_kernel" not in hyperparams: + rgbd = None + else: + rgbd = hyperparams["image_kernel"](new_state, hyperparams) @ "rgbd" + + return { + "new_state": new_state, + "rgbd": rgbd, + } + + +### Helpers ### +def make_colors_choicemap(colors): + return jax.vmap(lambda idx: C["colors", idx].set(colors[idx]))( + jnp.arange(len(colors)) + ) + + +def make_visibility_prob_choicemap(visibility_prob): + return jax.vmap(lambda idx: C["visibility_prob", idx].set(visibility_prob[idx]))( + jnp.arange(len(visibility_prob)) + ) + + +def make_depth_nonreturn_prob_choicemap(depth_nonreturn_prob): + return jax.vmap( + lambda idx: C["depth_nonreturn_prob", idx].set(depth_nonreturn_prob[idx]) + )(jnp.arange(len(depth_nonreturn_prob))) + + +def get_hypers(trace): + return trace.get_args()[0] + + +def get_prev_state(trace): + return trace.get_args()[1] + + +def get_new_state(trace): + return trace.get_retval()["new_state"] + + +def get_n_vertices(trace): + return get_hypers(trace)["vertices"].shape[0] + + +def get_observed_rgbd(trace): + return trace.get_retval()["rgbd"] + + +### Visualization Code ### + + +def viz_trace( + trace, + t=0, + ground_truth_vertices=None, + ground_truth_pose=None, + log_blueprint=True, +): + b3d.rr_set_time(t) + hyperparams, _ = trace.get_args() + new_state = trace.get_retval()["new_state"] + + pose = new_state["pose"] + colors = new_state["colors"] + visibility_prob = new_state["visibility_prob"] + depth_nonreturn_prob = new_state["depth_nonreturn_prob"] + + vertices = hyperparams["vertices"] + b3d.rr_log_cloud( + vertices[visibility_prob > 0.1], + "object/model", + colors[visibility_prob > 0.1], + ) + b3d.rr_log_cloud( + vertices, + "object/visibility_prob", + jnp.array([[1.0, 0.0, 0.0]]) * visibility_prob[..., None], + ) + b3d.rr_log_cloud( + vertices[visibility_prob > 0.1], + "object/depth_nonreturn_prob", + (jnp.array([[0.0, 1.0, 0.0]]) * depth_nonreturn_prob[..., None])[ + visibility_prob > 0.1 + ], + ) + + rr.log( + "info", + rr.TextDocument( + f""" + depth_scale: {new_state["depth_scale"]:.5f} + color_scale: {new_state["color_scale"]:.5f} + hyperparams: + {pprint.pformat(hyperparams)} + """.strip(), + media_type=rr.MediaType.MARKDOWN, + ), + ) + + # rr.log("color_scale", rr.Scalar(new_state["color_scale"])) + # rr.log("depth_scale", rr.Scalar(new_state["depth_scale"])) + + vertices_transformed = pose.apply(vertices) + b3d.rr_log_cloud( + vertices_transformed, + "scene/model", + colors, + ) + + output = trace.get_retval() + if output["rgbd"] is not None: + observed_rgbd = output["rgbd"] + b3d.rr_log_rgb(observed_rgbd[..., :3], "image") + b3d.rr_log_rgb(observed_rgbd[..., :3], "image/rgb/observed") + b3d.rr_log_depth(observed_rgbd[..., 3], "image/depth/observed") + + pixel_point_association = PixelsPointsAssociation.from_points_and_intrinsics( + vertices_transformed, + hyperparams["intrinsics"], + ) + pixel_latent_rgb = jnp.clip( + pixel_point_association.get_pixel_attributes(new_state["colors"]), 0.0, 1.0 + ) + pixel_latent_depth = jnp.clip( + pixel_point_association.get_pixel_attributes(vertices_transformed[..., 2]), + 0.0, + 10.0, + ) + + b3d.rr_log_rgb(pixel_latent_rgb, "image/rgb/latent") + b3d.rr_log_depth(pixel_latent_depth, "image/depth/latent") + + # TODO: should we add in a way to visualize a noise-free projection + # of the points to the camera plane? + + fx, fy, cx, cy = ( + hyperparams["intrinsics"]["fx"], + hyperparams["intrinsics"]["fy"], + hyperparams["intrinsics"]["cx"], + hyperparams["intrinsics"]["cy"], + ) + b3d.rr_log_cloud( + b3d.xyz_from_depth( + output["rgbd"][..., 3], + fx, + fy, + cx, + cy, + ), + "scene/observed", + output["rgbd"][..., :3].reshape(-1, 3), + ) + + if ground_truth_vertices is not None: + b3d.rr_log_cloud( + trace.get_choices()["pose"].apply(ground_truth_vertices), + "scene/full_object_model", + ) + + if ground_truth_pose: + b3d.rr_log_cloud( + ground_truth_pose.apply(ground_truth_vertices), + "scene/ground_truth_object_mesh", + ) + + b3d.rr_log_pose(ground_truth_pose, "scene/ground_truth_pose") + b3d.rr_log_pose(trace.get_choices()["pose"], "scene/inferred_pose") + + if not b3d.get_blueprint_logged() and log_blueprint: + rr.send_blueprint(get_blueprint()) + b3d.set_blueprint_logged(True) + + +def get_blueprint(): + return rrb.Blueprint( + rrb.Vertical( + rrb.Horizontal( + rrb.Spatial3DView(origin="scene/"), + rrb.Horizontal( + rrb.Spatial2DView(origin="image/rgb/"), + rrb.Spatial2DView(origin="image/depth/"), + ), + ), + rrb.Horizontal( + rrb.Spatial3DView(origin="object/model"), + rrb.Spatial3DView(origin="object/visibility_prob"), + rrb.Spatial3DView(origin="object/depth_nonreturn_prob"), + rrb.TextDocumentView(origin="info"), + ), + ) + ) diff --git a/src/b3d/chisight/gen3d/pixel_kernels.py b/src/b3d/chisight/gen3d/pixel_kernels.py deleted file mode 100644 index e69de29b..00000000 diff --git a/src/b3d/chisight/gen3d/pixel_kernels/pixel_color_kernels.py b/src/b3d/chisight/gen3d/pixel_kernels/pixel_color_kernels.py new file mode 100644 index 00000000..5402d7d3 --- /dev/null +++ b/src/b3d/chisight/gen3d/pixel_kernels/pixel_color_kernels.py @@ -0,0 +1,176 @@ +from abc import abstractmethod +from typing import TYPE_CHECKING + +import genjax +import jax +from b3d.modeling_utils import ( + _FIXED_COLOR_UNIFORM_WINDOW, + renormalized_laplace, + truncated_laplace, +) +from genjax import Pytree +from genjax.typing import FloatArray, PRNGKey +from jax.random import split +from tensorflow_probability.substrates import jax as tfp + +if TYPE_CHECKING: + import tensorflow_probability.python.distributions.distribution as dist + +COLOR_MIN_VAL: float = 0.0 +COLOR_MAX_VAL: float = 1.0 + + +@Pytree.dataclass +class PixelColorDistribution(genjax.ExactDensity): + """ + An abstract class that defines the common interface for pixel color kernels. + + Distribuiton args: + - latent_color + - color_scale + + Support: + - An RGB value in [0, 1]^3. + """ + + @abstractmethod + def sample( + self, key: PRNGKey, latent_color: FloatArray, color_scale: FloatArray + ) -> FloatArray: + raise NotImplementedError + + def logpdf( + self, + observed_color: FloatArray, + latent_color: FloatArray, + color_scale: FloatArray, + ) -> float: + return self.logpdf_per_channel(observed_color, latent_color, color_scale).sum() + + @abstractmethod + def logpdf_per_channel( + self, + observed_color: FloatArray, + latent_color: FloatArray, + color_scale: FloatArray, + ) -> FloatArray: + """ + Return an array of logpdf values, one for each channel. This is useful + for testing purposes. + Either this or `logpdf` must be implemented. + """ + raise NotImplementedError + + +@Pytree.dataclass +class RenormalizedGaussianPixelColorDistribution(PixelColorDistribution): + """ + Sample a color from a renormalized Gaussian distribution centered around the given + latent_color (rgb value), given the color_scale (stddev of the Gaussian). + + The support of the distribution is ([0, 1]^3). + """ + + def sample(self, key, latent_color, color_scale): + return jax.vmap( + genjax.truncated_normal.sample, in_axes=(0, 0, None, None, None) + )( + split(key, latent_color.shape[0]), + latent_color, + color_scale, + COLOR_MIN_VAL, + COLOR_MAX_VAL, + ) + + def logpdf_per_channel(self, observed_color, latent_color, color_scale): + return jax.vmap( + genjax.truncated_normal.logpdf, in_axes=(0, 0, None, None, None) + )(observed_color, latent_color, color_scale, COLOR_MIN_VAL, COLOR_MAX_VAL) + + +@Pytree.dataclass +class RenormalizedLaplacePixelColorDistribution(PixelColorDistribution): + """ + Sample a color from a renormalized Laplace distribution centered around the given + latent_color (rgb value), given the color_scale (scale of the laplace). + + The support of the distribution is ([0, 1]^3). + """ + + def sample(self, key, latent_color, color_scale): + return jax.vmap(renormalized_laplace.sample, in_axes=(0, 0, None, None, None))( + split(key, latent_color.shape[0]), + latent_color, + color_scale, + COLOR_MIN_VAL, + COLOR_MAX_VAL, + ) + + def logpdf_per_channel(self, observed_color, latent_color, color_scale): + return jax.vmap(renormalized_laplace.logpdf, in_axes=(0, 0, None, None, None))( + observed_color, latent_color, color_scale, COLOR_MIN_VAL, COLOR_MAX_VAL + ) + + +@Pytree.dataclass +class TruncatedLaplacePixelColorDistribution(PixelColorDistribution): + """A distribution that generates the color of a pixel from a truncated + Laplace distribution centered around the latent color, with the spread + controlled by color_scale. The support of the distribution is ([0, 1]^3). + """ + + # the uniform window is used to wrapped the truncated laplace distribution + # to ensure that the color generated is within the range of [0, 1] + uniform_window_size: float = Pytree.static(default=_FIXED_COLOR_UNIFORM_WINDOW) + + def sample( + self, key: PRNGKey, latent_color: FloatArray, color_scale: FloatArray + ) -> FloatArray: + return jax.vmap( + lambda k, color: truncated_laplace.sample( + k, + color, + color_scale, + COLOR_MIN_VAL, + COLOR_MAX_VAL, + self.uniform_window_size, + ), + in_axes=(0, 0), + )(jax.random.split(key, latent_color.shape[0]), latent_color) + + def logpdf_per_channel( + self, + observed_color: FloatArray, + latent_color: FloatArray, + color_scale: FloatArray, + ) -> FloatArray: + return jax.vmap( + lambda obs, latent: truncated_laplace.logpdf( + obs, + latent, + color_scale, + COLOR_MIN_VAL, + COLOR_MAX_VAL, + self.uniform_window_size, + ), + in_axes=(0, 0), + )(observed_color, latent_color) + + +@Pytree.dataclass +class UniformPixelColorDistribution(PixelColorDistribution): + """A distribution that generates the color of a pixel from a uniform on the + RGB space ([0, 1]^3). + """ + + @property + def _base_dist(self) -> "dist.Distribution": + return tfp.distributions.Uniform(COLOR_MIN_VAL, COLOR_MAX_VAL) + + def sample(self, key: PRNGKey, *args, **kwargs) -> FloatArray: + return self._base_dist.sample(seed=key, sample_shape=(3,)) + + def logpdf_per_channel( + self, observed_color: FloatArray, *args, **kwargs + ) -> FloatArray: + return self._base_dist.log_prob(observed_color) diff --git a/src/b3d/chisight/gen3d/pixel_kernels/pixel_depth_kernels.py b/src/b3d/chisight/gen3d/pixel_kernels/pixel_depth_kernels.py new file mode 100644 index 00000000..2d351c64 --- /dev/null +++ b/src/b3d/chisight/gen3d/pixel_kernels/pixel_depth_kernels.py @@ -0,0 +1,191 @@ +from abc import abstractmethod +from typing import TYPE_CHECKING + +import genjax +from b3d.modeling_utils import ( + _FIXED_DEPTH_UNIFORM_WINDOW, + renormalized_laplace, + truncated_laplace, +) +from genjax import Pytree +from genjax.typing import PRNGKey +from tensorflow_probability.substrates import jax as tfp + +if TYPE_CHECKING: + import tensorflow_probability.python.distributions.distribution as dist + +DEPTH_NONRETURN_VAL = 0.0 +UNEXPLAINED_DEPTH_NONRETURN_PROB = 0.02 + + +@Pytree.dataclass +class PixelDepthDistributionForDepthReturn(genjax.ExactDensity): + """ + An abstract class that defines the common interface for kernels + from a latent depth to an observed measurement of the depth, + assuming there was a depth return. + These distributions return a depth value between (near, far). + + These distributions NEVER return DEPTH_NONRETURN_VAL; outer distributions should + wrap a `PixelDepthDistributionForDepthReturn` in a mixture distribution where + the other branch can return DEPTH_NONRETURN_VAL. + + Distribution args: + - latent_depth + - depth_scale + - near + - far + + Support: depth value in [near, far], or DEPTH_NONRETURN_VAL. + """ + + @abstractmethod + def sample( + self, key: PRNGKey, latent_depth: float, near: float, far: float + ) -> float: + raise NotImplementedError + + @abstractmethod + def logpdf( + self, + observed_depth: float, + latent_depth: float, + near: float, + far: float, + ) -> float: + raise NotImplementedError + + +@Pytree.dataclass +class RenormalizedGaussianPixelDepthDistribution(PixelDepthDistributionForDepthReturn): + """A distribution that generates the depth of a pixel from a Gaussian + distribution centered around the latent depth, with the spread controlled + by depth_scale. The support of the distribution is [near, far]. + """ + + def sample( + self, + key: PRNGKey, + latent_depth: float, + depth_scale: float, + near: float, + far: float, + ) -> float: + return genjax.truncated_normal.sample(key, latent_depth, depth_scale, near, far) + + def logpdf( + self, + observed_depth: float, + latent_depth: float, + depth_scale: float, + near: float, + far: float, + ) -> float: + return genjax.truncated_normal.logpdf( + observed_depth, latent_depth, depth_scale, near, far + ) + + +@Pytree.dataclass +class RenormalizedLaplacePixelDepthDistribution(PixelDepthDistributionForDepthReturn): + """A distribution that generates the depth of a pixel from a Laplace + distribution centered around the latent depth, with the spread controlled + by depth_scale. The support of the distribution is [near, far]. + """ + + def sample( + self, + key: PRNGKey, + latent_depth: float, + depth_scale: float, + near: float, + far: float, + ) -> float: + return renormalized_laplace.sample(key, latent_depth, depth_scale, near, far) + + def logpdf( + self, + observed_depth: float, + latent_depth: float, + depth_scale: float, + near: float, + far: float, + ) -> float: + return renormalized_laplace.logpdf( + observed_depth, latent_depth, depth_scale, near, far + ) + + +@Pytree.dataclass +class TruncatedLaplacePixelDepthDistribution(PixelDepthDistributionForDepthReturn): + """A distribution that generates the depth of a pixel from a truncated + Laplace distribution centered around the latent depth, with the spread + controlled by depth_scale. The support of the distribution is [near, far]. + """ + + # the uniform window is used to wrapped the truncated laplace distribution + # to ensure that the depth generated is within the range of [near, far] + uniform_window_size: float = Pytree.static(default=_FIXED_DEPTH_UNIFORM_WINDOW) + + def sample( + self, + key: PRNGKey, + latent_depth: float, + depth_scale: float, + near: float, + far: float, + ) -> float: + return truncated_laplace.sample( + key, + latent_depth, + depth_scale, + near, + far, + self.uniform_window_size, + ) + + def logpdf( + self, + observed_depth: float, + latent_depth: float, + depth_scale: float, + near: float, + far: float, + ) -> float: + return truncated_laplace.logpdf( + observed_depth, + latent_depth, + depth_scale, + near, + far, + self.uniform_window_size, + ) + + +@Pytree.dataclass +class UniformPixelDepthDistribution(PixelDepthDistributionForDepthReturn): + """A distribution that generates the depth of a pixel from a uniform from + [near, far].""" + + def _base_dist(self, near, far) -> "dist.Distribution": + return tfp.distributions.Uniform(near, far) + + def sample( + self, + key: PRNGKey, + latent_depth: float, + depth_scale: float, + near: float, + far: float, + ) -> float: + return self._base_dist(near, far).sample(seed=key) + + def logpdf( + self, + observed_depth: float, + latent_depth: float, + depth_scale: float, + near: float, + far: float, + ) -> float: + return self._base_dist(near, far).log_prob(observed_depth) diff --git a/src/b3d/chisight/gen3d/pixel_kernels/pixel_rgbd_kernels.py b/src/b3d/chisight/gen3d/pixel_kernels/pixel_rgbd_kernels.py new file mode 100644 index 00000000..dc357ada --- /dev/null +++ b/src/b3d/chisight/gen3d/pixel_kernels/pixel_rgbd_kernels.py @@ -0,0 +1,200 @@ +import genjax +import jax +import jax.numpy as jnp +from b3d.chisight.gen3d.pixel_kernels.pixel_color_kernels import PixelColorDistribution +from b3d.chisight.gen3d.pixel_kernels.pixel_depth_kernels import ( + PixelDepthDistributionForDepthReturn, +) +from genjax import Pytree +from genjax.typing import FloatArray, PRNGKey +from jax.random import split + + +def is_unexplained(latent_value: FloatArray) -> bool: + """ + Check if a given `latent_value` value given to a pixel + indicates that no latent point hits a pixel. + This is done by checking if any of the latent color values + are negative. + + Args: + latent_value (FloatArray): The latent color of the pixel. + + Returns: + bool: True is none of the latent point hits the pixel, False otherwise. + """ + return jnp.any(latent_value < 0.0) + + +@Pytree.dataclass +class PixelDistFromColorDistAndDepthReturnDist(genjax.ExactDensity): + """ + Distribution on an RGBD pixel. + This wraps (1) a color distribution and (2) + a depth distribution for the case where the depth value is a return. + + This distribution samples a pixel by sampling from the color distribution, + and either sampling a depth value from the depth distribution or deciding + that the depth value at this pixel is a non-return. + + Distribution support: + [0, 1]^3 x ([near, far] + {DEPTH_NONRETURN_VALUE}). + + Args: + - latent_rgbd + - color_scale + - depth_scale + - depth_nonreturn_prob + - intrinsics dict containing `"near"` and `"far"` keys. + + [TODO: is there a better name for this class?] + """ + + color_distribution: PixelColorDistribution + depth_distribution: PixelDepthDistributionForDepthReturn + + def sample( + self, + key: PRNGKey, + latent_rgbd: FloatArray, + color_scale: float, + depth_scale: float, + depth_nonreturn_prob: float, + intrinsics: dict, + ) -> FloatArray: + k1, k2, k3 = split(key, 3) + color = self.color_distribution.sample(k1, latent_rgbd[:3], color_scale) + depth_if_return = self.depth_distribution.sample( + k2, latent_rgbd[3], depth_scale, intrinsics["near"], intrinsics["far"] + ) + depth = jnp.where( + jax.random.bernoulli(k3, depth_nonreturn_prob), 0.0, depth_if_return + ) + + return jnp.concatenate([color, jnp.array([depth])]) + + def logpdf( + self, obs, latent, color_scale, depth_scale, depth_nonreturn_prob, intrinsics + ): + color_logpdf = self.color_distribution.logpdf(obs[:3], latent[:3], color_scale) + depth_logpdf_if_return = self.depth_distribution.logpdf( + obs[3], latent[3], depth_scale, intrinsics["near"], intrinsics["far"] + ) + depth_logpdf = jnp.where( + obs[3] == 0.0, + jnp.log(depth_nonreturn_prob), + jnp.log(1 - depth_nonreturn_prob) + depth_logpdf_if_return, + ) + return color_logpdf + depth_logpdf + + +@Pytree.dataclass +class FullPixelRGBDDistribution(genjax.ExactDensity): + """ + Args: + - latent_rgbd: 4-array: RGBD value. (a value of [-1, -1, -1, -1] indicates no point hits here.) + - color_scale: float + - depth_scale: float + - visibility_prob: float + - depth_nonreturn_prob: float + - intrinsics: dict + - depth_nonreturn_prob_for_invisible: float + + The support of the distribution is [0, 1]^3 x ([near, far] + {DEPTH_NONRETURN_VALUE}). + + The generative process is: + - If latent_rgbd is [-1, -1, -1, -1], the pixel color will be sampled from `outlier_color_distribution` + and the depth will be sampled from `outlier_depth_distribution`, called with `depth_nonreturn_prob_for_invisible`. + - Otherwise, with probability `1 - visibility_prob`, the pixel will be sampled in the same way + as the preceding bullet. + - Finally, if `latent_rgbd` is not [-1, -1, -1, -1], with probability `visibility_prob`, the pixel + color will be sampled from `inlier_color_distribution` and the depth will be sampled from `inlier_depth_distribution` + called with `depth_nonreturn_prob` (rather than `depth_nonreturn_prob_for_invisible`). + """ + + inlier_color_distribution: PixelColorDistribution + outlier_color_distribution: PixelColorDistribution + + inlier_depth_distribution: PixelDepthDistributionForDepthReturn + outlier_depth_distribution: PixelDepthDistributionForDepthReturn + + @property + def inlier_distribution(self): + return PixelDistFromColorDistAndDepthReturnDist( + self.inlier_color_distribution, self.inlier_depth_distribution + ) + + @property + def outlier_distribution(self): + return PixelDistFromColorDistAndDepthReturnDist( + self.outlier_color_distribution, self.outlier_depth_distribution + ) + + def sample( + self, + key: PRNGKey, + latent_rgbd: FloatArray, + color_scale: float, + depth_scale: float, + visibility_prob: float, + depth_nonreturn_prob: float, + intrinsics: dict, + depth_nonreturn_prob_for_invisible: float, + ) -> FloatArray: + k1, k2, k3 = split(key, 3) + choose_to_be_invisible = jax.random.bernoulli(k1, visibility_prob) + return jnp.where( + jnp.logical_or(is_unexplained(latent_rgbd), choose_to_be_invisible), + self.inlier_distribution.sample( + k2, + latent_rgbd, + color_scale, + depth_scale, + depth_nonreturn_prob, + intrinsics, + ), + self.outlier_distribution.sample( + k3, + latent_rgbd, + color_scale, + depth_scale, + depth_nonreturn_prob_for_invisible, + intrinsics, + ), + ) + + @jax.jit + def logpdf( + self, + observed_rgbd: FloatArray, + latent_rgbd: FloatArray, + color_scale: float, + depth_scale: float, + visibility_prob: float, + depth_nonreturn_prob: float, + intrinsics: dict, + invisible_depth_nonreturn_prob: float, + ) -> float: + log_inlier_prob = self.inlier_distribution.logpdf( + observed_rgbd, + latent_rgbd, + color_scale, + depth_scale, + depth_nonreturn_prob, + intrinsics, + ) + log_outlier_prob = self.outlier_distribution.logpdf( + observed_rgbd, + latent_rgbd, + color_scale, + depth_scale, + invisible_depth_nonreturn_prob, + intrinsics, + ) + score_if_latent_is_valid = jnp.logaddexp( + jnp.log(visibility_prob) + log_inlier_prob, + jnp.log(1 - visibility_prob) + log_outlier_prob, + ) + return jnp.where( + is_unexplained(latent_rgbd), log_outlier_prob, score_if_latent_is_valid + ) diff --git a/src/b3d/chisight/gen3d/projection.py b/src/b3d/chisight/gen3d/projection.py new file mode 100644 index 00000000..ce151662 --- /dev/null +++ b/src/b3d/chisight/gen3d/projection.py @@ -0,0 +1,164 @@ +from functools import cached_property + +import jax.numpy as jnp +from genjax import Pytree +from genjax.typing import FloatArray, IntArray + +import b3d.utils + +# using this in combination with mode="drop" in the .at[] +# methods can help filter out vertices that are not visible in the image +INVALID_IDX = jnp.iinfo(jnp.int32).min # -2147483648 + + +@Pytree.dataclass +class PixelsPointsAssociation(Pytree): + """A utility class to associate 3D points with their projected 2D pixel.""" + + projected_pixel_coordinates: IntArray # (num_vertices, 2) + image_height: int + image_width: int + + @classmethod + def from_hyperparams_and_pose(cls, hyperparams, pose_CO): + """`pose_CO` is the same thing as `pose` in the model.""" + vertices_O = hyperparams["vertices"] + vertices_C = pose_CO.apply(vertices_O) + return cls.from_points_and_intrinsics( + vertices_C, + hyperparams["intrinsics"], + ) + + @classmethod + def from_points_and_intrinsics( + cls, points: FloatArray, intrinsics: dict + ) -> "PixelsPointsAssociation": + """Create a PixelsPointsAssociation object from a set of 3D points and + the camera intrinsics. + + Args: + points (FloatArray): The points/vertices in 3D space (num_vertices, 3). + intrinsics (dict): Camera intrinsics. + image_height (int): Height of the image. + image_width (int): Width of the image. + """ + projected_coords = jnp.rint( + b3d.utils.xyz_to_pixel_coordinates( + points, + intrinsics["fx"], + intrinsics["fy"], + intrinsics["cx"], + intrinsics["cy"], + ) + - 0.5 + ) + + image_height, image_width = ( + intrinsics["image_height"].unwrap(), + intrinsics["image_width"].unwrap(), + ) + + # handle NaN before converting to int (otherwise NaN will be converted + # to 0) + projected_coords = jnp.nan_to_num(projected_coords, nan=INVALID_IDX) + + # handle the case where the projected coordinates are outside the image + projected_coords = jnp.where( + projected_coords > 0, projected_coords, INVALID_IDX + ) + projected_coords = jnp.where( + projected_coords < jnp.array([image_height, image_width]), + projected_coords, + INVALID_IDX, + ) + + return cls(projected_coords.astype(jnp.int32), image_height, image_width) + + def __len__(self) -> int: + return self.projected_pixel_coordinates.shape[0] + + def shape(self) -> tuple[int, int]: + return self.projected_pixel_coordinates.shape + + @property + def x(self) -> IntArray: + return self.projected_pixel_coordinates[:, 0] + + @property + def y(self) -> IntArray: + return self.projected_pixel_coordinates[:, 1] + + def get_pixel_attributes(self, point_attributes: FloatArray) -> FloatArray: + """Given a (num_vertices, attribute_length) array of point attributes, + return a (image_height, image_width, attribute_length) array of attributes. + Pixels that don't hit a vertex will have a value filled with -1. + """ + return point_attributes.at[self.pixel_to_point_idx].get( + mode="drop", fill_value=-1 + ) + + def get_point_rgbds(self, rgbd_image: FloatArray) -> FloatArray: + """ + Get a (num_vertices, 4) array of RGBD values for each vertex + by indexing into the given image. + Vertices that don't hit a pixel will have a value of (-1, -1, -1, -1). + """ + return rgbd_image.at[self.x, self.y].get(mode="drop", fill_value=-1.0) + + def get_point_depths(self, rgbd_image: FloatArray) -> FloatArray: + """ + Get a (num_vertices,) array of depth values for each vertex + by indexing into the given image, or -1 if the vertex doesn't hit a pixel. + """ + return self.get_point_rgbds(rgbd_image)[..., 3] + + def get_point_rgbs(self, rgbd: FloatArray) -> FloatArray: + """ + Get a (num_vertices, 3) array of RGB values for each vertex + by indexing into the given image, or [-1, -1, -1] if the vertex doesn't hit a pixel. + """ + return self.get_point_rgbds(rgbd)[..., :3] + + @cached_property + def num_point_per_pixel(self) -> IntArray: + """Return a 2D array of shape (image_height, image_width) where each + element is the number of points that project to that pixel. + """ + counts = jnp.zeros((self.image_height, self.image_width), dtype=jnp.int32) + counts = counts.at[self.x, self.y].add(1, mode="drop") + return counts + + @cached_property + def pixel_to_point_idx(self) -> IntArray: + """Return a 2D array of shape (image_height, image_width) where each + element is the index of the point that projects to that pixel (if any). + If none of the points project to that pixel, the value is set to INVALID_IDX. + + Warning: this implementaion does not handle race condition. That is, if + multiple points project to the same pixel, this method will randomly + return one of them (the non-determinism is subject to GPU parallelism). + """ + registered_pixel_idx = jnp.full( + (self.image_height, self.image_width), INVALID_IDX, dtype=jnp.int32 + ) + registered_pixel_idx = registered_pixel_idx.at[self.x, self.y].set( + jnp.arange(len(self)) + ) + return registered_pixel_idx + + def get_pixel_idx(self, point_idx: int) -> IntArray: + return self.projected_pixel_coordinates[point_idx] + + def get_pixels_with_multiple_points(self) -> tuple[IntArray, IntArray]: + """Return a tuple of (x_coords, y_coords) of pixels that have more than + one vertices associated with them. Note that this method is not JIT-compatible + because the return values are not of fixed shape. + """ + return jnp.nonzero(self.num_point_per_pixel > 1) + + def get_one_latent_point_idx(self, pixel_x: int, pixel_y: int) -> int: + """Return the index of one of the points that project to the given pixel. + If there are multiple points, this method will return one of them randomly + (the non-determinism is subject to GPU parallelism). + """ + return self.pixel_to_point_idx[pixel_x, pixel_y] diff --git a/src/b3d/chisight/gen3d/run_ycbv_evaluation.py b/src/b3d/chisight/gen3d/run_ycbv_evaluation.py new file mode 100755 index 00000000..f8c18c62 --- /dev/null +++ b/src/b3d/chisight/gen3d/run_ycbv_evaluation.py @@ -0,0 +1,184 @@ +#!/usr/bin/env python + +import os +import pprint +from datetime import datetime +from pathlib import Path + +import fire +import jax +import jax.numpy as jnp +import rerun as rr +from tqdm import tqdm + +import b3d +import b3d.chisight.gen3d.inference.inference as inference +import b3d.chisight.gen3d.settings as settings +import b3d.chisight.gen3d.visualization as viz +from b3d import Pose +from b3d.chisight.gen3d.dataloading import ( + get_initial_state, + load_object_given_scene, + load_scene, +) +from b3d.chisight.gen3d.model import viz_trace as rr_viz_trace + + +def setup_save_directory(): + # Make a folder, stamped with the current time. + current_time = datetime.now().strftime("%Y-%m-%d--%H:%M:%S") + folder_name = ( + b3d.get_root_path() / "test_results" / "gen3d" / f"gen3d_{current_time}" + ) + Path(folder_name).mkdir(parents=True, exist_ok=True) + video_folder_name = folder_name / "mp4" + npy_folder_name = folder_name / "npy" + rr_folder_name = folder_name / "rr" + os.mkdir(rr_folder_name) + os.mkdir(video_folder_name) + os.mkdir(npy_folder_name) + return folder_name, video_folder_name, npy_folder_name, rr_folder_name + + +def save_hyperparams(folder_name, hyperparams, inference_hyperparams, script_kwargs): + hyperparams_file = folder_name / "hyperparams.txt" + with open(hyperparams_file, "w") as f: + f.write("Hyperparameters:\n") + f.write(pprint.pformat(hyperparams)) + f.write("\n\n\nInference Hyperparameters:\n") + f.write(pprint.pformat(inference_hyperparams)) + f.write("\n\n\nScript kwargs:\n") + f.write(pprint.pformat(script_kwargs)) + + +def run_tracking( + scene=None, + object=None, + live_rerun=False, + save_rerun=False, + use_gt_pose=False, + subdir="train_real", + max_n_frames=None, +): + kwargs = locals() + folder_name, video_folder_name, npy_folder_name, rr_folder_name = ( + setup_save_directory() + ) + print( + f""" +Folder Name: {folder_name} +Video Folder Name: {video_folder_name} +Npy Folder Name: {npy_folder_name} +RR Folder Name: {rr_folder_name} +""" + ) + + hyperparams = settings.hyperparams + inference_hyperparams = b3d.chisight.gen3d.settings.inference_hyperparams # noqa + save_hyperparams(folder_name, hyperparams, inference_hyperparams, kwargs) + + FRAME_RATE = 50 + + assert not ( + live_rerun and save_rerun + ), "Cannot save and live rerun at the same time" + + if live_rerun: + b3d.rr_init("run_ycbv_evaluation") + + if scene is None: + scenes = range(1, 80) + elif isinstance(scene, int): + scenes = [scene] + elif isinstance(scene, list): + scenes = scene + + for scene_id in scenes: + print(f"Scene {scene_id}") + all_data, meshes, renderer, intrinsics, initial_object_poses = load_scene( + scene_id, FRAME_RATE, subdir=subdir + ) + + object_indices = ( + [object] if object is not None else range(len(initial_object_poses)) + ) + for OBJECT_INDEX in object_indices: + print(f"Object {OBJECT_INDEX} out of {len(initial_object_poses) - 1}") + template_pose, model_vertices, model_colors = load_object_given_scene( + all_data, meshes, renderer, OBJECT_INDEX + ) + + hyperparams["intrinsics"] = intrinsics + hyperparams["vertices"] = model_vertices + initial_state = get_initial_state( + template_pose, model_vertices, model_colors, hyperparams + ) + + tracking_results = {} + + ### Run inference ### + def gt_pose(T): + return ( + all_data[T]["camera_pose"].inv() + @ all_data[T]["object_poses"][OBJECT_INDEX] + ) + + key = jax.random.PRNGKey(156) + trace = inference.get_initial_trace( + key, hyperparams, initial_state, all_data[0]["rgbd"] + ) + + if save_rerun: + b3d.rr_init(f"SCENE_{scene_id}_OBJECT_INDEX_{OBJECT_INDEX}") + rr.save( + rr_folder_name / f"SCENE_{scene_id}_OBJECT_INDEX_{OBJECT_INDEX}.rrd" + ) + + if max_n_frames is not None: + maxT = min(max_n_frames, len(all_data)) + else: + maxT = len(all_data) + + for T in tqdm(range(maxT)): + key = b3d.split_key(key) + trace, _ = inference.inference_step( + key, + trace, + all_data[T]["rgbd"], + inference_hyperparams, + gt_pose=gt_pose(T), + use_gt_pose=use_gt_pose, + ) + tracking_results[T] = trace + + if live_rerun or save_rerun: + rr_viz_trace( + trace, + T, + ground_truth_vertices=meshes[OBJECT_INDEX].vertices, + ground_truth_pose=gt_pose(T), + ) + + inferred_poses = Pose.stack_poses( + [tracking_results[t].get_choices()["pose"] for t in range(maxT)] + ) + jnp.savez( + npy_folder_name + / f"SCENE_{scene_id}_OBJECT_INDEX_{OBJECT_INDEX}_POSES.npy", + position=inferred_poses.position, + quaternion=inferred_poses.quat, + ) + + viz.make_video_from_traces( + [tracking_results[t] for t in range(maxT)], + video_folder_name / f"SCENE_{scene_id}_OBJECT_INDEX_{OBJECT_INDEX}.mp4", + scale=0.25, + ) + + if save_rerun: + rr.disconnect() + print("rerun disconnected") + + +if __name__ == "__main__": + fire.Fire(run_tracking) diff --git a/src/b3d/chisight/gen3d/settings.py b/src/b3d/chisight/gen3d/settings.py new file mode 100644 index 00000000..10f578f6 --- /dev/null +++ b/src/b3d/chisight/gen3d/settings.py @@ -0,0 +1,13 @@ +import b3d.chisight.gen3d.transition_kernels as transition_kernels +from b3d.chisight.gen3d.hyperparams import InferenceHyperparams + +hyperparams = { + "pose_kernel": transition_kernels.GaussianVMFPoseDriftKernel(0.02, 1000.0), + "color_noise_variance": 1.0, + "depth_noise_variance": 0.01, + "outlier_probability": 0.1, +} + +inference_hyperparams = InferenceHyperparams( + n_poses=2000, +) diff --git a/src/b3d/chisight/gen3d/transition_kernels.py b/src/b3d/chisight/gen3d/transition_kernels.py index e69de29b..b8a6853b 100644 --- a/src/b3d/chisight/gen3d/transition_kernels.py +++ b/src/b3d/chisight/gen3d/transition_kernels.py @@ -0,0 +1,39 @@ +from abc import abstractmethod + +import genjax +from genjax import Pytree +from genjax.typing import ArrayLike, PRNGKey + +from b3d import Pose + + +@Pytree.dataclass +class DriftKernel(genjax.ExactDensity): + """An abstract class that defines the common interface for drift kernels.""" + + @abstractmethod + def sample(self, key: PRNGKey, prev_value: ArrayLike) -> ArrayLike: + raise NotImplementedError + + @abstractmethod + def logpdf(self, new_value: ArrayLike, prev_value: ArrayLike) -> ArrayLike: + raise NotImplementedError + + +# Pose Drift Kernels + + +@Pytree.dataclass +class GaussianVMFPoseDriftKernel(DriftKernel): + std: float = Pytree.static() + concentration: float = Pytree.static() + + def sample(self, key: PRNGKey, prev_pose): + return Pose.sample_gaussian_vmf_pose_approx( + key, prev_pose, self.std, self.concentration + ) + + def logpdf(self, new_pose, prev_pose) -> ArrayLike: + return Pose.logpdf_gaussian_vmf_pose_approx( + new_pose, prev_pose, self.std, self.concentration + ) diff --git a/src/b3d/chisight/gen3d/uniform_distributions.py b/src/b3d/chisight/gen3d/uniform_distributions.py new file mode 100644 index 00000000..38da98ef --- /dev/null +++ b/src/b3d/chisight/gen3d/uniform_distributions.py @@ -0,0 +1,326 @@ +import genjax +import ipywidgets as widgets +import jax +import jax.numpy as jnp +import matplotlib.pyplot as plt +from genjax import Pytree, uniform +from ipywidgets import interact + + +@Pytree.dataclass +class Uniform(genjax.ExactDensity): + """ + A uniform distribution on the interval [min, max]. + """ + + min: float + max: float + + def sample(self, key): + return uniform.sample(key, self.min, self.max) + + def logpdf(self, x): + return jnp.where( + (self.min <= x) & (x <= self.max), + jnp.log(1 / (self.max - self.min)), + -jnp.inf, + ) + + def __getitem__(self, idx): + return Uniform(self.min[idx], self.max[idx]) + + +@Pytree.dataclass +class NiceTruncatedCenteredUniform(genjax.ExactDensity): + """ + This distribution, given a value `center`, "tries" to sample + uniformly from the interval [center - epsilon, center + epsilon], + without going outside the interval [min, max]. + + Specifically, the distribution is: + - If center <= min + epsilon, uniform from [min, min + 2 * epsilon] + - If center >= max - epsilon, uniform from [max - 2 * epsilon, max] + - Otherwise, uniform from [center - epsilon, center + epsilon] + + A nice feature of this distribution is that its PDF is always + either 0 or 1 / (2 * epsilon). + """ + + epsilon: float + min: float + max: float + + def __init__(self, epsilon, min, max): + isvalid = jnp.all(max - min >= 2 * epsilon) + self.epsilon = jnp.where(isvalid, epsilon, jnp.nan * jnp.ones_like(epsilon)) + self.min = jnp.where(isvalid, min, jnp.nan * jnp.ones_like(min)) + self.max = jnp.where(isvalid, max, jnp.nan * jnp.ones_like(max)) + + def __getitem__(self, idx): + return NiceTruncatedCenteredUniform( + self.epsilon[idx], self.min[idx], self.max[idx] + ) + + def _get_uniform_given_center(self, center): + is_near_bottom = center < self.min + self.epsilon + is_near_top = center > self.max - self.epsilon + minval = jnp.where( + is_near_bottom, + self.min, + jnp.where(is_near_top, self.max - 2 * self.epsilon, center - self.epsilon), + ) + maxval = jnp.where( + is_near_top, + self.max, + jnp.where( + is_near_bottom, self.min + 2 * self.epsilon, center + self.epsilon + ), + ) + return Uniform(minval, maxval) + + def sample(self, key, center): + return self._get_uniform_given_center(center).sample(key) + + def logpdf(self, x, center): + return self._get_uniform_given_center(center).logpdf(x) + + +@Pytree.dataclass +class MixtureOfUniforms(genjax.ExactDensity): + probs: jnp.ndarray + uniforms: Uniform # Batched pytree + + def sample(self, key): + k1, k2 = jax.random.split(key) + keys = jax.random.split(k1, len(self.probs)) + idx = genjax.categorical.sample(k2, jnp.log(self.probs)) + vals = jax.vmap(lambda key, uniform: uniform.sample(key))(keys, self.uniforms) + return vals[idx] + + def logpdf(self, x): + logpdfs_given_uniform = jax.vmap(lambda uniform: uniform.logpdf(x))( + self.uniforms + ) + joint_logpdfs_for_each_uniform = jnp.log(self.probs) + logpdfs_given_uniform + joint_logpdfs_for_each_uniform = jnp.nan_to_num( + joint_logpdfs_for_each_uniform, nan=-jnp.inf + ) + return jax.scipy.special.logsumexp(joint_logpdfs_for_each_uniform) + + +@Pytree.dataclass +class MixtureOfNiceTruncatedCenteredUniforms(genjax.ExactDensity): + probs: jnp.ndarray + ntcus: NiceTruncatedCenteredUniform # Batched pytree + + def sample(self, key, center): + k1, k2 = jax.random.split(key) + keys = jax.random.split(k1, len(self.probs)) + idx = genjax.categorical.sample(k2, jnp.log(self.probs)) + vals = jax.vmap(lambda key: self.ntcus.sample(key, center))(keys) + return vals[idx] + + def logpdf(self, x, center): + logpdfs_given_ntcu = jax.vmap(lambda ntcu: ntcu.logpdf(x, center))(self.ntcus) + joint_logpdfs_for_each_ntcu = jnp.log(self.probs) + logpdfs_given_ntcu + joint_logpdfs_for_each_ntcu = jnp.nan_to_num( + joint_logpdfs_for_each_ntcu, nan=-jnp.inf + ) + return jax.scipy.special.logsumexp(joint_logpdfs_for_each_ntcu) + + +def prior_and_obsmodel_are_compatible( + prior: Uniform, + obsmodel: NiceTruncatedCenteredUniform, +): + """ + Checks that the assumptions of the posterior functions are met. + """ + return jnp.logical_and(obsmodel.min <= prior.min, obsmodel.max >= prior.max) + + +def get_posterior_for_uniform_prior_ntcu_obs( + prior: Uniform, obsmodel: NiceTruncatedCenteredUniform, obs: float +) -> Uniform: + """ + Given that under P, x ~ prior and y ~ obsmodel(x), this returns the posterior P(x | y). + """ + assumptions_are_met = prior_and_obsmodel_are_compatible(prior, obsmodel) + minval = jnp.maximum(prior.min, obs - obsmodel.epsilon) + maxval = jnp.minimum(prior.max, obs + obsmodel.epsilon) + + # If the assumptions under which this posterior was derived are not + # met, return a distribution with NaNs to warn the user. + # Also return nans if P(obs) = 0. + isvalid = assumptions_are_met & (minval <= maxval) + minval = jnp.where(isvalid, minval, jnp.nan) + maxval = jnp.where(isvalid, maxval, jnp.nan) + + return Uniform(minval, maxval) + + +def get_marginal_probability_of_obs_for_uniform_prior_ntcu_obs( + prior: Uniform, obsmodel: NiceTruncatedCenteredUniform, obs: float +) -> float: + """ + Given that under P, x ~ prior and y ~ obsmodel(x), this returns the marginal + probability P(y = obs). + """ + posterior = get_posterior_for_uniform_prior_ntcu_obs(prior, obsmodel, obs) + pobs_is_0 = jnp.isnan(posterior.min) + region_size = posterior.max - posterior.min + joint_pdf = 1 / (prior.max - prior.min) * 1 / (2 * obsmodel.epsilon) + return jnp.where(pobs_is_0, 0.0, region_size * joint_pdf) + + +def get_posterior_from_mix_of_uniform_prior_and_mix_of_nctus_obs( + prior: MixtureOfUniforms, + obsmodel: MixtureOfNiceTruncatedCenteredUniforms, + obs: float, +) -> MixtureOfUniforms: + """ + Given that under P, x ~ prior and y ~ obsmodel(x), this returns the posterior P(x | y). + """ + all_ij_pairs = all_pairs( + jnp.arange(len(prior.probs)), jnp.arange(len(obsmodel.probs)) + ) + + # Shape: (len(prior.probs), len(obsmodel.probs)) + p_obs_given_branch = jax.vmap( + lambda ij: get_marginal_probability_of_obs_for_uniform_prior_ntcu_obs( + prior.uniforms[ij[0]], obsmodel.ntcus[ij[1]], obs + ) + )(all_ij_pairs) + + prior_probs_of_branches = jax.vmap( + lambda ij: prior.probs[ij[0]] * obsmodel.probs[ij[1]] + )(all_ij_pairs) + + joint_probs_of_branches = prior_probs_of_branches * p_obs_given_branch + posterior_probs_of_branches = joint_probs_of_branches / jnp.sum( + joint_probs_of_branches + ) + + uniform_dists_per_branch = jax.vmap( + lambda ij: get_posterior_for_uniform_prior_ntcu_obs( + prior.uniforms[ij[0]], obsmodel.ntcus[ij[1]], obs + ) + )(all_ij_pairs) + + return MixtureOfUniforms(posterior_probs_of_branches, uniform_dists_per_branch) + + +### Util ### +def all_pairs(X, Y): + """ + Return an array `ret` of shape (|X| * |Y|, 2) where each row + is a pair of values from X and Y. + That is, `ret[i, :]` is a pair [x, y] for some x in X and y in Y. + """ + return jnp.swapaxes(jnp.stack(jnp.meshgrid(X, Y), axis=-1), 0, 1).reshape(-1, 2) + + +### IPy vizualization ### + + +def create_interactive_posterior_viz( + prior, + obs_model, + prior_min, + prior_max, + obs_min, + obs_max, + get_exact_posterior_pdf, # (obs, latent) -> pdf + get_enum_posterior_pdf=None, # (obs, gridpoints) -> approx pdf at each gridpoint +): + if get_enum_posterior_pdf is None: + + def get_enum_posterior_pdf(obs, gridpoints): + return _get_enum_posterior_pdf(prior, obs_model, obs, gridpoints) + + # Define the grid for prior and observation + grid_latent = jnp.linspace(prior_min, prior_max, 1001) + grid_obs = jnp.linspace(obs_min, obs_max, 1001) + + # Compute the prior densities on the latent grid + prior_pdf = jnp.exp(jax.vmap(prior.logpdf)(grid_latent)) + + # Set up the widgets for latent and observed values + latent_slider = widgets.FloatSlider( + min=prior_min, max=prior_max, step=0.01, description="Latent Value" + ) + obs_slider = widgets.FloatSlider( + min=obs_min, max=obs_max, step=0.01, description="Observed Value" + ) + + # Function to update the plots + def update_plots(latent_value, obs_value): + # Clear the current figure + plt.figure(figsize=(10, 8)) + + # Top half: Prior and observation model + plt.subplot(2, 1, 1) + plt.title("Prior and Observation Model") + + # Prior plot with latent value line + plt.plot(grid_latent, prior_pdf, label="Prior PDF", color="blue") + plt.axvline(x=latent_value, color="red", linestyle="--", label="Latent Value") + plt.legend() + plt.ylabel("Density") + + # Observation model at latent value + obs_pdf = jnp.exp( + jax.vmap(lambda obs: obs_model.logpdf(obs, latent_value))(grid_obs) + ) + plt.plot(grid_obs, obs_pdf, label="Observation PDF", color="green") + plt.axvline(x=obs_value, color="orange", linestyle="--", label="Observed Value") + plt.legend() + + # Bottom half: Posterior distribution + plt.subplot(2, 1, 2) + plt.title("Posterior Distributions") + + plt.plot(grid_latent, prior_pdf, label="Prior PDF", color="blue") + + # Exact posterior based on the observed value + exact_posterior_pdf = jax.vmap( + lambda latent: get_exact_posterior_pdf(obs_value, latent) + )(grid_latent) + plt.plot(grid_latent, exact_posterior_pdf, label="Exact Posterior", color="red") + plt.axvline(x=obs_value, color="orange", linestyle="--", label="Observed Value") + + # Enumeration-based posterior (if provided) + if get_enum_posterior_pdf: + tight_grid_latent = jnp.linspace(prior_min, prior_max, 1000001) + enum_posterior_pdf_tight = get_enum_posterior_pdf( + obs_value, tight_grid_latent + ) + plot_enum_posterior_pdf = enum_posterior_pdf_tight[::1000] + plt.plot( + grid_latent, + plot_enum_posterior_pdf, + label="Enumeration Posterior", + color="purple", + linestyle="--", + ) + + plt.legend() + plt.xlabel("Value") + plt.ylabel("Density") + + plt.tight_layout() + plt.show() + + interact(update_plots, latent_value=latent_slider, obs_value=obs_slider) + + +def _get_enum_posterior_pdf(prior, obs_model, obs, gridpoints): + prior_vals = jnp.exp(jax.vmap(prior.logpdf)(gridpoints)) + obs_vals_given_latent = jnp.exp( + jax.vmap(obs_model.logpdf, in_axes=(None, 0))(obs, gridpoints) + ) + joint_pdf = prior_vals * obs_vals_given_latent + posterior_prob_per_point = joint_pdf / jnp.sum(joint_pdf) + distance_between_points = gridpoints[1] - gridpoints[0] + posterior_pdf = posterior_prob_per_point / distance_between_points + return posterior_pdf diff --git a/src/b3d/chisight/gen3d/visualization.py b/src/b3d/chisight/gen3d/visualization.py new file mode 100644 index 00000000..821d98db --- /dev/null +++ b/src/b3d/chisight/gen3d/visualization.py @@ -0,0 +1,221 @@ +import ipywidgets as widgets +import jax +import jax.numpy as jnp +import matplotlib.pyplot as plt +from ipywidgets import interact +from matplotlib.gridspec import GridSpec + +import b3d + + +def plot_samples( + samples, + observed_rgbd_for_point, + latent_rgbd_for_point, + previous_color, + previous_visibility_prob, + previous_dnrp, + color_scale, +): + fig = plt.figure(layout="constrained", figsize=(10, 10)) + gs = GridSpec(3, 3, figure=fig) + + fig.suptitle(f"Observed RGBD: {observed_rgbd_for_point}", fontsize=16) + rgb = samples["colors"] + visibility_prob = samples["visibility_prob"] + dnr_prob = samples["depth_nonreturn_prob"] + + ax = fig.add_subplot(gs[0, 0]) + values, counts = jnp.unique(visibility_prob, return_counts=True) + ax.bar(values, counts) + ax.set_xticks(values) + ax.set_title("Visibility Probability Samples") + + ax = fig.add_subplot(gs[0, 1]) + values, counts = jnp.unique(dnr_prob, return_counts=True) + ax.bar(values, counts) + ax.set_xticks(values) + ax.set_title("Depth Nonreturn Probability Samples") + + ax = fig.add_subplot(gs[0, 2]) + # ax.set_xlim(0.0, 2.0) + ax.set_title("Depth") + ax.axvline( + x=observed_rgbd_for_point[3], color="black", linestyle="--", label="Observed" + ) + ax.axvline( + x=latent_rgbd_for_point[3], color="black", linestyle="dotted", label="Latent" + ) + ax.legend() + + ax = fig.add_subplot(gs[1, 0]) + ax.hist(rgb[:, 0], jnp.linspace(0, 1, 100), color="r") + ax.set_title("R Samples") + ax.axvline(x=observed_rgbd_for_point[0], color="black", linestyle="--") + ax.axvline(x=previous_color[0], color="black", linestyle="dotted") + + ax = fig.add_subplot(gs[1, 1]) + ax.hist(rgb[:, 1], jnp.linspace(0, 1, 100), color="g") + ax.set_title("G Samples") + ax.axvline(x=observed_rgbd_for_point[1], color="black", linestyle="--") + ax.axvline(x=previous_color[1], color="black", linestyle="dotted") + + ax = fig.add_subplot(gs[1, 2]) + ax.hist(rgb[:, 2], jnp.linspace(0, 1, 100), color="b") + ax.set_title("B Samples") + ax.axvline( + x=observed_rgbd_for_point[2], color="black", linestyle="--", label="Observed" + ) + ax.axvline(x=previous_color[2], color="black", linestyle="dotted", label="Previous") + ax.legend() + + +def create_interactive_visualization( + observed_rgbd_for_point, + latent_rgbd_for_point, + hyperparams, + inference_hyperparams, + previous_color, + previous_visibility_prob, + previous_dnrp, + attribute_proposal_function, +): + key = jax.random.PRNGKey(0) + + color_scale_kernel = hyperparams["color_scale_kernel"] + depth_scale_kernel = hyperparams["depth_scale_kernel"] + + def f( + observed_r, + observed_g, + observed_b, + observed_d, + color_scale, + depth_scale, + ): + _observed_rgbd_for_point = jnp.array( + [observed_r, observed_g, observed_b, observed_d] + ) + samples = jax.vmap(attribute_proposal_function, in_axes=(0, *(None,) * 9))( + jax.random.split(key, 100), + _observed_rgbd_for_point, + latent_rgbd_for_point, + previous_color, + previous_visibility_prob, + previous_dnrp, + color_scale, + depth_scale, + hyperparams, + inference_hyperparams, + ) + plot_samples( + samples, + _observed_rgbd_for_point, + latent_rgbd_for_point, + previous_color, + previous_visibility_prob, + previous_dnrp, + color_scale, + ) + + interact( + f, + color_scale=widgets.FloatSlider( + value=color_scale_kernel.support.min(), + min=color_scale_kernel.support.min(), + max=color_scale_kernel.support.max(), + step=0.001, + description="Color Scale:", + disabled=False, + continuous_update=False, + orientation="horizontal", + readout=True, + readout_format=".4f", + ), + depth_scale=widgets.FloatSlider( + value=depth_scale_kernel.support.min(), + min=depth_scale_kernel.support.min(), + max=depth_scale_kernel.support.max(), + step=0.0005, + description="Depth Scale:", + disabled=False, + continuous_update=False, + orientation="horizontal", + readout=True, + readout_format=".4f", + ), + observed_r=widgets.FloatSlider( + value=observed_rgbd_for_point[0], + min=0.0, + max=1.0, + step=0.01, + description="Observed R:", + disabled=False, + continuous_update=False, + orientation="horizontal", + readout=True, + readout_format=".2f", + ), + observed_g=widgets.FloatSlider( + value=observed_rgbd_for_point[1], + min=0.0, + max=1.0, + step=0.01, + description="Observed G:", + disabled=False, + continuous_update=False, + orientation="horizontal", + readout=True, + readout_format=".2f", + ), + observed_b=widgets.FloatSlider( + value=observed_rgbd_for_point[2], + min=0.0, + max=1.0, + step=0.01, + description="Observed B:", + disabled=False, + continuous_update=False, + orientation="horizontal", + readout=True, + readout_format=".2f", + ), + observed_d=widgets.FloatSlider( + value=observed_rgbd_for_point[3], + min=-1.0, + max=hyperparams["intrinsics"]["far"], + step=0.01, + description="Observed Depth:", + disabled=False, + continuous_update=False, + orientation="horizontal", + readout=True, + readout_format=".2f", + ), + ) + + +# Make video + + +def make_video_from_traces(traces, output_filename, scale=0.2, fps=5.0): + images = [] + for trace in traces: + latent_rgb = b3d.chisight.gen3d.image_kernel.get_latent_rgb_image( + trace.get_retval()["new_state"], trace.get_args()[0] + ) + + a = b3d.scale_image( + b3d.viz_rgb( + trace.get_choices()["rgbd"][..., :3], + ), + scale, + ) + b = b3d.scale_image( + b3d.viz_rgb( + latent_rgb[..., :3], + ), + scale, + ) + images.append(b3d.multi_panel([a, b, b3d.overlay_image(a, b)])) + b3d.utils.make_video_from_pil_images(images, output_filename, fps=fps) diff --git a/src/b3d/chisight/particle_system.py b/src/b3d/chisight/particle_system.py index 9b6790fd..f77fee5c 100644 --- a/src/b3d/chisight/particle_system.py +++ b/src/b3d/chisight/particle_system.py @@ -26,14 +26,14 @@ def initial_particle_system_state( ): relative_particle_poses = ( dummy_mapped_uniform_pose( - jnp.arange(num_particles.const), *relative_particle_poses_prior_params + jnp.arange(num_particles.unwrap()), *relative_particle_poses_prior_params ) @ "particle_poses" ) object_assignments = ( b3d.modeling_utils.categorical.vmap(in_axes=(0,))( - jnp.zeros((num_particles.const, num_clusters.const)) + jnp.zeros((num_particles.unwrap(), num_clusters.unwrap())) ) @ "object_assignments" ) @@ -41,7 +41,7 @@ def initial_particle_system_state( # Cluster pose in world coordinates initial_object_poses = ( dummy_mapped_uniform_pose( - jnp.arange(num_clusters.const), *initial_object_poses_prior_params + jnp.arange(num_clusters.unwrap()), *initial_object_poses_prior_params ) @ "object_poses" ) @@ -59,7 +59,7 @@ def initial_particle_system_state( # Initial visibility mask initial_vis_mask = ( b3d.modeling_utils.bernoulli.vmap(in_axes=(0,))( - jnp.repeat(jax.scipy.special.logit(0.5), num_particles.const) + jnp.repeat(jax.scipy.special.logit(0.5), num_particles.unwrap()) ) @ "initial_visibility" ) @@ -101,7 +101,7 @@ def particle_system_state_step(carried_state, _): # Visibility mask vis_mask = ( b3d.modeling_utils.bernoulli.vmap(in_axes=(0,))( - jnp.repeat(jax.scipy.special.logit(0.5), num_particles.const) + jnp.repeat(jax.scipy.special.logit(0.5), num_particles.unwrap()) ) @ "visibility" ) @@ -146,7 +146,7 @@ def latent_particle_model( ) final_state, scan_retvals = ( - particle_system_state_step.scan(n=(num_timesteps.const - 1))(state0, None) + particle_system_state_step.scan(n=(num_timesteps.unwrap() - 1))(state0, None) @ "states1+" ) @@ -164,7 +164,7 @@ def sparse_observation_model( ): # TODO: add visibility uv = b3d.camera.screen_from_world( - particle_absolute_poses.pos, camera_pose, instrinsics.const + particle_absolute_poses.pos, camera_pose, instrinsics.unwrap() ) uv_ = ( b3d.modeling_utils.normal(uv, jnp.tile(sigma, uv.shape)) @ "sensor_coordinates" @@ -248,7 +248,7 @@ def visualize_particle_system( camera_pose = particle_dynamics_summary["camera_pose"] object_assignments = static_state[0] - cluster_colors = jnp.array(b3d.distinct_colors(num_clusters.const)) + cluster_colors = jnp.array(b3d.distinct_colors(num_clusters.unwrap())) rr.log( f"{viz_prefix}/3D", @@ -266,7 +266,7 @@ def visualize_particle_system( timeless=True, ) - for t in range(num_timesteps.const): + for t in range(num_timesteps.unwrap()): rr.set_time_sequence("time", t) cam_pose = camera_pose[t] @@ -286,7 +286,7 @@ def visualize_particle_system( ), ) - for i in range(num_clusters.const): + for i in range(num_clusters.unwrap()): b3d.rr_log_pose(f"{viz_prefix}/3D/cluster/{i}", object_poses[t][i]) @@ -302,7 +302,7 @@ def particle_2d_pixel_coordinates_to_image(pixel_coords, image_height, image_wid def visualize_sparse_observation(sparse_model_args, observations): import rerun as rr - intrinsics = sparse_model_args[0].const + intrinsics = sparse_model_args[0].unwrap() for t in range(observations.shape[0]): rr.set_time_sequence("time", t) @@ -338,7 +338,7 @@ def visualize_dense_gps( timeless=True, ) - for t in range(num_timesteps.const): + for t in range(num_timesteps.unwrap()): rr.set_time_sequence("time", t) poses = particle_dynamics_summary["absolute_particle_poses"][t] for i in range(len(meshes)): diff --git a/src/b3d/chisight/patch_tracking.py b/src/b3d/chisight/patch_tracking.py index 94d8e889..9910d763 100644 --- a/src/b3d/chisight/patch_tracking.py +++ b/src/b3d/chisight/patch_tracking.py @@ -90,7 +90,7 @@ def get_adam_optimization_patch_tracker(model, patches, pose_WC=Pose.identity()) """ def allidx_chm(x): - return genjax.ChoiceMap.idx(jnp.arange(x.shape[0], dtype=int), x) + return C[jnp.arange(x.shape[0], dtype=int)].set(x) @jax.jit def importance_from_pos_quat(positions, quaternions, observed_rgbd): @@ -118,14 +118,14 @@ def importance_from_pos_quat(positions, quaternions, observed_rgbd): ) particle_poses = jax.tree.map( - lambda arr: jnp.tile(arr, (num_particles.const, 1)), Pose.identity() + lambda arr: jnp.tile(arr, (num_particles.unwrap(), 1)), Pose.identity() ) - object_assignments = jnp.arange(num_particles.const, dtype=int) + object_assignments = jnp.arange(num_particles.unwrap(), dtype=int) object_poses = jax.vmap( lambda pos, quat: Pose.from_vec(jnp.concatenate([pos, quat])), in_axes=(0, 0), )(positions, quaternions) - vis_mask = jnp.ones((num_particles.const,), dtype=int) + vis_mask = jnp.ones((num_particles.unwrap(),), dtype=int) constraints = C.d( { diff --git a/src/b3d/io/data_loader.py b/src/b3d/io/data_loader.py index b771aa4f..70419c92 100644 --- a/src/b3d/io/data_loader.py +++ b/src/b3d/io/data_loader.py @@ -8,12 +8,14 @@ import imageio import jax import jax.numpy as jnp -import liblzfse # https://pypi.org/project/pyliblzfse/ + +# import liblzfse # https://pypi.org/project/pyliblzfse/ import numpy as np from natsort import natsorted from PIL import Image from tqdm import tqdm +import b3d from b3d.mesh import Mesh from b3d.pose import Pose @@ -84,12 +86,11 @@ def get_pose_object_info_from_dict(d, cam_pose): ) -def get_ycbv_num_test_images(ycb_dir, scene_id): +def get_ycbv_num_images(scene_id, subdir="test"): + ycb_dir = os.path.join(b3d.utils.get_assets_path(), f"bop/ycbv/{subdir}") scene_id = str(scene_id).rjust(6, "0") - - data_dir = os.path.join(ycb_dir, "test") scene_data_dir = os.path.join( - data_dir, scene_id + ycb_dir, scene_id ) # depth, mask, mask_visib, rgb; scene_camera.json, scene_gt_info.json, scene_gt.json scene_rgb_images_dir = os.path.join(scene_data_dir, "rgb") @@ -101,10 +102,10 @@ def get_ycbv_num_test_images(ycb_dir, scene_id): ) -def get_ycbv_test_images(ycb_dir, scene_id, images_indices, fields=[]): +def get_ycbv_data(scene_id, images_indices, fields=[], subdir="train_real"): scene_id = str(scene_id).rjust(6, "0") + data_dir = os.path.join(b3d.utils.get_assets_path(), f"bop/ycbv/{subdir}") - data_dir = os.path.join(ycb_dir, "test") scene_data_dir = os.path.join( data_dir, scene_id ) # depth, mask, mask_visib, rgb; scene_camera.json, scene_gt_info.json, scene_gt.json diff --git a/src/b3d/mesh.py b/src/b3d/mesh.py index 4b399db6..4000bcd5 100644 --- a/src/b3d/mesh.py +++ b/src/b3d/mesh.py @@ -163,7 +163,8 @@ def transform(self, pose): return transform_mesh(self, pose) def __repr__(self) -> str: - return f"Mesh(vertices={self.vertices.shape[:-1]}, faces={self.faces.shape[:-1]}, vertex_attributes={self.vertex_attributes.shape[:-1]})" + # return f"Mesh(vertices={self.vertices.shape[:-1]}, faces={self.faces.shape[:-1]}, vertex_attributes={self.vertex_attributes.shape[:-1]})" + return f"Mesh(vertices={self.vertices}, faces={self.faces}, vertex_attributes={self.vertex_attributes})" def __len__(self): # assert len(self.vertices.shape) == 3, "This is not a batched mesh object." @@ -183,8 +184,11 @@ def __getitem__(self, index): def rr_visualize(self, channel): rr_visualize_mesh(channel, self) - def scale(self, scale): - return Mesh(self.vertices * scale, self.faces, self.vertex_attributes) + def scale(self, scale) -> "Mesh": + self.vertices = self.vertices.at[:, 0].multiply(scale[0]) + self.vertices = self.vertices.at[:, 1].multiply(scale[1]) + self.vertices = self.vertices.at[:, 2].multiply(scale[2]) + return Mesh(self.vertices, self.faces, self.vertex_attributes) @staticmethod def cube_mesh(dimensions=jnp.ones(3), color=jnp.array([1.0, 0.0, 0.0])): diff --git a/src/b3d/modeling_utils.py b/src/b3d/modeling_utils.py index 4d21a832..4e9d72f7 100644 --- a/src/b3d/modeling_utils.py +++ b/src/b3d/modeling_utils.py @@ -1,16 +1,128 @@ +import itertools +import warnings +from functools import partial + import genjax import jax import jax.numpy as jnp +from genjax import Pytree from tensorflow_probability.substrates import jax as tfp from b3d.pose import ( logpdf_gaussian_vmf_pose, logpdf_uniform_pose, + logpdf_uniform_scale, sample_gaussian_vmf_pose, sample_uniform_pose, + sample_uniform_scale, ) +############################ +#### compute the volume #### +############################ +@jax.jit +def ray_intersects_triangle(p0, d, v0, v1, v2): + epsilon = 1e-6 + e1 = v1 - v0 + e2 = v2 - v0 + h = jnp.cross(d, e2) + a = jnp.dot(e1, h) + parallel = jnp.abs(a) < epsilon + f = 1.0 / a + s = p0 - v0 + u = f * jnp.dot(s, h) + valid_u = (u >= 0.0) & (u <= 1.0) + q = jnp.cross(s, e1) + v = f * jnp.dot(d, q) + valid_v = (v >= 0.0) & (u + v <= 1.0) + t = f * jnp.dot(e2, q) + valid_t = t > epsilon + intersects = (~parallel) & valid_u & valid_v & valid_t + return intersects + + +@jax.jit +def point_in_mesh(point, vertices, faces): + ray_direction = jnp.array([1.0, 0.0, 0.0]) # Arbitrary direction + v0 = vertices[faces[:, 0]] + v1 = vertices[faces[:, 1]] + v2 = vertices[faces[:, 2]] + + intersects = jax.vmap(ray_intersects_triangle, in_axes=(None, None, 0, 0, 0))( + point, ray_direction, v0, v1, v2 + ) + num_intersections = jnp.sum(intersects) + return num_intersections % 2 == 1 # Inside if odd number of intersections + + +def min_max_coord(vertices): + min_coords = jnp.min(vertices, axis=0) + max_coords = jnp.max(vertices, axis=0) + return min_coords, max_coords + + +@partial(jax.jit, static_argnames=["num_samples"]) +def monte_carlo_intersection_volume( + mesh1_vertices, mesh1_faces, mesh2_vertices, mesh2_faces, num_samples, key +): + min_coords1, max_coords1 = min_max_coord(mesh1_vertices) + min_coords2, max_coords2 = min_max_coord(mesh2_vertices) + + min_coords = jnp.maximum(min_coords1, min_coords2) + max_coords = jnp.minimum(max_coords1, max_coords2) + + overlap = jnp.all(min_coords < max_coords) + bbox_volume = jnp.prod(max_coords - min_coords) + + def sample_points(key): + subkey_x, subkey_y, subkey_z = jax.random.split(key, 3) + x = jax.random.uniform( + subkey_x, shape=(num_samples,), minval=min_coords[0], maxval=max_coords[0] + ) + y = jax.random.uniform( + subkey_y, shape=(num_samples,), minval=min_coords[1], maxval=max_coords[1] + ) + z = jax.random.uniform( + subkey_z, shape=(num_samples,), minval=min_coords[2], maxval=max_coords[2] + ) + points = jnp.stack([x, y, z], axis=1) + return points + + points = sample_points(key) + + point_in_mesh_vmap = jax.vmap(point_in_mesh, in_axes=(0, None, None)) + + in_mesh1 = point_in_mesh_vmap(points, mesh1_vertices, mesh1_faces) + in_mesh2 = point_in_mesh_vmap(points, mesh2_vertices, mesh2_faces) + in_both_meshes = in_mesh1 & in_mesh2 + + hits = jnp.sum(in_both_meshes) + intersection_volume = (hits / num_samples) * bbox_volume * overlap + return intersection_volume + + +def get_interpenetration(mesh_seq, num_samples): + interpenetrations = [] + for ct, pair in enumerate(list(itertools.combinations(mesh_seq, 2))): + m1, m2 = pair + # Monte Carlo parameters + key = jax.random.PRNGKey(ct) # Random seed + # Compute intersection volume + intersection_volume = monte_carlo_intersection_volume( + m1.vertices, m1.faces, m2.vertices, m2.faces, num_samples, key + ) + interpenetrations.append(intersection_volume) + + # floor interpenetration approximation + for mesh in mesh_seq: + bottom = mesh.vertices[:, 1].min() + interpenetrations.append(jnp.where(bottom < 0, abs(bottom), 0)) + # if bottom < 0: + # interpenetrations.append(abs(bottom)) + return jnp.array(interpenetrations).sum() + + @jax.jit def sample_uniform_broadcasted(key, low, high): return genjax.uniform.sample(key, low, high) @@ -26,12 +138,12 @@ def logpdf_uniform_broadcasted(values, low, high): sample_uniform_broadcasted, logpdf_uniform_broadcasted ) - uniform_discrete = genjax.exact_density( lambda key, vals: jax.random.choice(key, vals), lambda sampled_val, vals: jnp.log(1.0 / (vals.shape[0])), ) uniform_pose = genjax.exact_density(sample_uniform_pose, logpdf_uniform_pose) +uniform_scale = genjax.exact_density(sample_uniform_scale, logpdf_uniform_scale) vmf = genjax.exact_density( lambda key, mean, concentration: tfp.distributions.VonMisesFisher( @@ -45,6 +157,8 @@ def logpdf_uniform_broadcasted(values, low, high): gaussian_vmf = genjax.exact_density(sample_gaussian_vmf_pose, logpdf_gaussian_vmf_pose) ### Below are placeholders for genjax functions which are currently buggy ### +## TODO: these bugs in genjax should now be fixed, so we should be able to +# remove these. # There is currently a bug in `genjax.uniform.logpdf`; this `uniform` # can be used instead until a fix is pushed. @@ -71,3 +185,206 @@ def logpdf(v, *args, **kwargs): ) bernoulli = tfp_distribution(lambda logits: tfp.distributions.Bernoulli(logits=logits)) normal = tfp_distribution(tfp.distributions.Normal) + + +### + + +@Pytree.dataclass +class RenormalizedLaplace(genjax.ExactDensity): + @jax.jit + def sample(self, key, loc, scale, low, high): + warnings.warn( + "RenormalizedLaplace sampling is currently not implemented perfectly." + ) + x = tfp.distributions.Laplace(loc, scale).sample(seed=key) + return jnp.clip(x, low, high) + + @jax.jit + def logpdf(self, obs, loc, scale, low, high): + laplace_logpdf = tfp.distributions.Laplace(loc, scale).log_prob(obs) + p_below_low = tfp.distributions.Laplace(loc, scale).cdf(low) + p_below_high = tfp.distributions.Laplace(loc, scale).cdf(high) + log_integral_of_laplace_pdf_within_this_range = jnp.log( + p_below_high - p_below_low + ) + logpdf_if_in_range = ( + laplace_logpdf - log_integral_of_laplace_pdf_within_this_range + ) + + return jnp.where( + jnp.logical_and(obs >= low, obs <= high), + logpdf_if_in_range, + -jnp.inf, + ) + + +renormalized_laplace = RenormalizedLaplace() + + +@Pytree.dataclass +class RenormalizedColorLaplace(genjax.ExactDensity): + @jax.jit + def sample(self, key, loc, scale): + return jax.vmap( + lambda k, c: renormalized_laplace.sample(k, c, scale, 0.0, 1.0), + )(jax.random.split(key, loc.shape[0]), loc) + + @jax.jit + def logpdf(self, obs, loc, scale): + return jax.vmap( + lambda o, c: renormalized_laplace.logpdf(o, c, scale, 0.0, 1.0), + )(obs, loc).sum() + + +renormalized_color_laplace = RenormalizedColorLaplace() + +### Mixture distribution combinator ### + + +@Pytree.dataclass +class PythonMixtureDistribution(genjax.ExactDensity): + """ + Mixture of different distributions. + Constructor: + - dists : python list of N genjax.ExactDensity objects + + Distribution args: + - probs : (N,) array of branch probabilities + - args : python list of argument tuples, so that + `dists[i].sample(key, *args[i])` is valid for each i + """ + + dists: any = genjax.Pytree.static() + + def sample(self, key, probs, args): + values = [] + for i, dist in enumerate(self.dists): + key, subkey = jax.random.split(key) + values.append(dist.sample(subkey, *args[i])) + values = jnp.array(values) + key, subkey = jax.random.split(key) + component = genjax.categorical.sample(subkey, jnp.log(probs)) + return values[component] + + def logpdf(self, observed, probs, args): + logprobs = [] + for i, dist in enumerate(self.dists): + lp = dist.logpdf(observed, *args[i]) + logprobs.append(lp + jnp.log(probs[i])) + logprobs = jnp.stack(logprobs) + return jax.scipy.special.logsumexp(logprobs) + + +### Truncated laplace distribution, and mapped version for RGB ### + + +@Pytree.dataclass +class TruncatedLaplace(genjax.ExactDensity): + """ + This is a distribution on the interval (low, high). + The generative process is: + 1. Sample x ~ laplace(loc, scale). + 2. If x < low, sample y ~ uniform(low, low + uniform_window_size) and return y. + 3. If x > high, sample y ~ uniform(high - uniform_window_size, high) and return y. + 4. Otherwise, return x. + + Args: + - loc: float + - scale: float + - low: float + - high: float + - uniform_window_size: float + + Support: + - x in (low, high) [a float] + """ + + def sample(self, key, loc, scale, low, high, uniform_window_size): + isvalid = jnp.logical_and( + low < high, low + uniform_window_size < high - uniform_window_size + ) + k1, k2 = jax.random.split(key, 2) + x = tfp.distributions.Laplace(loc, scale).sample(seed=k1) + u = jax.random.uniform(k2, ()) * uniform_window_size + return jnp.where( + isvalid, + jnp.where( + x > high, high - uniform_window_size + u, jnp.where(x < low, low + u, x) + ), + jnp.nan, + ) + + def logpdf(self, obs, loc, scale, low, high, uniform_window_size): + isvalid = jnp.logical_and( + low < high, low + uniform_window_size < high - uniform_window_size + ) + laplace_logpdf = tfp.distributions.Laplace(loc, scale).log_prob(obs) + laplace_logp_below_low = tfp.distributions.Laplace(loc, scale).log_cdf(low) + laplace_logp_above_high = tfp.distributions.Laplace( + loc, scale + ).log_survival_function(high) + log_window_size = jnp.log(uniform_window_size) + + score = jnp.where( + jnp.logical_or(obs < low, obs > high), + -jnp.inf, + jnp.where( + jnp.logical_and( + low + uniform_window_size < obs, obs < high - uniform_window_size + ), + laplace_logpdf, + jnp.where( + obs < low + uniform_window_size, + jnp.logaddexp( + laplace_logp_below_low - log_window_size, laplace_logpdf + ), + jnp.logaddexp( + laplace_logp_above_high - log_window_size, laplace_logpdf + ), + ), + ), + ) + return jnp.where(isvalid, score, -jnp.inf) + + +truncated_laplace = TruncatedLaplace() + +_FIXED_COLOR_UNIFORM_WINDOW = 1 / 255 +_FIXED_DEPTH_UNIFORM_WINDOW = 0.01 + + +@Pytree.dataclass +class TruncatedColorLaplace(genjax.ExactDensity): + """ + Args: + - loc: (3,) array (loc for R, G, B channels) + - shared_scale: float (scale, shared across R, G, B channels) + - uniform_window_size: float [optional; defaults to 1/255] + + Support: + - rgb in [0, 1]^3 [a 3D array] + """ + + def sample( + self, key, loc, shared_scale, uniform_window_size=_FIXED_COLOR_UNIFORM_WINDOW + ): + return jax.vmap( + lambda k, lc: truncated_laplace.sample( + k, lc, shared_scale, 0.0, 1.0, uniform_window_size + ), + in_axes=(0, 0), + )(jax.random.split(key, loc.shape[0]), loc) + + def logpdf( + self, obs, loc, shared_scale, uniform_window_size=_FIXED_COLOR_UNIFORM_WINDOW + ): + return jax.vmap( + lambda o, lc: truncated_laplace.logpdf( + o, lc, shared_scale, 0.0, 1.0, uniform_window_size + ), + in_axes=(0, 0), + )(obs, loc).sum() + + +truncated_color_laplace = TruncatedColorLaplace() diff --git a/src/b3d/pose/core.py b/src/b3d/pose/core.py index 0ecda002..74a0337d 100644 --- a/src/b3d/pose/core.py +++ b/src/b3d/pose/core.py @@ -76,6 +76,19 @@ def sample_uniform_pose(key, low, high): return Pose(pos, quat) +@jax.jit +def sample_uniform_scale(key, low, high): + key, subkey = jax.random.split(key) + scale = jax.random.uniform(subkey, (3,)) * (high - low) + low + return scale + + +def logpdf_uniform_scale(scale, low, high): + valid = (low <= scale) & (scale <= high) + scale_score = jnp.log((valid * 1.0) * (jnp.ones_like(scale) / (high - low))) + return scale_score.sum() + jnp.pi**2 + + def logpdf_uniform_pose(pose, low, high): position = pose.pos valid = (low <= position) & (position <= high) @@ -120,6 +133,92 @@ def logpdf_gaussian_vmf_pose(pose, mean_pose, std, concentration): return translation_score + quaternion_score +@jax.jit +def sample_gaussian_vmf_pose_trunc(key, mean_pose, std, concentration): + """ + Samples poses from the product of a diagonal normal distribution (for position) and + a generalized von Mises-Fisher distribution (for quaternion). + + Note: + One can view the von Mises–Fisher distribution over the n-sphere + as the restriction of the normal distribution on R^{n+1} + to the n-sphere. From this viewpoint the concentration is + approximateley the inverse of the variance. + + See: + > https://en.wikipedia.org/wiki/Von_Mises%E2%80%93Fisher_distribution#Relation_to_normal_distribution + """ + from b3d.utils import keysplit + + _, keys = keysplit(key, 1, 3) + var = std**2 + xz = jax.random.multivariate_normal( + keys[0], jnp.array([mean_pose.pos[0], mean_pose.pos[2]]), var * jnp.eye(2) + ) + y = genjax.truncated_normal.sample(keys[1], mean_pose.pos[1], std, 0, jnp.inf) + q = tfp.distributions.VonMisesFisher(mean_pose.quat, concentration).sample( + seed=keys[2] + ) + + return Pose(jnp.array([xz[0], y, xz[2]]), q) + + +def logpdf_gaussian_vmf_pose_trunc(pose, mean_pose, std, concentration): + translation_score_xz = tfp.distributions.MultivariateNormalDiag( + jnp.array([mean_pose.pos[0], mean_pose.pos[2]]), jnp.ones(2) * std + ).log_prob(jnp.array([pose.pos[0], pose.pos[2]])) + translation_score_y = genjax.truncated_normal.logpdf( + pose.pos[1], mean_pose.pos[1], std, 0, jnp.inf + ) + quaternion_score = tfp.distributions.VonMisesFisher( + mean_pose.quat / jnp.linalg.norm(mean_pose.quat), concentration + ).log_prob(pose.quat) + return translation_score_xz + translation_score_y + quaternion_score + + +@jax.jit +def sample_gaussian_vmf_pose_approx(key, mean_pose, std, concentration): + """ + Samples poses from the product of a diagonal normal distribution (for position) and + a generalized von Mises-Fisher distribution (for quaternion). + + Note: + One can view the von Mises–Fisher distribution over the n-sphere + as the restriction of the normal distribution on R^{n+1} + to the n-sphere. From this viewpoint the concentration is + approximateley the inverse of the variance. + + See: + > https://en.wikipedia.org/wiki/Von_Mises%E2%80%93Fisher_distribution#Relation_to_normal_distribution + """ + from b3d.utils import keysplit + + _, keys = keysplit(key, 1, 3) + var = std**2 + xz = jax.random.multivariate_normal( + keys[0], jnp.array([mean_pose.pos[0], mean_pose.pos[2]]), var * jnp.eye(2) + ) + y = genjax.truncated_normal.sample(keys[1], mean_pose.pos[1], std, 0, jnp.inf) + q = jax.random.multivariate_normal( + keys[1], mean_pose.quat, jnp.eye(4) / concentration + ) + + return Pose(jnp.array([xz[0], y, xz[2]]), q).normalize() + + +def logpdf_gaussian_vmf_pose_approx(pose, mean_pose, std, concentration): + translation_score_xz = tfp.distributions.MultivariateNormalDiag( + jnp.array([mean_pose.pos[0], mean_pose.pos[2]]), jnp.ones(2) * std + ).log_prob(jnp.array([pose.pos[0], pose.pos[2]])) + translation_score_y = genjax.truncated_normal.logpdf( + pose.pos[1], mean_pose.pos[1], std, 0, jnp.inf + ) + quaternion_score = tfp.distributions.MultivariateNormalDiag( + mean_pose.quat, jnp.ones(4) * jnp.sqrt(1 / concentration) + ).log_prob(pose.quat) + return translation_score_xz + translation_score_y + quaternion_score + + def camera_from_position_and_target( position, target=jnp.array([0.0, 0.0, 0.0]), up=jnp.array([0.0, 0.0, 1.0]) ): @@ -415,4 +514,28 @@ def from_pos_matrix(pos, matrix): jax.vmap(logpdf_gaussian_vmf_pose, in_axes=(0, None, None, None)) ) + sample_gaussian_vmf_pose_approx = sample_gaussian_vmf_pose_approx + + sample_gaussian_vmf_pose_approx_jit = jax.jit(sample_gaussian_vmf_pose_approx) + sample_gaussian_vmf_pose_approx_vmap = jax.vmap( + sample_gaussian_vmf_pose_approx, in_axes=(0, None, None, None) + ) + + logpdf_gaussian_vmf_pose_approx = logpdf_gaussian_vmf_pose_approx + logpdf_gaussian_vmf_pose_approx_vmap = jax.jit( + jax.vmap(logpdf_gaussian_vmf_pose_approx, in_axes=(0, None, None, None)) + ) + + sample_gaussian_vmf_pose_trunc = sample_gaussian_vmf_pose_trunc + + sample_gaussian_vmf_pose_trunc_jit = jax.jit(sample_gaussian_vmf_pose_trunc) + sample_gaussian_vmf_pose_trunc_vmap = jax.vmap( + sample_gaussian_vmf_pose_trunc, in_axes=(0, None, None, None) + ) + + logpdf_gaussian_vmf_pose_trunc = logpdf_gaussian_vmf_pose_trunc + logpdf_gaussian_vmf_pose_trunc_vmap = jax.jit( + jax.vmap(logpdf_gaussian_vmf_pose_trunc, in_axes=(0, None, None, None)) + ) + uniform_pose_centered = uniform_pose_centered diff --git a/src/b3d/pose/grid.py b/src/b3d/pose/grid.py new file mode 100644 index 00000000..565609ee --- /dev/null +++ b/src/b3d/pose/grid.py @@ -0,0 +1,182 @@ +import os + +import jax +import jax.numpy as jnp + +# for debug+test only +import rerun as rr +from jax.scipy.spatial.transform import Rotation + +import b3d +from b3d import Mesh + +from .core import Pose + + +def viz_rotation(pose, vertices, t=0, channel="mesh/xfm_cloud"): + """visualize a rotation of a given mesh vertex set in rerun""" + b3d.rr_set_time(t) + + # render + b3d.rr_log_cloud( + pose.apply(vertices), + channel, + ) + rr.log( + "info", + rr.TextDocument( + f""" + translation: {pose.pos} + rotation (xyzw): {pose.quaternion} + """.strip(), + media_type=rr.MediaType.MARKDOWN, + ), + ) + b3d.rr_log_pose(pose, "axes/xfm_pose_axes") + + +def viz_from_grid(pose_grid, rerun_session_name="grid_test", ycb_obj_id=13): + # load vertices + ycb_dir = os.path.join(b3d.get_assets_path(), "bop/ycbv") + mesh = Mesh.from_obj_file( + os.path.join(ycb_dir, f'models/obj_{f"{ycb_obj_id + 1}".rjust(6, "0")}.ply') + ).scale(0.001) + cam_pose = Pose( + position=mesh.vertices.mean(axis=0), quaternion=jnp.array([0, 0, 0, 1]) + ) # center the mesh for cleaner viz + mesh_vertices = cam_pose.inv().apply(mesh.vertices) + + # setup viz + b3d.rr_init(rerun_session_name) + + # log the default pose + b3d.rr_set_time(0) + b3d.rr_log_pose(Pose.identity(), "axes/default_pose_axes") + viz_rotation(Pose.identity(), mesh_vertices, 0, "mesh/default_pose_cloud") + + # visualize + for t, pose_viz in enumerate(pose_grid): + viz_rotation(pose_viz, mesh_vertices, t + 1, "mesh/xfm_cloud") + + +def sorted_linspace(delta, half_num): + if half_num == 0: # only the zero-transform sample is returned + return jnp.array([0.0]) + + num_samples = half_num * 2 + 1 + linspace = jnp.linspace(-delta, delta, num_samples) + ordered_linspace = linspace[jnp.argsort(jnp.abs(linspace))] + return ordered_linspace + + +def rr_log_pose_arrows_grid(pose_grid, channel="pose_grid", scale=0.02): + origins = jnp.tile(pose_grid.pos, (3, 1)) + colors = jnp.tile(jnp.eye(3), (len(origins), 1)) + vectors = jax.vmap(lambda pose: pose.as_matrix()[:3, :3].T)(pose_grid) * scale + vectors = vectors.reshape(-1, 3) + rr.log(channel, rr.Arrows3D(origins=origins, vectors=vectors, colors=colors)) + + +def make_rotation_grid_enumeration( + half_d_angle, + half_n_alpha, + half_n_beta, + half_n_gamma, +) -> Pose: + """ + Enumerate rotations via euler angles uniformly gridded in the range [min_angle, max_angle] + for each axis (angle of axes: X = alpha, Y = beta, Z = gamma) + """ + alphas = sorted_linspace(half_d_angle, half_n_alpha) + betas = sorted_linspace(half_d_angle, half_n_beta) + gammas = sorted_linspace(half_d_angle, half_n_gamma) + + # nest vmap over all axes + def _inner_proposal(alpha, beta, gamma): + return Rotation.from_euler("ZYX", jnp.array([gamma, beta, alpha])) + + _proposal_z = lambda gamma, beta: jax.vmap( # noqa:E731 + _inner_proposal, in_axes=(None, None, 0) + )(gamma, beta, alphas) + _proposal_zy = lambda gamma: jax.vmap(_proposal_z, in_axes=(None, 0))(gamma, betas) # noqa:E731 + proposal_zyx = jax.vmap(_proposal_zy, in_axes=(0,))(gammas) + + n_alpha, n_beta, n_gamma = ( + 2 * half_n_alpha + 1, + 2 * half_n_beta + 1, + 2 * half_n_gamma + 1, + ) + return Pose( + jnp.zeros((n_alpha * n_beta * n_gamma, 3)), + proposal_zyx.as_quat().reshape(-1, 4), + ) + + +def make_translation_grid_enumeration( + half_dx, half_dy, dz, half_num_x, half_num_y, half_num_z +) -> Pose: + """ + Generate uniformly spaced translation proposals in a 3D box + Args: + half_dx, half_dy, dz: half-dimension of each of the x, y, z directions + half_num_x, half_num_y, half_num_z: samples in each of the dimensions, EXCLUDING the zero sample. + """ + x_space = sorted_linspace(half_dx, half_num_x) + y_space = sorted_linspace(half_dy, half_num_y) + z_space = sorted_linspace(dz, half_num_z) + deltas = jnp.stack( + jnp.meshgrid( + x_space, + y_space, + z_space, + ), + axis=-1, + ) + deltas = deltas.reshape((-1, 3), order="F") + + num_x, num_y, num_z = 2 * half_num_x + 1, 2 * half_num_y + 1, 2 * half_num_z + 1 + return Pose(deltas, jnp.tile(Pose.identity_quaternion, (num_x * num_y * num_z, 1))) + + +def pose_grid( + pose_center: Pose, + half_dx: float, + half_dy: float, + half_dz: float, + half_nx: int, + half_ny: int, + half_nz: int, + half_dangle: float, + half_n_xrot: int, + half_n_yrot: int, + half_n_zrot: int, +) -> Pose: + """ + Returns: + A batched Pose object. + + Args: + pose_center: the center pose + half_dx, dy, dz: half the step size for the x, y, z dimension + half_nx, ny, nz: half the number of samples in the x, y, z dimension + (2n + 1 samples will be used per dimension) + half_dangle: half the step size for the euler angle + half_n_xrot, half_n_yrot, half_n_zrot: half the number of samples in the x, y, z rotation + (2n + 1 samples will be used per dimension) + """ + tr_grid = make_translation_grid_enumeration( + half_dx, half_dy, half_dz, half_nx, half_ny, half_nz + ) + rot_grid = make_rotation_grid_enumeration( + half_dangle, half_n_xrot, half_n_yrot, half_n_zrot + ) + + compose_pose = lambda tr, rot: pose_center.compose(tr).compose(rot) # noqa:E731 + inner_vmap = lambda tr: jax.vmap(compose_pose, in_axes=(None, 0))( # noqa:E731 + tr, rot_grid + ) + _total_grid = jax.vmap(inner_vmap, in_axes=(0,))(tr_grid) # vmap over tr + + total_grid = _total_grid.reshape(-1) + + return total_grid diff --git a/src/b3d/utils.py b/src/b3d/utils.py index 137aa567..2c5f3701 100644 --- a/src/b3d/utils.py +++ b/src/b3d/utils.py @@ -1,3 +1,4 @@ +import functools import inspect import os import subprocess @@ -132,8 +133,8 @@ def downsize_images(ims, k): @jax.jit def xyz_from_depth(z: rr.DepthImage, fx, fy, cx, cy): v, u = jnp.mgrid[: z.shape[0], : z.shape[1]] - x = (u - cx) / fx - y = (v - cy) / fy + x = (u + 0.5 - cx) / fx + y = (v + 0.5 - cy) / fy xyz = jnp.stack([x, y, jnp.ones_like(x)], axis=-1) * z[..., None] return xyz @@ -150,10 +151,20 @@ def xyz_from_depth(z: rr.DepthImage, fx, fy, cx, cy): ) +@functools.partial( + jnp.vectorize, + signature="(3)->(2)", + excluded=( + 1, + 2, + 3, + 4, + ), +) def xyz_to_pixel_coordinates(xyz, fx, fy, cx, cy): - x = fx * xyz[..., 0] / (xyz[..., 2]) + cx - y = fy * xyz[..., 1] / (xyz[..., 2]) + cy - return jnp.stack([y, x], axis=-1) + x = fx * xyz[0] / (xyz[2]) + cx + y = fy * xyz[1] / (xyz[2]) + cy + return jnp.array([y, x]) def segment_point_cloud(point_cloud, threshold=0.01, min_points_in_cluster=0): @@ -511,7 +522,7 @@ def multivmap(f, args=None): def update_choices(trace, addresses, *values): return trace.update( jax.random.PRNGKey(0), - genjax.ChoiceMap.d({addr: c for (addr, c) in zip(addresses.const, values)}), + genjax.ChoiceMap.from_mapping(zip(addresses.unwrap(), values)), )[0] @@ -549,13 +560,13 @@ def update_choices_get_score(trace, addr_const, *values): @jax.jit def grid_trace(trace, addresses_const, values): - if len(addresses_const.const) == 1: + if len(addresses_const.unwrap()) == 1: return grid1(trace, addresses_const, *values) - elif len(addresses_const.const) == 2: + elif len(addresses_const.unwrap()) == 2: return grid2(trace, addresses_const, *values) - elif len(addresses_const.const) == 3: + elif len(addresses_const.unwrap()) == 3: return grid3(trace, addresses_const, *values) - elif len(addresses_const.const) == 4: + elif len(addresses_const.unwrap()) == 4: return grid4(trace, addresses_const, *values) else: raise ValueError("Too many addresses") @@ -586,18 +597,24 @@ def nn_background_segmentation(images): return masks -def rr_log_pose(channel, pose, scale=0.1): - origins = jnp.tile(pose.pos[None, ...], (3, 1)) - colors = jnp.eye(3) - rr.log( - channel, - rr.Arrows3D( - origins=origins, vectors=pose.as_matrix()[:3, :3].T * scale, colors=colors - ), - ) +# This variable can be used to know whether a rerun blueprint +# has been logged since this rerun session was initialized. +_blueprint_logged = False + + +def get_blueprint_logged(): + global _blueprint_logged + return _blueprint_logged + + +def set_blueprint_logged(val): + global _blueprint_logged + _blueprint_logged = val def rr_init(name="demo"): + global _blueprint_logged + _blueprint_logged = False rr.init(name) rr.connect("127.0.0.1:8812") @@ -629,6 +646,17 @@ def rr_log_cloud(cloud, channel="cloud", colors=None): rr.log(channel, rr.Points3D(cloud.reshape(-1, 3), colors=colors.reshape(-1, 3))) +def rr_log_pose(pose, channel="pose", scale=0.1): + origins = jnp.tile(pose.pos[None, ...], (3, 1)) + colors = jnp.eye(3) + rr.log( + channel, + rr.Arrows3D( + origins=origins, vectors=pose.as_matrix()[:3, :3].T * scale, colors=colors + ), + ) + + def rr_set_time(t=0): rr.set_time_sequence("step", t) @@ -883,3 +911,16 @@ def make_grid_points(min_vec, max_vec, num_vec): ) deltas = deltas.reshape((-1, len(min_vec)), order="F") return deltas + + +def scale_image(img, factor): + """Scale an image. + + Args: + img (PIL.Image): Image to scale. + factor (float): Scale factor. + Returns: + PIL.Image: Scaled image. + """ + w, h = img.size + return img.resize((int(w * factor), int(h * factor))) diff --git a/test_agnular_velocity.ipynb b/test_agnular_velocity.ipynb new file mode 100644 index 00000000..52d35b50 --- /dev/null +++ b/test_agnular_velocity.ipynb @@ -0,0 +1,211 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import b3d\n", + "import jax.numpy as jnp\n", + "import numpy as np\n", + "import h5py\n", + "import matplotlib.pyplot as plt\n", + "from scipy.spatial.transform import Rotation as R\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# paths for reading physion metadata\n", + "physion_assets_path = '/home/haoliangwang/data/physion_hdf5/collide_all_movies'\n", + "\n", + "stim_name = 'pilot_it2_collision_non-sphere_box_0015'\n", + "\n", + "hdf5_file_path = os.path.join(physion_assets_path,\n", + " f\"{stim_name}.hdf5\",\n", + ")\n", + "\n", + "video_file_path = os.path.join(physion_assets_path,\n", + " f\"{stim_name}_img.mp4\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# def compute_angular_velocity(q1, q2, dt):\n", + "# return (2 / dt) * np.array([\n", + "# q1[0]*q2[1] - q1[1]*q2[0] - q1[2]*q2[3] + q1[3]*q2[2],\n", + "# q1[0]*q2[2] + q1[1]*q2[3] - q1[2]*q2[0] - q1[3]*q2[1],\n", + "# q1[0]*q2[3] - q1[1]*q2[2] + q1[2]*q2[1] - q1[3]*q2[0]])\n", + "\n", + "def compute_angular_velocity(q1, q2, delta_t):\n", + " \"\"\"\n", + " Compute angular velocity in radians per second from two quaternions.\n", + "\n", + " Parameters:\n", + " q1 (array-like): Quaternion at the earlier time [w, x, y, z].\n", + " q2 (array-like): Quaternion at the later time [w, x, y, z].\n", + " delta_t (float): Time difference between the two quaternions.\n", + "\n", + " Returns:\n", + " angular_velocity (numpy array): Angular velocity vector (radians per second).\n", + " \"\"\"\n", + " # Convert quaternions to scipy Rotation objects\n", + " rot1 = R.from_quat(q1)\n", + " rot2 = R.from_quat(q2)\n", + " \n", + " # Compute the relative rotation\n", + " relative_rotation = rot2 * rot1.inv()\n", + " \n", + " # Convert the relative rotation to angle-axis representation\n", + " angle = relative_rotation.magnitude() # Rotation angle in radians\n", + " axis = relative_rotation.as_rotvec() / angle if angle != 0 else np.zeros(3) # Rotation axis\n", + " \n", + " # Compute angular velocity\n", + " angular_velocity = (axis * angle) / delta_t\n", + " return angular_velocity\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Angular Velocity (radians per second): [ 0. 15.70796327 0. ]\n" + ] + } + ], + "source": [ + "\n", + "# Example usage\n", + "q1 = [0.7071, 0, 0.7071, 0] # Quaternion at time t1\n", + "q2 = [1, 0, 0, 0] # Quaternion at time t2\n", + "delta_t = 0.1 # Time difference in seconds\n", + "\n", + "angular_velocity = compute_angular_velocity(q1, q2, delta_t)\n", + "print(\"Angular Velocity (radians per second):\", angular_velocity)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# fps = b3d.io.utils.load_video_info(video_file_path).fps\n", + "fps = 100\n", + "delta_t = 1/fps\n", + "obj_idx = 3\n", + "\n", + "recorded = []\n", + "computed = []\n", + "with h5py.File(hdf5_file_path, \"r\") as f:\n", + " for key in f['frames'].keys():\n", + " ang_vel = jnp.array(f['frames'][key]['objects']['angular_velocities'])\n", + " quaternion_now = jnp.array(f['frames'][key]['objects']['rotations_cam0'])\n", + " # print(ang_vel.shape, quaternion_now.shape)\n", + " if key == '0000':\n", + " continue\n", + " frame_idx = int(key)\n", + " quaternion_last = jnp.array(f['frames'][str(frame_idx-1).zfill(4)]['objects']['rotations_cam0'])\n", + " angular_velocity = compute_angular_velocity(quaternion_last[obj_idx], quaternion_now[obj_idx], delta_t)\n", + " # angular_velocity = np.dot(angular_velocity, np.array([[0,0,1],[0,-1,0],[-1,0,0]]))\n", + " recorded.append(ang_vel[obj_idx])\n", + " computed.append(angular_velocity)\n", + " # print(\"Angular Velocity computed:\", angular_velocity)\n", + " # print(\"Angular Velocity recorded:\", ang_vel[obj_idx], '\\n')" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "recorded = np.array(recorded)\n", + "computed = np.array(computed)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "ename": "", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31mThe Kernel crashed while executing code in the current cell or a previous cell. \n", + "\u001b[1;31mPlease review the code in the cell(s) to identify a possible cause of the failure. \n", + "\u001b[1;31mClick here for more info. \n", + "\u001b[1;31mView Jupyter log for further details." + ] + } + ], + "source": [ + "dim = 2\n", + "\n", + "frames = [i for i in range(computed[:,0].shape[0])]\n", + "\n", + "plt.plot(frames, recorded[:,dim], 'blue')\n", + "plt.plot(frames, computed[:,dim], 'red')\n", + "plt.xlabel(\"frame\")\n", + "plt.ylabel(\"angular velocity\")\n", + "plt.title('comparison between computed and recorded velocity')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "gpu", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/test_b3d_tracking_hmm copy.py b/test_b3d_tracking_hmm copy.py new file mode 100644 index 00000000..6b881129 --- /dev/null +++ b/test_b3d_tracking_hmm copy.py @@ -0,0 +1,248 @@ +import argparse +import json +import os +from os import listdir +from os.path import isfile, join + +import b3d +import b3d.chisight.dense.dense_model +import b3d.chisight.dense.likelihoods.laplace_likelihood +import b3d.chisight.gen3d.inference.inference as inference +import b3d.chisight.gen3d.settings as settings +import jax +import jax.numpy as jnp +import rerun as rr +import trimesh +from b3d.chisight.dense.dense_model import get_new_state +from b3d.chisight.gen3d.dataloading import ( + get_initial_state, + load_trial, + resize_rgbds_and_get_masks, +) +from b3d.chisight.gen3d.datawriting import write_json +from genjax import Pytree + + +def foreground_background(depth_map, area, val): + zero_depth_map = jnp.full(depth_map.shape, val) + zero_depth_map = zero_depth_map.at[area].set(depth_map[area]) + return zero_depth_map + + +def main( + scenario, + START_T, + FINAL_T, + hdf5_file_path, + trial_name, + mehses, + pred_file, + save_path, + likelihood_args, + inference_hyperparams, + im_height, + im_width, + model, + viz_trace, + viz_index, + debug=True, +): + ( + rgbds, + seg_arr, + object_ids, + object_segmentation_colors, + background_areas, + camera_pose, + _, + _, + ) = load_trial(hdf5_file_path) + + hyperparams = settings.hyperparams + hyperparams["camera_pose"] = camera_pose + hyperparams["likelihood_args"] = likelihood_args + + initial_state, hyperparams = get_initial_state( + pred_file, + object_ids, + object_segmentation_colors, + mehses, + seg_arr[START_T], + rgbds[START_T], + hyperparams, + ) + + rgbds, all_areas, background_areas = resize_rgbds_and_get_masks( + rgbds, seg_arr, background_areas, im_height, im_width + ) + hyperparams["background"] = jnp.asarray( + [ + foreground_background(rgbds[t], background_areas[t], jnp.inf) + for t in range(rgbds.shape[0]) + ] + ) + + key = jax.random.PRNGKey(156) + trace = inference.get_initial_trace( + key, + model, + hyperparams, + initial_state, + foreground_background(rgbds[START_T], all_areas[START_T], 0.0), + ) + viz_trace(trace, t=viz_index) + print("finished initializing trace") + + posterior_across_frames = {"pose": []} + for T in range(FINAL_T): + print(f"time {T}") + key = b3d.split_key(key) + trace, posterior_across_frames = inference.inference_step( + key, + trace, + foreground_background(rgbds[T], all_areas[T], 0.0), + inference_hyperparams, + [Pytree.const(f"object_pose_{o_id}") for o_id in object_ids], + posterior_across_frames, + ) + viz_trace(trace, t=viz_index + T + 1) + print(get_new_state(trace), "\n") + + write_json( + pred_file, + hyperparams, + posterior_across_frames, + save_path, + scenario, + trial_name, + debug=debug, + ) + + return + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--scenario", default="collide", type=str) + args = parser.parse_args() + scenario = args.scenario + + # paths for reading physion metadata + data_path = "/home/haoliangwang/data/" + hdf5_file_path = os.path.join( + data_path, + "physion_hdf5", + ) + mesh_file_path = os.path.join( + data_path, + "all_flex_meshes/core", + ) + save_path = "/home/haoliangwang/data/b3d_tracking_results/test" + pred_file_path = "/home/haoliangwang/data/pred_files/gt_info/gt.json" + + rr.init("demo") + rr.connect("127.0.0.1:8813") + rr.log("/", rr.ViewCoordinates.LEFT_HAND_Y_UP, static=True) + + near_plane = 0.1 + far_plane = 100 + im_width = 350 + im_height = 350 + width = 1024 + height = 1024 + + START_T = 0 + if scenario == "collide": + FINAL_T = 15 + else: + FINAL_T = 45 + + with open(pred_file_path) as f: + pred_file_all = json.load(f) + + all_meshes = {} + for path, dirs, files in os.walk(mesh_file_path): + for name in files + dirs: + if name.endswith(".obj"): + mesh = trimesh.load(os.path.join(path, name)) + all_meshes[name[:-4]] = mesh + + scenario_path = join(hdf5_file_path, scenario + "_all_movies") + onlyhdf5 = [ + f + for f in listdir(scenario_path) + if isfile(join(scenario_path, f)) and join(scenario_path, f).endswith(".hdf5") + ] + + scaling_factor = im_height / height + vfov = 54.43222 / 180.0 * jnp.pi + tan_half_vfov = jnp.tan(vfov / 2.0) + tan_half_hfov = tan_half_vfov * width / float(height) + fx = width / 2.0 / tan_half_hfov # focal length in pixel space + fy = height / 2.0 / tan_half_vfov + + renderer = b3d.renderer.renderer_original.RendererOriginal( + width * scaling_factor, + height * scaling_factor, + fx * scaling_factor, + fy * scaling_factor, + (width / 2) * scaling_factor, + (height / 2) * scaling_factor, + near_plane, + far_plane, + ) + + b3d.reload(b3d.chisight.dense.likelihoods.laplace_likelihood) + likelihood_func = b3d.chisight.dense.likelihoods.laplace_likelihood.likelihood_func + + b3d.reload(b3d.chisight.dense.dense_model) + dynamic_object_generative_model, viz_trace = ( + b3d.chisight.dense.dense_model.make_dense_multiobject_dynamics_model( + renderer, likelihood_func + ) + ) + importance_jit = jax.jit(dynamic_object_generative_model.importance) + + likelihood_args = { + "fx": renderer.fx, + "fy": renderer.fy, + "cx": renderer.cx, + "cy": renderer.cy, + "image_width": Pytree.const(renderer.width), + "image_height": Pytree.const(renderer.height), + "masked": Pytree.const(True), + "check_interp": Pytree.const(False), + "num_mc_sample": Pytree.const(500), + "interp_penalty": Pytree.const(1000), + } + + inference_hyperparams = b3d.chisight.gen3d.settings.inference_hyperparams + + viz_index = 0 + for trial_index, hdf5_file in enumerate(onlyhdf5): + trial_name = hdf5_file[:-5] + # if trial_name in ["pilot_it2_collision_yeet_tdw_1_dis_1_occ_0025", "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0025", "pilot_it2_collision_non-sphere_box_0003", "pilot_it2_collision_simple_box_1_dis_1_occ_0014", "pilot_it2_collision_simple_box_1_dis_1_occ_0034", "pilot_it2_collision_tiny_ball_box_0023", "pilot_it2_collision_yeet_tdw_1_dis_1_occ_0038"]: + # continue + print(trial_index + 1, "\t", trial_name) + hdf5_file_path = join(scenario_path, hdf5_file) + + pred_file = pred_file_all[trial_name] + + main( + scenario, + START_T, + FINAL_T, + hdf5_file_path, + trial_name, + all_meshes, + pred_file, + save_path, + likelihood_args, + inference_hyperparams, + im_height, + im_width, + importance_jit, + viz_trace, + viz_index, + ) + viz_index += FINAL_T + 1 diff --git a/test_b3d_tracking_hmm.py b/test_b3d_tracking_hmm.py new file mode 100644 index 00000000..de020d4d --- /dev/null +++ b/test_b3d_tracking_hmm.py @@ -0,0 +1,226 @@ +import argparse +import collections +import json +import os +from os import listdir +from os.path import isfile, join + +import b3d +import b3d.chisight.dense.dense_model +import b3d.chisight.dense.likelihoods.laplace_likelihood +import b3d.chisight.gen3d.inference.inference as inference +import b3d.chisight.gen3d.settings as settings +import jax +import jax.numpy as jnp +import rerun as rr +import trimesh +from b3d.chisight.gen3d.dataloading import ( + get_initial_state, + load_trial, + resize_rgbds_and_get_masks, +) +from b3d.chisight.gen3d.datawriting import write_json +from genjax import Pytree + + +def foreground_background(depth_map, area, val): + zero_depth_map = jnp.full(depth_map.shape, val) + zero_depth_map = zero_depth_map.at[area].set(depth_map[area]) + return zero_depth_map + + +def main( + hdf5_file_path, + scenario, + mesh_file_path, + pred_file_path, + save_path, + masked=True, + debug=True, +): + rr.init("demo") + rr.connect("127.0.0.1:8813") + rr.log("/", rr.ViewCoordinates.LEFT_HAND_Y_UP, static=True) + + near_plane = 0.1 + far_plane = 100 + im_width = 350 + im_height = 350 + width = 1024 + height = 1024 + + START_T = 0 + if scenario == "collide": + FINAL_T = 15 + else: + FINAL_T = 45 + + with open(pred_file_path) as f: + pred_file_all = json.load(f) + + all_meshes = {} + for path, dirs, files in os.walk(mesh_file_path): + for name in files + dirs: + if name.endswith(".obj"): + mesh = trimesh.load(os.path.join(path, name)) + all_meshes[name[:-4]] = mesh + ordered_all_meshes = collections.OrderedDict(sorted(all_meshes.items())) + + scenario_path = join(hdf5_file_path, scenario + "_all_movies") + onlyhdf5 = [ + f + for f in listdir(scenario_path) + if isfile(join(scenario_path, f)) and join(scenario_path, f).endswith(".hdf5") + ] + + scaling_factor = im_height / height + vfov = 54.43222 / 180.0 * jnp.pi + tan_half_vfov = jnp.tan(vfov / 2.0) + tan_half_hfov = tan_half_vfov * width / float(height) + fx = width / 2.0 / tan_half_hfov # focal length in pixel space + fy = height / 2.0 / tan_half_vfov + + renderer = b3d.renderer.renderer_original.RendererOriginal( + width * scaling_factor, + height * scaling_factor, + fx * scaling_factor, + fy * scaling_factor, + (width / 2) * scaling_factor, + (height / 2) * scaling_factor, + near_plane, + far_plane, + ) + + b3d.reload(b3d.chisight.dense.likelihoods.laplace_likelihood) + likelihood_func = b3d.chisight.dense.likelihoods.laplace_likelihood.likelihood_func + + b3d.reload(b3d.chisight.dense.dense_model) + dynamic_object_generative_model, viz_trace = ( + b3d.chisight.dense.dense_model.make_dense_multiobject_dynamics_model( + renderer, likelihood_func + ) + ) + importance_jit = jax.jit(dynamic_object_generative_model.importance) + + likelihood_args = { + "fx": renderer.fx, + "fy": renderer.fy, + "cx": renderer.cx, + "cy": renderer.cy, + "image_width": Pytree.const(renderer.width), + "image_height": Pytree.const(renderer.height), + "masked": Pytree.const(masked), + "check_interp": Pytree.const(False), + "num_mc_sample": Pytree.const(500), + "interp_penalty": Pytree.const(1000), + } + + inference_hyperparams = b3d.chisight.gen3d.settings.inference_hyperparams + + viz_index = 0 + for trial_index, hdf5_file in enumerate(onlyhdf5): + trial_name = hdf5_file[:-5] + + print(trial_index + 1, "\t", trial_name) + hdf5_file_path = join(scenario_path, hdf5_file) + + pred_file = pred_file_all[trial_name] + ( + rgbds, + seg_arr, + object_ids, + object_segmentation_colors, + background_areas, + camera_pose, + _, + _, + ) = load_trial(hdf5_file_path) + + hyperparams = settings.hyperparams + hyperparams["camera_pose"] = camera_pose + hyperparams["likelihood_args"] = likelihood_args + + initial_state, hyperparams = get_initial_state( + pred_file, + object_ids, + object_segmentation_colors, + ordered_all_meshes, + seg_arr[START_T], + rgbds[START_T], + hyperparams, + ) + + rgbds, all_areas, background_areas = resize_rgbds_and_get_masks( + rgbds, seg_arr, background_areas, im_height, im_width + ) + hyperparams["background"] = jnp.asarray( + [ + foreground_background(rgbds[t], background_areas[t], jnp.inf) + for t in range(rgbds.shape[0]) + ] + ) + + key = jax.random.PRNGKey(156) + trace = inference.get_initial_trace( + key, + importance_jit, + hyperparams, + initial_state, + foreground_background(rgbds[START_T], all_areas[START_T], 0.0), + ) + viz_trace(trace, t=viz_index) + print("finished initializing trace") + + posterior_across_frames = {"pose": []} + for T in range(FINAL_T): + print(f"time {T}") + key = b3d.split_key(key) + trace, posterior_across_frames = inference.inference_step( + key, + trace, + foreground_background(rgbds[T], all_areas[T], 0.0), + inference_hyperparams, + [Pytree.const(f"object_pose_{o_id}") for o_id in object_ids], + posterior_across_frames, + ) + viz_trace(trace, t=viz_index + T + 1) + # print(get_new_state(trace), '\n') + viz_index += FINAL_T + 1 + + write_json( + pred_file, + hyperparams, + posterior_across_frames, + save_path, + scenario, + trial_name, + debug=debug, + ) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--scenario", default="collide", type=str) + args = parser.parse_args() + scenario = args.scenario + + # paths for reading physion metadata + data_path = "/home/haoliangwang/data/" + hdf5_file_path = os.path.join( + data_path, + "physion_hdf5", + ) + mesh_file_path = os.path.join( + data_path, + "all_flex_meshes/core", + ) + save_path = "/home/haoliangwang/data/b3d_tracking_results/test" + + pred_file_path = "/home/haoliangwang/data/pred_files/gt_info/gt.json" + main( + hdf5_file_path, + scenario, + mesh_file_path, + pred_file_path, + save_path, + ) diff --git a/test_b3d_tracking_hmm_single.py b/test_b3d_tracking_hmm_single.py new file mode 100644 index 00000000..1df20186 --- /dev/null +++ b/test_b3d_tracking_hmm_single.py @@ -0,0 +1,226 @@ +import argparse +import json +import os +import time +from os.path import join + +import b3d +import b3d.chisight.dense.dense_model +import b3d.chisight.dense.likelihoods.laplace_likelihood +import b3d.chisight.gen3d.inference.inference as inference +import b3d.chisight.gen3d.settings as settings +import jax +import jax.numpy as jnp +import rerun as rr +import trimesh +from b3d.chisight.gen3d.dataloading import ( + get_initial_state, + load_trial, + resize_rgbds_and_get_masks, +) +from b3d.chisight.gen3d.datawriting import write_json +from genjax import Pytree + + +def foreground_background(depth_map, area, val): + zero_depth_map = jnp.full(depth_map.shape, val) + zero_depth_map = zero_depth_map.at[area].set(depth_map[area]) + return zero_depth_map + + +def main( + scenario, + trial_name, + mesh_file_path, + pred_file_path, + save_path, + recording_id, + viz_index, + masked=True, + debug=True, +): + start_time = time.time() + rr.init("demo", recording_id=recording_id) + rr.connect("127.0.0.1:8813") + + if scenario == "dominoes": + START_T = 14 + else: + START_T = 0 + + if scenario == "collide": + FINAL_T = 15 + else: + FINAL_T = 45 + + near_plane = 0.1 + far_plane = 100 + im_width = 150 + im_height = 150 + width = 1024 + height = 1024 + + with open(pred_file_path) as f: + pred_file_all = json.load(f) + pred_file = pred_file_all[trial_name] + + all_meshes = {} + for path, dirs, files in os.walk(mesh_file_path): + for name in files + dirs: + if name.endswith(".obj"): + mesh = trimesh.load(os.path.join(path, name)) + all_meshes[name[:-4]] = mesh + + scaling_factor = im_height / height + vfov = 54.43222 / 180.0 * jnp.pi + tan_half_vfov = jnp.tan(vfov / 2.0) + tan_half_hfov = tan_half_vfov * width / float(height) + fx = width / 2.0 / tan_half_hfov + fy = height / 2.0 / tan_half_vfov + + renderer = b3d.renderer.renderer_original.RendererOriginal( + width * scaling_factor, + height * scaling_factor, + fx * scaling_factor, + fy * scaling_factor, + (width / 2) * scaling_factor, + (height / 2) * scaling_factor, + near_plane, + far_plane, + ) + + b3d.reload(b3d.chisight.dense.likelihoods.laplace_likelihood) + likelihood_func = b3d.chisight.dense.likelihoods.laplace_likelihood.likelihood_func + + b3d.reload(b3d.chisight.dense.dense_model) + dynamic_object_generative_model, viz_trace = ( + b3d.chisight.dense.dense_model.make_dense_multiobject_dynamics_model( + renderer, likelihood_func + ) + ) + importance_jit = jax.jit(dynamic_object_generative_model.importance) + + likelihood_args = { + "fx": renderer.fx, + "fy": renderer.fy, + "cx": renderer.cx, + "cy": renderer.cy, + "image_width": Pytree.const(renderer.width), + "image_height": Pytree.const(renderer.height), + "masked": Pytree.const(masked), + "check_interp": Pytree.const(True), + "num_mc_sample": Pytree.const(500), + "interp_penalty": Pytree.const(1e10), + } + + inference_hyperparams = b3d.chisight.gen3d.settings.inference_hyperparams + + hdf5_file_path = join( + "/home/haoliangwang/data/physion_hdf5", + scenario + "_all_movies", + f"{trial_name}.hdf5", + ) + initalization_time = time.time() + print(f"\t\t Initialization time: {initalization_time - start_time}") + + ( + rgbds_original, + seg_arr_original, + object_ids, + object_segmentation_colors, + background_areas, + camera_pose, + ) = load_trial(hdf5_file_path, FINAL_T) + loading_time = time.time() + print(f"\t\t Loading time: {loading_time - initalization_time}") + + hyperparams = settings.hyperparams + hyperparams["camera_pose"] = camera_pose + hyperparams["likelihood_args"] = likelihood_args + + initial_state, hyperparams = get_initial_state( + pred_file, + object_ids, + object_segmentation_colors, + all_meshes, + seg_arr_original[START_T], + rgbds_original[START_T], + hyperparams, + ) + first_state_time = time.time() + print(f"\t\t First state time: {first_state_time - loading_time}") + + rgbds, all_areas, background_areas = resize_rgbds_and_get_masks( + rgbds_original, seg_arr_original, background_areas, im_height, im_width + ) + hyperparams["background"] = jnp.asarray( + [ + foreground_background(rgbds[t], background_areas[t], jnp.inf) + for t in range(rgbds.shape[0]) + ] + ) + + key = jax.random.PRNGKey(156) + trace = inference.get_initial_trace( + key, + importance_jit, + hyperparams, + initial_state, + foreground_background(rgbds[START_T], all_areas[START_T], 0.0), + ) + viz_trace(trace, t=viz_index) + first_trace_time = time.time() + print(f"\t\t First trace time: {first_trace_time - first_state_time}") + + posterior_across_frames = {"pose": []} + for i, T in enumerate(range(START_T, FINAL_T)): + this_iteration_start_time = time.time() + key = b3d.split_key(key) + trace, this_frame_posterior = inference.inference_step( + key, + trace, + foreground_background(rgbds[T], all_areas[T], 0.0), + inference_hyperparams, + [Pytree.const(f"object_pose_{o_id}") for o_id in object_ids], + ) + posterior_across_frames["pose"].append(this_frame_posterior) + viz_trace(trace, t=viz_index + i + 1) + this_iteration_end_time = time.time() + print(f"\t\t frame {T}: {this_iteration_end_time - this_iteration_start_time}") + + write_json( + pred_file, + hyperparams, + posterior_across_frames, + save_path, + scenario, + trial_name, + debug=debug, + ) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--scenario", default="collide", type=str) + parser.add_argument("--trial_name", default="", type=str) + parser.add_argument("--recording_id", default="", type=str) + parser.add_argument("--viz_index", default="", type=int) + args = parser.parse_args() + scenario = args.scenario + trial_name = args.trial_name + recording_id = args.recording_id + viz_index = args.viz_index + + mesh_file_path = "/home/haoliangwang/data/all_flex_meshes/core" + save_path = "/home/haoliangwang/data/b3d_tracking_results/test" + pred_file_path = "/home/haoliangwang/data/pred_files/gt_info/gt.json" + + main( + scenario, + trial_name, + mesh_file_path, + pred_file_path, + save_path, + recording_id, + viz_index, + ) diff --git a/test_combine_json.ipynb b/test_combine_json.ipynb new file mode 100644 index 00000000..516f7d8e --- /dev/null +++ b/test_combine_json.ipynb @@ -0,0 +1,215 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "from os import listdir\n", + "from os.path import isfile, join" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "first_all = 'gt'\n", + "# path = f'/home/haoliangwang/data/b3d_tracking_results/all_scale/{first_all}'\n", + "path = f'/home/haoliangwang/data/b3d_tracking_results/test'\n", + "scenario = 'collide_optim'\n", + "scenario_path = f'{path}/{scenario}'\n", + "onlyjson = [\n", + " f\n", + " for f in listdir(scenario_path)\n", + " if isfile(join(scenario_path, f)) and join(scenario_path, f).endswith(\".json\")\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "configs = set([f[:-10] for f in onlyjson])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pilot_it2_collision_tiny_ball_box_0037.json\n", + "pilot_it2_collision_tiny_ball_box_0024.json\n", + "pilot_it2_collision_tiny_ball_box_0029.json\n", + "pilot_it2_collision_tiny_ball_box_0017.json\n", + "pilot_it2_collision_tiny_ball_box_0014.json\n", + "pilot_it2_collision_tiny_ball_box_0023.json\n", + "pilot_it2_collision_tiny_ball_box_0002.json\n", + "pilot_it2_collision_tiny_ball_box_0003.json\n", + "pilot_it2_collision_tiny_ball_box_0013.json\n", + "pilot_it2_collision_tiny_ball_box_0034.json\n", + "pilot_it2_collision_yeet_tdw_1_dis_1_occ_0036.json\n", + "pilot_it2_collision_yeet_tdw_1_dis_1_occ_0021.json\n", + "pilot_it2_collision_yeet_tdw_1_dis_1_occ_0038.json\n", + "pilot_it2_collision_yeet_tdw_1_dis_1_occ_0020.json\n", + "pilot_it2_collision_yeet_tdw_1_dis_1_occ_0007.json\n", + "pilot_it2_collision_yeet_tdw_1_dis_1_occ_0011.json\n", + "pilot_it2_collision_yeet_tdw_1_dis_1_occ_0017.json\n", + "pilot_it2_collision_yeet_tdw_1_dis_1_occ_0015.json\n", + "pilot_it2_collision_yeet_tdw_1_dis_1_occ_0023.json\n", + "pilot_it2_collision_yeet_tdw_1_dis_1_occ_0039.json\n", + "pilot_it2_collision_yeet_tdw_1_dis_1_occ_0032.json\n", + "pilot_it2_collision_yeet_tdw_1_dis_1_occ_0026.json\n", + "pilot_it2_collision_yeet_tdw_1_dis_1_occ_0035.json\n", + "pilot_it2_collision_yeet_tdw_1_dis_1_occ_0005.json\n", + "pilot_it2_collision_yeet_tdw_1_dis_1_occ_0025.json\n", + "pilot_it2_collision_yeet_box_0007.json\n", + "pilot_it2_collision_yeet_box_0030.json\n", + "pilot_it2_collision_yeet_box_0029.json\n", + "pilot_it2_collision_yeet_box_0021.json\n", + "pilot_it2_collision_yeet_box_0005.json\n", + "pilot_it2_collision_yeet_box_0026.json\n", + "pilot_it2_collision_simple_box_1_dis_1_occ_0014.json\n", + "pilot_it2_collision_simple_box_1_dis_1_occ_0034.json\n", + "pilot_it2_collision_simple_box_1_dis_1_occ_0008.json\n", + "pilot_it2_collision_simple_box_1_dis_1_occ_0018.json\n", + "pilot_it2_collision_simple_box_1_dis_1_occ_0013.json\n", + "pilot_it2_collision_simple_box_1_dis_1_occ_0022.json\n", + "pilot_it2_collision_simple_box_1_dis_1_occ_0005.json\n", + "pilot_it2_collision_simple_box_1_dis_1_occ_0038.json\n", + "pilot_it2_collision_simple_box_1_dis_1_occ_0009.json\n", + "pilot_it2_collision_simple_box_1_dis_1_occ_0024.json\n", + "pilot_it2_collision_simple_box_0006.json\n", + "pilot_it2_collision_simple_box_1_dis_1_occ_0014.json\n", + "pilot_it2_collision_simple_box_1_dis_1_occ_0034.json\n", + "pilot_it2_collision_simple_box_1_dis_1_occ_0008.json\n", + "pilot_it2_collision_simple_box_1_dis_1_occ_0018.json\n", + "pilot_it2_collision_simple_box_1_dis_1_occ_0013.json\n", + "pilot_it2_collision_simple_box_1_dis_1_occ_0022.json\n", + "pilot_it2_collision_simple_box_1_dis_1_occ_0005.json\n", + "pilot_it2_collision_simple_box_1_dis_1_occ_0038.json\n", + "pilot_it2_collision_simple_box_0031.json\n", + "pilot_it2_collision_simple_box_0015.json\n", + "pilot_it2_collision_simple_box_0012.json\n", + "pilot_it2_collision_simple_box_1_dis_1_occ_0009.json\n", + "pilot_it2_collision_simple_box_0005.json\n", + "pilot_it2_collision_simple_box_1_dis_1_occ_0024.json\n", + "pilot_it2_collision_simple_box_0017.json\n", + "pilot_it2_collision_simple_box_0025.json\n", + "pilot_it2_collision_assorted_targets_tdw_1_dis_1_occ_0007.json\n", + "pilot_it2_collision_assorted_targets_tdw_1_dis_1_occ_0034.json\n", + "pilot_it2_collision_assorted_targets_tdw_1_dis_1_occ_0014.json\n", + "pilot_it2_collision_assorted_targets_tdw_1_dis_1_occ_0035.json\n", + "pilot_it2_collision_assorted_targets_tdw_1_dis_1_occ_0027.json\n", + "pilot_it2_collision_non-sphere_box_0030.json\n", + "pilot_it2_collision_non-sphere_box_0036.json\n", + "pilot_it2_collision_non-sphere_box_0021.json\n", + "pilot_it2_collision_non-sphere_box_0015.json\n", + "pilot_it2_collision_non-sphere_box_0035.json\n", + "pilot_it2_collision_non-sphere_box_0029.json\n", + "pilot_it2_collision_non-sphere_box_0018.json\n", + "pilot_it2_collision_non-sphere_box_0039.json\n", + "pilot_it2_collision_non-sphere_box_0003.json\n", + "pilot_it2_collision_non-sphere_box_0017.json\n", + "pilot_it2_collision_non-sphere_box_0004.json\n", + "pilot_it2_collision_non-sphere_box_0007.json\n", + "pilot_it2_collision_non-sphere_box_0002.json\n", + "pilot_it2_collision_non-sphere_box_0013.json\n", + "pilot_it2_collision_non-sphere_box_0023.json\n", + "pilot_it2_collision_non-sphere_box_0034.json\n", + "pilot_it2_collision_non-sphere_box_0038.json\n", + "pilot_it2_collision_non-sphere_box_0012.json\n", + "pilot_it2_collision_non-sphere_box_0009.json\n", + "pilot_it2_collision_non-sphere_box_0033.json\n", + "pilot_it2_collision_non-sphere_box_0032.json\n", + "pilot_it2_collision_non-sphere_box_0025.json\n", + "pilot_it2_collision_non-sphere_box_0019.json\n", + "pilot_it2_collision_non-sphere_box_0037.json\n", + "pilot_it2_collision_non-sphere_box_0010.json\n", + "pilot_it2_collision_non-sphere_box_0016.json\n", + "pilot_it2_collision_assorted_targets_box_0011.json\n", + "pilot_it2_collision_assorted_targets_box_0007.json\n", + "pilot_it2_collision_assorted_targets_box_0003.json\n", + "pilot_it2_collision_assorted_targets_box_0017.json\n", + "pilot_it2_collision_tiny_ball_tdw_1_dis_1_occ_0021.json\n", + "pilot_it2_collision_tiny_ball_tdw_1_dis_1_occ_0000.json\n", + "pilot_it2_collision_tiny_ball_tdw_1_dis_1_occ_0037.json\n", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0023.json\n", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0000.json\n", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0017.json\n", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0024.json\n", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0038.json\n", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0033.json\n", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0015.json\n", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0028.json\n", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0014.json\n", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0007.json\n", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0004.json\n", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0032.json\n", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0034.json\n", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0011.json\n", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0020.json\n", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0008.json\n", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0025.json\n", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0035.json\n", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0030.json\n", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0019.json\n", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0039.json\n", + "pilot_it2_collision_non-sphere_tdw_1_dis_1_occ_0010.json\n" + ] + } + ], + "source": [ + "for config in configs:\n", + " config_dict = {}\n", + " for f in onlyjson:\n", + " if f.startswith(config):\n", + " print(f)\n", + " index = int(f[-9:-5])\n", + " f_path = join(scenario_path, f)\n", + " with open(f_path) as f:\n", + " this_trial = json.load(f)\n", + " config_dict[index] = this_trial\n", + " with open(f\"{path}/{config}.json\", \"w\") as f:\n", + " json.dump(config_dict, f)" + ] + }, + { + "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.9.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/test_linear_velocity.ipynb b/test_linear_velocity.ipynb new file mode 100644 index 00000000..fa203ac8 --- /dev/null +++ b/test_linear_velocity.ipynb @@ -0,0 +1,1173 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "# import b3d\n", + "import numpy as np\n", + "import numpy as np\n", + "import h5py\n", + "import matplotlib.pyplot as plt\n", + "import trimesh" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib widget" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# paths for reading physion metadata\n", + "physion_assets_path = '/home/haoliangwang/data/physion_hdf5/collide_all_movies'\n", + "\n", + "stim_name = 'pilot_it2_collision_assorted_targets_box_0003'\n", + "\n", + "hdf5_file_path = os.path.join(physion_assets_path,\n", + " f\"{stim_name}.hdf5\",\n", + ")\n", + "\n", + "video_file_path = os.path.join(physion_assets_path,\n", + " f\"{stim_name}_img.mp4\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def scale_mesh(vertices, scale_factor):\n", + " vertices[:, 0] *= scale_factor[0]\n", + " vertices[:, 1] *= scale_factor[1]\n", + " vertices[:, 2] *= scale_factor[2]\n", + " # vertices[:,[2,1]] = vertices[:,[1,2]]\n", + " return vertices\n", + "\n", + "def compute_linear_velocity(last, now, dt):\n", + " vel = (now-last)/dt\n", + " return vel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## test whether linear velocity is calculated using the center_cam0" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0001 [5.9032860e+00 2.2649765e-04 6.4978874e-01] [5.9045925e+00 2.8189719e-03 6.5133959e-01]\n", + "0002 [5.592719 0.81792176 0.61623234] [5.6839514 0.7913073 0.62700063]\n", + "0003 [5.681223 0.6921068 0.62624997] [5.6839514 0.69320726 0.62700063]\n", + "0004 [5.680958 0.59496313 0.62650687] [5.6839514 0.59510726 0.62700063]\n", + "0005 [5.6810336 0.4978493 0.6268224] [5.6839514 0.49700725 0.62700063]\n", + "0006 [5.6814523 0.40062964 0.62715894] [5.6839514 0.39890724 0.62700063]\n", + "0007 [5.6821547 0.30320287 0.6274745 ] [5.6839514 0.30080724 0.62700063]\n", + "0008 [5.6830606 0.2055198 0.62773526] [5.6839514 0.20270723 0.62700063]\n", + "0009 [5.684072 0.10750592 0.62791485] [5.6839514 0.10460723 0.62700063]\n", + "0010 [5.6850705 0.00915527 0.62799007] [5.6839514 0.00650723 0.62700063]\n", + "0011 [ 5.6859374 -0.08950233 0.6279476 ] [ 5.6839514 -0.09159277 0.62700063]\n", + "0012 [ 5.6865783 -0.18838942 0.6277986 ] [ 5.6839514 -0.18969277 0.62700063]\n", + "0013 [ 5.6869164 -0.28743446 0.62755644] [ 5.6839514 -0.28779277 0.62700063]\n", + "0014 [4.064013 1.336047 1.1516765] [2.3102188 3.1270993 1.7531028]\n", + "0015 [2.220577 3.1188772 1.8441663] [2.3102188 3.0289993 1.7531028]\n", + "0016 [2.3119063 2.9295862 1.7530278] [2.3102188 2.9308994 1.7531028]\n", + "0017 [2.3115666 2.8311431 1.7529026] [2.3102188 2.8327994 1.7531028]\n", + "0018 [2.3111343 2.7327836 1.7527804] [2.3102188 2.7346995 1.7531028]\n", + "0019 [2.3106635 2.6345491 1.7526805] [2.3102188 2.6365995 1.7531028]\n", + "0020 [2.3101687 2.53641 1.752603 ] [2.3102188 2.5384996 1.7531028]\n", + "0021 [2.309668 2.4383962 1.7525494] [2.3102188 2.4403996 1.7531028]\n", + "0022 [2.3092031 2.3405015 1.7525345] [2.3102188 2.3422997 1.7531028]\n", + "0023 [2.308795 2.2426963 1.7525434] [2.3102188 2.2441998 1.7531028]\n", + "0024 [2.3084612 2.1449835 1.7525911] [2.3102188 2.1460998 1.7531028]\n", + "0025 [2.3082316 2.0473213 1.7526597] [2.3102188 2.0479999 1.7531028]\n", + "0026 [2.3081064 1.9496977 1.752758 ] [2.3102188 1.9498999 1.7531028]\n", + "0027 [2.3081064 1.8520951 1.7528743] [2.3102188 1.8518 1.7531028]\n", + "0028 [2.3082197 1.7544746 1.7529994] [2.3102188 1.7537 1.7531028]\n", + "0029 [2.3084462 1.6568065 1.7531365] [2.3102188 1.6556001 1.7531028]\n", + "0030 [2.308762 1.5590727 1.7532736] [2.3102188 1.5575001 1.7531028]\n", + "0031 [2.3091793 1.4612556 1.7533839] [2.3102188 1.4594002 1.7531028]\n", + "0032 [2.3096263 1.3633192 1.753509 ] [2.3102188 1.3613002 1.7531028]\n", + "0033 [2.310127 1.2652874 1.7535776] [2.3102188 1.2632003 1.7531028]\n", + "0034 [2.3106277 1.1671364 1.7536432] [2.3102188 1.1651003 1.7531028]\n", + "0035 [2.3111045 1.0688663 1.7536759] [2.3102188 1.0670004 1.7531028]\n", + "0036 [2.3115337 0.9705007 1.753667 ] [2.3102188 0.9689004 1.7531028]\n", + "0037 [2.3118854 0.87203383 1.7536312 ] [2.3102188 0.8708004 1.7531028]\n", + "0038 [2.3121476 0.77350736 1.7535686 ] [2.3102188 0.77270037 1.7531028 ]\n", + "0039 [2.3123026 0.6749332 1.7534792] [2.3102188 0.67460036 1.7531028 ]\n", + "0040 [2.3123324 0.5763471 1.753366 ] [2.3102188 0.57650036 1.7531028 ]\n", + "0041 [2.3122668 0.47775507 1.7532468 ] [2.3102188 0.47840035 1.7531028 ]\n", + "0042 [2.3120642 0.37921667 1.7531097 ] [2.3102188 0.38030034 1.7531028 ]\n", + "0043 [2.3117602 0.28072 1.7529726] [2.3102188 0.28220034 1.7531028 ]\n", + "0044 [2.3113847 0.18233061 1.7528474 ] [2.3102188 0.18410033 1.7531028 ]\n", + "0045 [2.3109317 0.08400083 1.7527401 ] [2.3102188 0.08600033 1.7531028 ]\n", + "0046 [ 2.310449 -0.01417398 1.7526388 ] [ 2.3102188 -0.01209967 1.7531028 ]\n", + "0047 [ 2.3099542 -0.11227131 1.7525852 ] [ 2.3102188 -0.11019967 1.7531028 ]\n", + "0048 [ 2.3094535 -0.21021366 1.7525375 ] [ 2.3102188 -0.20829967 1.7531028 ]\n", + "0049 [ 2.3090243 -0.3080845 1.7525375] [ 2.3102188 -0.30639967 1.7531028 ]\n", + "0050 [ 2.3086429 -0.40585995 1.7525613 ] [ 2.3102188 -0.40449968 1.7531028 ]\n", + "0051 [ 2.3083448 -0.5035281 1.752615 ] [ 2.3102188 -0.50259966 1.7531028 ]\n", + "0052 [ 2.308166 -0.60117245 1.7526984 ] [ 2.3102188 -0.60069966 1.7531028 ]\n", + "0053 [ 2.3080945 -0.698781 1.7528057] [ 2.3102188 -0.69879967 1.7531028 ]\n", + "0054 [ 2.3081303 -0.7964015 1.7529309] [ 2.3102188 -0.7968997 1.7531028]\n", + "0055 [ 2.308309 -0.8940339 1.753056 ] [ 2.3102188 -0.8949997 1.7531028]\n", + "0056 [ 2.3085594 -0.99171996 1.7531931 ] [ 2.3102188 -0.9930997 1.7531028]\n", + "0057 [ 2.308929 -1.0895014 1.7533302] [ 2.3102188 -1.0911996 1.7531028]\n", + "0058 [ 2.309382 -1.1873543 1.7534316] [ 2.3102188 -1.1892996 1.7531028]\n", + "0059 [ 2.309835 -1.2853324 1.7535448] [ 2.3102188 -1.2873995 1.7531028]\n", + "0060 [ 2.3103476 -1.3834238 1.7536104] [ 2.3102188 -1.3854995 1.7531028]\n", + "0061 [ 2.3108244 -1.4816225 1.753658 ] [ 2.3102188 -1.4835994 1.7531028]\n", + "0062 [ 2.3113132 -1.5799344 1.75367 ] [ 2.3102188 -1.5816994 1.7531028]\n", + "0063 [ 2.3116827 -1.6783535 1.753658 ] [ 2.3102188 -1.6797993 1.7531028]\n", + "0064 [ 2.3120165 -1.7768383 1.7536163] [ 2.3102188 -1.7778993 1.7531028]\n", + "0065 [ 2.3122191 -1.8753886 1.7535269] [ 2.3102188 -1.8759992 1.7531028]\n", + "0066 [ 2.3123384 -1.9739747 1.7534375] [ 2.3102188 -1.9740992 1.7531028]\n", + "0067 [ 2.3123145 -2.0725667 1.7533183] [ 2.3102188 -2.072199 1.7531028]\n", + "0068 [ 2.3121953 -2.171141 1.7531872] [ 2.3102188 -2.170299 1.7531028]\n", + "0069 [ 2.311945 -2.2696614 1.753056 ] [ 2.3102188 -2.268399 1.7531028]\n", + "0070 [ 2.3116112 -2.3681104 1.752913 ] [ 2.3102188 -2.366499 1.7531028]\n", + "0071 [ 2.311194 -2.466479 1.7527938] [ 2.3102188 -2.464599 1.7531028]\n", + "0072 [ 2.310741 -2.5647433 1.7526984] [ 2.3102188 -2.5626988 1.7531028]\n", + "0073 [ 2.3102164 -2.6628852 1.752615 ] [ 2.3102188 -2.6607988 1.7531028]\n", + "0074 [ 2.3097396 -2.760917 1.7525673] [ 2.3102188 -2.7588987 1.7531028]\n", + "0075 [ 2.3092628 -2.8588355 1.7525196] [ 2.3102188 -2.8569987 1.7531028]\n", + "0076 [ 2.3088574 -2.9566467 1.7525554] [ 2.3102188 -2.9550986 1.7531028]\n", + "0077 [ 2.3084998 -3.054382 1.7525673] [ 2.3102188 -3.0531986 1.7531028]\n", + "0078 [ 2.3082495 -3.1520383 1.7526507] [ 2.3102188 -3.1512985 1.7531028]\n", + "0079 [2.581048 1.0645598 1.1392593] [2.6310678 0.94240785 0.5321082 ]\n", + "0080 [2.6297808 0.84432364 0.53185225] [2.6310678 0.84430784 0.5321082 ]\n", + "0081 [2.6298046 0.74643195 0.5318403 ] [2.6310678 0.74620783 0.5321082 ]\n", + "0082 [2.6298404 0.6485343 0.53186417] [2.6310678 0.6481078 0.5321082]\n", + "0083 [2.6299357 0.5506173 0.5318761] [2.6310678 0.5500078 0.5321082]\n", + "0084 [2.630043 0.45270175 0.5318761 ] [2.6310678 0.4519078 0.5321082]\n", + "0085 [2.6301742 0.35474747 0.5319357 ] [2.6310678 0.3538078 0.5321082]\n", + "0086 [2.6303291 0.25678277 0.5319357 ] [2.6310678 0.2557078 0.5321082]\n", + "0087 [2.630508 0.15879273 0.5319953 ] [2.6310678 0.1576078 0.5321082]\n", + "0088 [2.6306868 0.06076097 0.53201914] [2.6310678 0.05950779 0.5321082 ]\n", + "0089 [ 2.6308775 -0.03729463 0.5320549 ] [ 2.6310678 -0.0385922 0.5321082]\n", + "0090 [ 2.631116 -0.13537705 0.5321026 ] [ 2.6310678 -0.1366922 0.5321082]\n", + "0091 [ 2.6312828 -0.23349822 0.5321622 ] [ 2.6310678 -0.2347922 0.5321082]\n", + "0092 [ 2.6314974 -0.3316611 0.5321741] [ 2.6310678 -0.3328922 0.5321082]\n", + "0093 [ 2.6316643 -0.42983294 0.5322218 ] [ 2.6310678 -0.43099222 0.5321082 ]\n", + "0094 [ 2.6318789 -0.5280465 0.53224564] [ 2.6310678 -0.5290922 0.5321082]\n", + "0095 [ 2.6319742 -0.6262928 0.5322933] [ 2.6310678 -0.6271922 0.5321082]\n", + "0096 [ 2.632141 -0.7245451 0.53230524] [ 2.6310678 -0.7252922 0.5321082]\n", + "0097 [ 2.6322365 -0.82282126 0.5323529 ] [ 2.6310678 -0.8233922 0.5321082]\n", + "0098 [ 2.6322842 -0.9211153 0.532341 ] [ 2.6310678 -0.9214922 0.5321082]\n", + "0099 [ 2.6311874 -0.9573281 0.5218029] [ 2.6311352 -0.9582521 0.5220197]\n", + "0100 [2.5387049 0.06970316 0.3715396 ] [2.5423198 0.06788051 0.3730414 ]\n", + "0101 [2.5394201 0.09627342 0.36758184] [2.5400681 0.09407961 0.36823848]\n", + "0102 [2.533865 0.04440099 0.36076307] [2.533619 0.04388035 0.3611665 ]\n", + "0103 [ 2.5346756 -0.0547871 0.36131144] [ 2.533619 -0.05421965 0.3611665 ]\n", + "0104 [2.5036812 0.11642277 0.35032034] [2.502854 0.11708376 0.3509018 ]\n", + "0105 [2.503705 0.01811981 0.35099983] [2.502854 0.01898376 0.3509018 ]\n", + "0106 [ 2.503562 -0.08009523 0.3509879 ] [ 2.502854 -0.07911624 0.3509018 ]\n", + "0107 [2.4727821 0.08487552 0.34028292] [2.4719381 0.08652532 0.33916935]\n", + "0108 [ 2.472353 -0.01271963 0.33922195] [ 2.4719381 -0.01157468 0.33916935]\n", + "0109 [ 2.472186 -0.11085719 0.3391981 ] [ 2.4719381 -0.10967468 0.33916935]\n", + "0110 [ 2.4720192 -0.20898134 0.3391862 ] [ 2.4719381 -0.20777467 0.33916935]\n", + "0111 [2.4418354 0.22295117 0.35620928] [2.4395583 0.22385564 0.35555792]\n", + "0112 [2.4392605 0.12461543 0.35549402] [2.4395583 0.12575564 0.35555792]\n", + "0113 [2.4391174 0.02657175 0.35547018] [2.4395583 0.02765564 0.35555792]\n", + "0114 [ 2.4389744 -0.07146746 0.35544634] [ 2.4395583 -0.07044436 0.35555792]\n", + "0115 [ 2.3999214 -0.12321174 0.34962893] [ 2.3923287 -0.11336522 0.3471638 ]\n", + "0116 [2.3611307 0.1399532 0.3312111] [2.3668067 0.13991109 0.33438474]\n", + "0117 [2.3658752 0.0411436 0.33425093] [2.3668067 0.04181109 0.33438474]\n", + "0118 [ 2.3658276 -0.05683154 0.33425093] [ 2.3668067 -0.05628891 0.33438474]\n", + "0119 [ 2.3657322 -0.15478134 0.3342271 ] [ 2.3668067 -0.1543889 0.33438474]\n", + "0120 [ 2.3544073 -0.23792982 0.33487082] [ 2.3556044 -0.23756118 0.33496457]\n", + "0121 [ 2.3517132 -0.29532015 0.3425479 ] [ 2.354488 -0.29511055 0.34281677]\n", + "0122 [2.2722244 0.4857883 0.2670288] [2.2850337 0.3605185 0.277431 ]\n", + "0123 [2.2839546 0.26261955 0.27731657] [2.2850337 0.26241848 0.277431 ]\n", + "0124 [2.2840023 0.1646623 0.27730465] [2.2850337 0.16431847 0.277431 ]\n", + "0125 [2.2840738 0.06669909 0.27730465] [2.2850337 0.06621847 0.277431 ]\n", + "0126 [ 2.2841215 -0.0312686 0.27731657] [ 2.2850337 -0.03188153 0.277431 ]\n", + "0127 [ 2.284217 -0.12926161 0.27730465] [ 2.2850337 -0.12998152 0.277431 ]\n", + "0128 [ 2.284336 -0.22725016 0.2773404 ] [ 2.2850337 -0.22808152 0.277431 ]\n", + "0129 [ 2.2844315 -0.3252715 0.2773285] [ 2.2850337 -0.32618153 0.277431 ]\n", + "0130 [2.2451878 0.30626655 0.27405024] [2.2461617 0.18605798 0.2725196 ]\n", + "0131 [2.2458076 0.08898973 0.27247667] [2.2461617 0.08795799 0.2725196 ]\n", + "0132 [ 2.2459745 -0.00907481 0.2724886 ] [ 2.2461617 -0.01014201 0.2725196 ]\n", + "0133 [ 2.2420168 -0.07154047 0.26643276] [ 2.2417707 -0.0725157 0.26664874]\n", + "0134 [ 2.242899 -0.06994009 0.25810003] [ 2.2447562 -0.07189162 0.25877064]\n", + "0135 [ 2.2449732 -0.16895533 0.25877953] [ 2.2447562 -0.16999161 0.25877064]\n", + "0136 [ 2.2108793 -0.08246005 0.28362274] [ 2.209109 -0.08338962 0.2826721 ]\n", + "0137 [ 2.2096157 -0.18052459 0.28270483] [ 2.209109 -0.18148962 0.2826721 ]\n", + "0138 [2.1991253 0.20723343 0.2247572 ] [2.1990962 0.16071513 0.23117258]\n", + "0139 [2.1398783 0.30314922 0.21648407] [2.1643085 0.28957185 0.21783948]\n", + "0140 [2.165079 0.19213557 0.2179265 ] [2.1643085 0.19147184 0.21783948]\n", + "0141 [2.1651745 0.09391308 0.21791458] [2.1643085 0.09337185 0.21783948]\n", + "0142 [ 2.1652222 -0.00428855 0.21793842] [ 2.1643085 -0.00472815 0.21783948]\n", + "0143 [ 2.1652699 -0.10250807 0.21793842] [ 2.1643085 -0.10282815 0.21783948]\n", + "0144 [ 2.1653414 -0.2007395 0.21793842] [ 2.1643085 -0.20092815 0.21783948]\n", + "0145 [ 2.1653175 -0.29896498 0.21795034] [ 2.1643085 -0.29902816 0.21783948]\n", + "0146 [2.0989895 0.29939413 0.24027824] [2.099975 0.28000164 0.23954277]\n", + "0147 [2.1009684 0.18172264 0.23967028] [2.099975 0.18190163 0.23954277]\n", + "0148 [2.1008968 0.08350313 0.23964643] [2.099975 0.08380163 0.23954277]\n", + "0149 [ 2.100873 -0.01471639 0.23964643] [ 2.099975 -0.01429836 0.23954277]\n", + "0150 [ 2.1008253 -0.11291802 0.23964643] [ 2.099975 -0.11239836 0.23954277]\n", + "0151 [ 2.0977259 -0.13033599 0.23765564] [ 2.097128 -0.12972862 0.237491 ]\n", + "0152 [ 2.0978212 -0.22854507 0.23758411] [ 2.097128 -0.22782862 0.237491 ]\n", + "0153 [1.9984484 0.12785196 0.20850897] [2.0382318 0.09532797 0.21575858]\n", + "0154 [1.9993782 0.13474822 0.20781755] [1.998459 0.13619679 0.20814988]\n", + "0155 [1.9988298 0.0372231 0.20819902] [1.998459 0.03809679 0.20814988]\n", + "0156 [ 1.9987106 -0.06091148 0.20817518] [ 1.998459 -0.06000321 0.20814988]\n", + "0157 [ 1.9814491 -0.07124245 0.19801855] [ 1.9906846 -0.07548974 0.19932604]\n", + "0158 [1.9608736 0.03132969 0.21109581] [1.960488 0.03253542 0.21062504]\n", + "0159 [1.9603014 0.0069052 0.21494627] [1.9615673 0.00725266 0.2148306 ]\n", + "0160 [ 1.9613981 -0.09174943 0.21480322] [ 1.9615673 -0.09084734 0.2148306 ]\n", + "0161 [ 1.9613028 -0.18981844 0.21480322] [ 1.9615673 -0.18894735 0.2148306 ]\n", + "0162 [ 1.9383907 -0.17884523 0.19264221] [ 1.9392679 -0.17789176 0.19286706]\n", + "0163 [1.886344 0.23733675 0.24719238] [1.888281 0.23854694 0.24730612]\n", + "0164 [1.8877506 0.13974011 0.24722815] [1.888281 0.14044693 0.24730612]\n", + "0165 [1.8740177 0.09165108 0.24799109] [1.8747988 0.0921167 0.24760191]\n", + "0166 [1.8797874 0.04659295 0.24894476] [1.8806093 0.04648139 0.24941921]\n", + "0167 [ 1.8798828 -0.05211681 0.24932623] [ 1.8806093 -0.05161861 0.24941921]\n", + "0168 [ 1.8580914 -0.03283322 0.23559332] [ 1.8603524 -0.03236953 0.23621443]\n", + "0169 [ 1.8611908 -0.05214959 0.23006201] [ 1.8642424 -0.05292355 0.23120812]\n", + "0170 [ 1.8634081 -0.1512587 0.23109913] [ 1.8642424 -0.15102354 0.23120812]\n", + "0171 [ 1.8634081 -0.24926066 0.23111105] [ 1.8642424 -0.24912354 0.23120812]\n", + "0172 [ 1.8492699 -0.10437965 0.18596649] [ 1.8515183 -0.10447437 0.18651186]\n", + "0173 [1.8016338 0.49812794 0.1546979 ] [1.8193873 0.2625336 0.16527289]\n", + "0174 [1.8185377 0.1645565 0.16520023] [1.8193873 0.1644336 0.16527289]\n", + "0175 [1.8185616 0.06654263 0.16518831] [1.8193873 0.0663336 0.16527289]\n", + "0176 [ 1.8186092 -0.03146678 0.16521215] [ 1.8193873 -0.0317664 0.16527289]\n", + "0177 [ 1.8186331 -0.12949109 0.16521215] [ 1.8193873 -0.12986639 0.16527289]\n", + "0178 [1.7920971 0.0488013 0.172925 ] [1.7933166 0.04833338 0.17317003]\n", + "0179 [ 1.7926693 -0.04924387 0.17312765] [ 1.7933166 -0.04976662 0.17317003]\n", + "0180 [ 1.7927647 -0.14727563 0.17312765] [ 1.7933166 -0.14786662 0.17317003]\n", + "0181 [ 1.7928123 -0.24531484 0.17313957] [ 1.7933166 -0.24596661 0.17317003]\n", + "0182 [1.6822815 0.31638443 0.18105507] [1.6813182 0.3164903 0.18199955]\n", + "0183 [1.680994 0.21911561 0.18196106] [1.6813182 0.21839029 0.18199955]\n", + "0184 [1.680994 0.12104213 0.18196106] [1.6813182 0.12029029 0.18199955]\n", + "0185 [1.6811371 0.02297759 0.1819849 ] [1.6813182 0.02219029 0.18199955]\n", + "0186 [ 1.6811371 -0.07511675 0.1819849 ] [ 1.6813182 -0.07590971 0.18199955]\n", + "0187 [ 1.6812801 -0.17320216 0.18199682] [ 1.6813182 -0.17400971 0.18199955]\n", + "0188 [ 1.6704082 -0.02366304 0.16673803] [ 1.6703047 -0.02436377 0.16663426]\n", + "0189 [ 1.6706467 -0.07427633 0.16405582] [ 1.6705487 -0.07502654 0.16418873]\n", + "0190 [ 1.670742 -0.17236173 0.16419888] [ 1.6705487 -0.17312655 0.16418873]\n", + "0191 [ 1.6433239 -0.2201736 0.17039776] [ 1.6433948 -0.22315127 0.17019585]\n", + "0192 [ 1.6127586 -0.08599162 0.20977259] [ 1.6341426 -0.09360978 0.21263474]\n", + "0193 [1.5974998 0.293082 0.15255213] [1.5982368 0.2526378 0.15859076]\n", + "0194 [1.5986443 0.15515387 0.1586318 ] [1.5982368 0.1545378 0.15859076]\n", + "0195 [1.5986919 0.05701482 0.15865564] [1.5982368 0.0564378 0.15859076]\n", + "0196 [1.5741348 0.06913245 0.15422106] [1.5879272 0.05960718 0.15607306]\n", + "0197 [ 1.5798569 -0.00758767 0.1556158 ] [ 1.5792756 -0.00806027 0.15551664]\n", + "0198 [ 1.5799046 -0.1057446 0.15559196] [ 1.5792756 -0.10616027 0.15551664]\n", + "0199 [ 1.5557289 -0.02848506 0.17012358] [ 1.5555344 -0.0294628 0.16966882]\n", + "0200 [ 1.5500546 -0.02727509 0.177598 ] [ 1.5619941 -0.03261686 0.17851396]\n", + "0201 [ 1.562643 -0.13049841 0.17861128] [ 1.5619941 -0.13071686 0.17851396]\n", + "0202 [ 1.5626907 -0.22865534 0.17859936] [ 1.5619941 -0.22881687 0.17851396]\n", + "0203 [ 1.5361786 -0.15099645 0.21218061] [ 1.5348965 -0.13672362 0.21541756]\n", + "0204 [1.4446259 0.4049912 0.24087429] [1.4574608 0.31630751 0.23751524]\n", + "0205 [1.458168 0.21818578 0.23761988] [1.4574608 0.21820751 0.23751524]\n", + "0206 [1.4581203 0.12003034 0.23761988] [1.4574608 0.12010751 0.23751524]\n", + "0207 [1.4581203 0.02187043 0.23761988] [1.4574608 0.02200751 0.23751524]\n", + "0208 [ 1.4581203 -0.07628202 0.23761988] [ 1.4574608 -0.07609249 0.23751524]\n", + "0209 [ 1.456356 -0.13123006 0.23403168] [ 1.4562814 -0.13111833 0.23407818]\n", + "0210 [ 1.4262199 -0.00746697 0.2284646 ] [ 1.425214 -0.0068635 0.2281561]\n", + "0211 [1.4067173 0.08745193 0.2235651 ] [1.406184 0.08789902 0.22353473]\n", + "0212 [1.3967514 0.01510829 0.22101402] [1.3985556 0.01515248 0.22156546]\n", + "0213 [ 1.3990402 -0.08337796 0.22163391] [ 1.3985556 -0.08294752 0.22156546]\n", + "0214 [ 1.3990879 -0.18152446 0.22163391] [ 1.3985556 -0.18104753 0.22156546]\n", + "0215 [1.3891697 0.0152275 0.18543005] [1.3897392 0.01580092 0.18444389]\n", + "0216 [ 1.3900757 -0.08285791 0.18446445] [ 1.3897392 -0.08229908 0.18444389]\n", + "0217 [1.3516903 0.27273595 0.18004179] [1.355349 0.17809643 0.17823887]\n", + "0218 [1.355648 0.07941425 0.17825365] [1.355349 0.07999643 0.17823887]\n", + "0219 [ 1.355648 -0.01871139 0.17822981] [ 1.355349 -0.01810357 0.17823887]\n", + "0220 [ 1.3554573 -0.11682361 0.17822981] [ 1.355349 -0.11620357 0.17823887]\n", + "0221 [1.3258457 0.07895529 0.15969276] [1.350992 0.07416813 0.16454986]\n", + "0222 [ 1.3510704 -0.02454817 0.16454458] [ 1.350992 -0.02393187 0.16454986]\n", + "0223 [ 1.350975 -0.12265295 0.1645565 ] [ 1.350992 -0.12203187 0.16454986]\n", + "0224 [1.3198853 0.00658333 0.1856327 ] [1.3185639 0.00737843 0.1849799 ]\n", + "0225 [ 1.3198853 -0.04820824 0.18886328] [ 1.3199975 -0.04906495 0.18808284]\n", + "0226 [ 1.3169289 -0.14433116 0.18764734] [ 1.3170664 -0.14368178 0.18766521]\n", + "0227 [ 1.283741 -0.01508892 0.15054941] [ 1.2825161 -0.01359348 0.1505973 ]\n", + "0228 [1.2773991 0.02726763 0.12904406] [1.2802871 0.0268489 0.12924907]\n", + "0229 [ 1.2811661 -0.04481375 0.12526512] [ 1.281893 -0.04435697 0.12530056]\n", + "0230 [1.256752 0.00579804 0.14359951] [1.2550334 0.00662953 0.1424193 ]\n", + "0231 [1.2338638 0.03864914 0.16739368] [1.2470627 0.0373537 0.15812509]\n", + "0232 [1.2228012 0.00989288 0.16541481] [1.230507 0.00573149 0.15915473]\n", + "0233 [1.1911869 0.15113205 0.16726255] [1.1944972 0.15107751 0.1675081 ]\n", + "0234 [1.1880875 0.11547655 0.16927719] [1.1888276 0.11529048 0.17007673]\n", + "0235 [1.1882782 0.04210025 0.1712203 ] [1.1887517 0.04229952 0.17163682]\n", + "0236 [ 1.188612 -0.03837347 0.17229319] [ 1.1890719 -0.03809111 0.17235862]\n", + "0237 [ 1.1810303 -0.12206435 0.17154217] [ 1.1814445 -0.12177607 0.1716738 ]\n", + "0238 [1.1601925 0.0488624 0.1465559] [1.1596715 0.04902053 0.14667733]\n", + "0239 [1.1569977 0.0243485 0.14115572] [1.1587884 0.02415654 0.14222465]\n", + "0240 [ 1.1586189 -0.0439778 0.14052391] [ 1.1588533 -0.04441284 0.14105166]\n", + "0241 [ 1.1581421 -0.1200363 0.13974905] [ 1.1585096 -0.12038234 0.140155 ]\n", + "0242 [ 1.1569977 -0.19921511 0.13900995] [ 1.1574662 -0.19900481 0.13892518]\n", + "0243 [ 1.1432648 -0.12612492 0.10296106] [ 1.1444707 -0.12581372 0.10319477]\n", + "0244 [ 1.146555 -0.08298755 0.07579327] [ 1.1472317 -0.0825896 0.07577471]\n", + "0245 [1.0779858 0.39111227 0.0318408 ] [1.1007514 0.20861617 0.04567735]\n", + "0246 [1.0962963 0.1502797 0.04243851] [1.0977017 0.1390936 0.04325611]\n", + "0247 [1.0971546 0.04101247 0.04323721] [1.0977017 0.04099359 0.04325611]\n", + "0248 [ 1.0972023 -0.04420131 0.04303455] [ 1.0977125 -0.04419044 0.04298145]\n", + "0249 [ 1.0822296 -0.01152903 0.04912615] [ 1.082575 -0.01156534 0.04948076]\n", + "0250 [1.0678291 0.06520152 0.05780458] [1.068213 0.06512611 0.0576891 ]\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a6a12995b58743e7b0fa1b44a5b298c8", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# fps = b3d.io.utils.load_video_info(video_file_path).fps\n", + "fps = 100\n", + "window_size = 1\n", + "delta_t = window_size/fps\n", + "PLOTS_PER_ROW = 3\n", + "\n", + "with h5py.File(hdf5_file_path, \"r\") as f:\n", + " object_ids = np.array(f['static']['object_ids'])\n", + " model_names = np.array(f['static']['model_names'])\n", + " distractors = np.array(f['static']['distractors']) if np.array(f['static']['distractors']).size != 0 else None if np.array(f['static']['distractors']).size != 0 else None\n", + " occluders = np.array(f['static']['occluders']) if np.array(f['static']['occluders']).size != 0 else None if np.array(f['static']['occluders']).size != 0 else None\n", + " \n", + " distractor_ids = np.concatenate([np.where(model_names==distractor)[0] for distractor in distractors], axis=0).tolist() if distractors else []\n", + " occluder_ids = np.concatenate([np.where(model_names==occluder)[0] for occluder in occluders], axis=0).tolist() if occluders else []\n", + " excluded_model_ids = distractor_ids+occluder_ids\n", + " included_model_names = [model_names[idx] for idx in range(len(object_ids)) if idx not in excluded_model_ids]\n", + " included_model_ids = [object_ids[idx]-1 for idx in range(len(object_ids)) if idx not in excluded_model_ids]\n", + " fig, axs = plt.subplots(len(included_model_ids), PLOTS_PER_ROW, figsize=(10, 10))\n", + "\n", + " for obj_idx in included_model_ids:\n", + " recorded = []\n", + " computed = []\n", + " for key in f['frames'].keys():\n", + " lin_vel = np.array(f['frames'][key]['objects']['velocities'])\n", + " center_now = np.array(f['frames'][key]['objects']['center_cam0'])\n", + " # if obj_idx == 2:\n", + " # print(key, center_now[obj_idx], lin_vel[obj_idx])\n", + " if int(key) < window_size:\n", + " continue\n", + " frame_idx = int(key)\n", + " center_last = np.array(f['frames'][str(frame_idx-window_size).zfill(4)]['objects']['center_cam0'])\n", + " linear_velocity = compute_linear_velocity(center_last[obj_idx], center_now[obj_idx], delta_t)\n", + " recorded.append(lin_vel[obj_idx])\n", + " computed.append(linear_velocity)\n", + " if obj_idx == 2:\n", + " print(key, linear_velocity, lin_vel[obj_idx])\n", + " recorded = np.array(recorded)\n", + " computed = np.array(computed)\n", + " frames = [i for i in range(computed[:,0].shape[0])]\n", + " for dim in range(PLOTS_PER_ROW):\n", + " axs[obj_idx][dim].plot(frames, recorded[:,dim], 'blue', label='recorded')\n", + " axs[obj_idx][dim].plot(frames, computed[:,dim], 'red', label='computed')\n", + " axs[obj_idx][dim].set_xlabel(\"frame\")\n", + " axs[obj_idx][dim].set_ylabel(\"linear velocity\")\n", + " axs[obj_idx][dim].legend()\n", + " axs[obj_idx][dim].set_title(f'object {obj_idx} dimension {dim}')\n", + " plt.tight_layout()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "745a82a9487445a29c38421d0c0ef4d7", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# fps = b3d.io.utils.load_video_info(video_file_path).fps\n", + "fps = 100\n", + "window_size = 1\n", + "delta_t = window_size/fps\n", + "PLOTS_PER_ROW = 3\n", + "\n", + "with h5py.File(hdf5_file_path, \"r\") as f:\n", + " object_ids = np.array(f['static']['object_ids'])\n", + " model_names = np.array(f['static']['model_names'])\n", + " distractors = np.array(f['static']['distractors']) if np.array(f['static']['distractors']).size != 0 else None if np.array(f['static']['distractors']).size != 0 else None\n", + " occluders = np.array(f['static']['occluders']) if np.array(f['static']['occluders']).size != 0 else None if np.array(f['static']['occluders']).size != 0 else None\n", + " \n", + " distractor_ids = np.concatenate([np.where(model_names==distractor)[0] for distractor in distractors], axis=0).tolist() if distractors else []\n", + " occluder_ids = np.concatenate([np.where(model_names==occluder)[0] for occluder in occluders], axis=0).tolist() if occluders else []\n", + " excluded_model_ids = distractor_ids+occluder_ids\n", + " included_model_names = [model_names[idx] for idx in range(len(object_ids)) if idx not in excluded_model_ids]\n", + " included_model_ids = [object_ids[idx]-1 for idx in range(len(object_ids)) if idx not in excluded_model_ids]\n", + "\n", + " scales = np.array(f['static']['scale'])\n", + " meshes_faces = [np.array(f['static']['mesh'][f'faces_{idx}']) for idx in range(len(object_ids))]\n", + " meshes_vertices = [np.array(f['static']['mesh'][f'vertices_{idx}']) for idx in range(len(object_ids))]\n", + " object_scales = [scale for idx, scale in enumerate(scales) if idx in included_model_ids]\n", + " object_meshes = [(scale_mesh(vertex, object_scales[idx]), face) for idx, (face, vertex) in enumerate(zip(meshes_faces, meshes_vertices)) if idx in included_model_ids]\n", + " \n", + " fig, axs = plt.subplots(len(included_model_ids), PLOTS_PER_ROW, figsize=(10, 10))\n", + "\n", + " for obj_idx in included_model_ids:\n", + " mesh = b3d.Mesh(vertices=object_meshes[obj_idx][0], faces=object_meshes[obj_idx][1], vertex_attributes=None)\n", + " recorded = []\n", + " computed = []\n", + " for key in f['frames'].keys():\n", + " if int(key) < window_size:\n", + " continue\n", + " frame_idx = int(key)\n", + " \n", + " position = np.array(f['frames'][key]['objects']['positions_cam0'])\n", + " rotation = np.array(f['frames'][key]['objects']['rotations_cam0'])\n", + " object_positions = np.asarray([pos for idx, pos in enumerate(position) if idx in included_model_ids])\n", + " object_rotations = np.asarray([rot for idx, rot in enumerate(rotation) if idx in included_model_ids])\n", + " object_pose = b3d.Pose(object_positions[obj_idx], object_rotations[obj_idx])\n", + "\n", + " mesh_transform = mesh.transform(object_pose)\n", + " mesh_transform = trimesh.Trimesh(mesh_transform.vertices, mesh_transform.faces)\n", + " center_now = mesh_transform.center_mass\n", + "\n", + " position = np.array(f['frames'][str(frame_idx-window_size).zfill(4)]['objects']['positions_cam0'])\n", + " rotation = np.array(f['frames'][str(frame_idx-window_size).zfill(4)]['objects']['rotations_cam0'])\n", + " object_positions = np.asarray([pos for idx, pos in enumerate(position) if idx in included_model_ids])\n", + " object_rotations = np.asarray([rot for idx, rot in enumerate(rotation) if idx in included_model_ids])\n", + " object_pose = b3d.Pose(object_positions[obj_idx], object_rotations[obj_idx])\n", + "\n", + " mesh_transform = mesh.transform(object_pose)\n", + " mesh_transform = trimesh.Trimesh(mesh_transform.vertices, mesh_transform.faces)\n", + " center_last = mesh_transform.center_mass\n", + "\n", + " # center_now = np.array(f['frames'][key]['objects']['center_cam0'])\n", + " # center_last = np.array(f['frames'][str(frame_idx-window_size).zfill(4)]['objects']['center_cam0'])\n", + " linear_velocity = compute_linear_velocity(center_last, center_now, delta_t)\n", + "\n", + " lin_vel = np.array(f['frames'][key]['objects']['velocities'])\n", + " recorded.append(lin_vel[obj_idx])\n", + " computed.append(linear_velocity)\n", + " recorded = np.array(recorded)\n", + " computed = np.array(computed)\n", + " frames = [i for i in range(computed[:,0].shape[0])]\n", + " for dim in range(PLOTS_PER_ROW):\n", + " axs[obj_idx][dim].plot(frames, recorded[:,dim], 'blue', label='recorded')\n", + " axs[obj_idx][dim].plot(frames, computed[:,dim], 'red', label='computed')\n", + " axs[obj_idx][dim].set_xlabel(\"frame\")\n", + " axs[obj_idx][dim].set_ylabel(\"linear velocity\")\n", + " axs[obj_idx][dim].legend()\n", + " axs[obj_idx][dim].set_title(f'object {obj_idx} dimension {dim}')\n", + " plt.tight_layout()\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## test whether center_cam0 refers to the center of the bounding box" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4999973 0.49999729435756135\n", + "0.49999753 0.49999751219368593\n", + "0.49999723 0.499997229335926\n", + "0.49999687 0.49999687731298126\n", + "0.4999966 0.49999660360602954\n", + "0.49999654 0.4999965243138434\n", + "0.49999648 0.4999964845204232\n", + "0.4999964 0.49999639252321004\n", + "0.4999964 0.49999639162342874\n", + "0.4999964 0.4999963923837772\n", + "0.49999636 0.4999963643591989\n", + "0.4999964 0.49999639567611937\n", + "0.49999642 0.49999643744862426\n", + "0.49999642 0.49999643399740723\n", + "0.5283991 0.5283990888353058\n", + "0.55632704 0.5563270695208256\n", + "0.584255 0.5842549834908188\n", + "0.612183 0.6121830067161166\n", + "0.64213914 0.6421391350703585\n", + "0.6721022 0.6721021819484835\n", + "0.70206535 0.7020653071324289\n", + "0.7320286 0.7320286590632853\n", + "0.7619921 0.7619921043328903\n", + "0.7919558 0.7919558394154673\n", + "0.82191974 0.8219197640117457\n", + "0.8518839 0.8518838740998479\n", + "0.8818482 0.8818482088647188\n", + "0.91181296 0.9118129499044911\n", + "0.94177794 0.9417779748622415\n", + "0.9717432 0.9717432217524299\n", + "1.0017087 1.0017088096982585\n", + "1.0316747 1.031674702897958\n", + "1.061641 1.0616409554491901\n", + "1.0916076 1.091607558377745\n", + "1.1215744 1.1215744479464351\n", + "1.1515417 1.151541696294093\n", + "1.1815091 1.18150916988587\n", + "1.211477 1.211477008094928\n", + "1.2414451 1.2414450843113602\n", + "1.262072 1.2620719683153216\n", + "1.2824602 1.2824601468570904\n", + "1.3028483 1.3028483123846288\n", + "1.3232368 1.3232368047859537\n", + "1.3436253 1.3436253089710166\n", + "1.3640141 1.3640141506668813\n", + "1.384403 1.3844029899716561\n", + "1.404792 1.404791979113742\n", + "1.425181 1.4251810326598788\n", + "1.4455703 1.44557029092696\n", + "1.4659594 1.4659594899549826\n", + "1.4863487 1.4863487800714181\n", + "1.5067381 1.5067380674025717\n", + "1.5271275 1.5271274701193338\n", + "1.5475168 1.5475168224290399\n", + "1.5679061 1.5679061697972638\n", + "1.5882955 1.5882954390587494\n", + "1.6086847 1.6086846830536001\n", + "1.6290739 1.6290738066617518\n", + "1.6494629 1.6494628965860738\n", + "1.6698518 1.6698518023048197\n", + "1.6902406 1.6902406391814775\n", + "1.7106293 1.7106292777563386\n", + "1.7310178 1.7310179088943312\n", + "1.7514062 1.7514061626372313\n", + "1.7717944 1.7717944548305644\n", + "1.7921824 1.7921825231255544\n", + "1.8125703 1.8125703431640712\n", + "1.8329577 1.8329578094544254\n", + "1.8533453 1.8533452476263768\n", + "1.8737323 1.8737322692968261\n", + "1.8941194 1.8941194395889163\n", + "1.914506 1.914506019192489\n", + "1.9348925 1.9348925579376621\n", + "1.9552788 1.9552787310803417\n", + "1.9756647 1.975664725057614\n", + "1.9960506 1.9960507100306064\n", + "2.0013077 2.0013076042961067\n", + "2.0056486 2.005648527996129\n", + "2.0099895 2.009989504453258\n", + "2.0143306 2.014330562381842\n", + "2.0186715 2.0186714936899435\n", + "2.0230124 2.0230123472305626\n", + "2.0273533 2.0273533024525996\n", + "2.0316942 2.0316941397281547\n", + "2.036035 2.0360350577084683\n", + "2.040376 2.040375932782852\n", + "2.0447168 2.0447168931414437\n", + "2.0490577 2.0490577737790447\n", + "2.0533986 2.0533985050466517\n", + "2.0577395 2.05773945298772\n", + "2.0620801 2.0620801257811134\n", + "2.066421 2.0664209907446636\n", + "2.0707617 2.0707616186671456\n", + "2.0744736 2.0744735319818597\n", + "2.07693 2.076930079570748\n", + "2.0789587 2.078958766668793\n", + "2.0807295 2.0807295640663597\n", + "2.0822654 2.08226542009554\n", + "2.083572 2.0835718744215304\n", + "2.0846334 2.0846334265708273\n", + "2.085472 2.0854722277795474\n", + "2.0860908 2.0860907396959014\n", + "2.0864902 2.0864900487675104\n", + "2.0866714 2.0866713924936344\n", + "2.0866349 2.0866349480726174\n", + "2.086381 2.0863810773653473\n", + "2.085909 2.0859089806689743\n", + "2.0852177 2.0852175944109974\n", + "2.084306 2.0843059989384867\n", + "2.0831733 2.0831733170353557\n", + "2.0818186 2.0818184986480808\n", + "2.0802372 2.0802371749020554\n", + "2.078429 2.0784290124616613\n", + "2.0763953 2.0763951982194793\n", + "2.0741336 2.07413373410638\n", + "2.0716424 2.0716423197704725\n", + "2.0689135 2.0689133573957292\n", + "2.0659492 2.0659492661765086\n", + "2.0627491 2.062749183923439\n", + "2.0593126 2.0593124689582685\n", + "2.0556307 2.0556306384193683\n", + "2.0517137 2.0517136722523888\n", + "2.0475597 2.047559552982518\n", + "2.0431583 2.0431582651985614\n", + "2.0385315 2.0385315053215916\n", + "2.0336766 2.0336765211839167\n", + "2.0285792 2.0285792873780073\n", + "2.0232816 2.0232816518476606\n", + "2.0177538 2.017753681503977\n", + "2.0120573 2.0120571911958645\n", + "2.006155 2.0061549865124175\n", + "2.0001326 2.0001324520325543\n", + "1.9939303 1.993930365645426\n", + "1.9876746 1.987674596560786\n", + "1.981282 1.9812819879637313\n", + "1.974924 1.9749239221970702\n", + "1.9684911 1.9684911195780523\n", + "1.9618094 1.9618094480433643\n", + "1.9549297 1.954929760259402\n", + "1.9481313 1.948131373633231\n", + "1.948781 1.9487810410822914\n", + "1.9509006 1.9509005458476467\n", + "1.9530587 1.9530587681175722\n", + "1.9550391 1.9550391656499793\n", + "1.956908 1.9569079240532732\n", + "1.9586921 1.9586920990337204\n", + "1.9603945 1.9603944626741443\n", + "1.9620119 1.9620119488997696\n", + "1.9635442 1.9635442721878236\n", + "1.9649789 1.9649789103956856\n", + "1.9662967 1.9662967054017362\n", + "1.967492 1.9674919978975973\n", + "1.9685546 1.9685546956690676\n", + "1.9694684 1.969468284304817\n", + "1.9702156 1.9702156018040233\n", + "1.9707776 1.970777629215467\n", + "1.9707943 1.9707942973394097\n", + "1.9703661 1.9703661402256039\n", + "1.9702677 1.9702676202919471\n", + "1.9705746 1.9705745926194318\n", + "1.9709929 1.970992896702917\n", + "1.9714385 1.9714385679088373\n", + "1.971875 1.971874955126334\n", + "1.9723464 1.9723464046603543\n", + "1.9728358 1.9728357259449516\n", + "1.9733634 1.9733634723826121\n", + "1.9738973 1.9738973223403327\n", + "1.9744732 1.9744731933703012\n", + "1.9750724 1.975072357300877\n", + "1.9757197 1.9757196891949176\n", + "1.9762931 1.9762930887196106\n", + "1.9768265 1.9768265218677807\n", + "1.9773167 1.9773167233130415\n", + "1.9777846 1.977784637625249\n", + "1.9782157 1.9782156908670097\n", + "1.9786171 1.9786170366724738\n", + "1.9789836 1.9789836542967558\n", + "1.9793181 1.9793181064037217\n", + "1.979642 1.9796420479801948\n", + "1.9799362 1.9799362557104587\n", + "1.9802017 1.9802017199396709\n", + "1.9804462 1.9804462513286305\n", + "1.980664 1.9806640990601498\n", + "1.9808728 1.9808727766259595\n", + "1.9810557 1.981055799617443\n", + "1.9812174 1.9812173866311864\n", + "1.9813635 1.9813635195572576\n", + "1.981491 1.9814909819041469\n", + "1.9816025 1.98160254796858\n", + "1.9816966 1.9816965972253864\n", + "1.981775 1.981775155397617\n", + "1.9818375 1.9818375320767392\n", + "1.9818841 1.9818841011681303\n", + "1.9819156 1.9819155712091112\n", + "1.9819318 1.9819317821658868\n", + "1.9819325 1.9819325345838115\n", + "1.9819186 1.9819185917241369\n", + "1.9818892 1.981889323733861\n", + "1.9818447 1.981844660212328\n", + "1.9817845 1.9817844866740115\n", + "1.9817086 1.9817086375034612\n", + "1.9816167 1.9816167718918538\n", + "1.9815084 1.981508302695146\n", + "1.981383 1.9813830116509195\n", + "1.9812397 1.9812397093621315\n", + "1.9810791 1.981079076233925\n", + "1.9808986 1.9808986770586592\n", + "1.9806998 1.980699802374693\n", + "1.9804794 1.9804793271731305\n", + "1.9802363 1.980236319022134\n", + "1.9799691 1.9799691096425607\n", + "1.9796877 1.9796877130483943\n", + "1.9793761 1.9793760849127746\n", + "1.9790343 1.9790343060072797\n", + "1.9786713 1.9786712530365158\n", + "1.9782742 1.9782742481604672\n", + "1.977842 1.9778419401189835\n", + "1.9773926 1.9773926161354258\n", + "1.9769037 1.9769036909733377\n", + "1.9763765 1.976376573407193\n", + "1.9758725 1.975872489066424\n", + "1.9753671 1.975367064716272\n", + "1.9749147 1.9749147038507593\n", + "1.9745018 1.9745018936510672\n", + "1.9741215 1.9741213802466688\n", + "1.9737823 1.9737822329157202\n", + "1.9734633 1.9734632814286066\n", + "1.9731715 1.9731715192140995\n", + "1.9729176 1.9729175105238037\n", + "1.9726825 1.97268251077365\n", + "1.9724784 1.9724783828152155\n", + "1.9722947 1.9722947008405003\n", + "1.9721335 1.9721335252667291\n", + "1.9719967 1.9719966637113064\n", + "1.9718815 1.9718814584449182\n", + "1.9717885 1.9717885277729088\n", + "1.9717166 1.9717166103287571\n", + "1.9716661 1.9716660214310404\n", + "1.971636 1.9716360970511437\n", + "1.9716271 1.9716271522134283\n", + "1.9716387 1.9716387263483273\n", + "1.9716706 1.9716706073194987\n", + "1.9717237 1.9717236406571779\n", + "1.9717971 1.9717971226649906\n", + "1.9718922 1.97189224667871\n", + "1.9720093 1.972009350254856\n", + "1.9721487 1.9721486207107433\n", + "1.972311 1.9723109953266373\n", + "1.9724967 1.9724966805767585\n", + "1.972707 1.9727070673742515\n", + "1.9729422 1.9729422365841798\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "006f8851987f4f6ebb6c97ded7d55b3b", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "with h5py.File(hdf5_file_path, \"r\") as f:\n", + " # extract object info\n", + " object_ids = np.array(f['static']['object_ids'])\n", + " model_names = np.array(f['static']['model_names'])\n", + " distractors = np.array(f['static']['distractors']) if np.array(f['static']['distractors']).size != 0 else None if np.array(f['static']['distractors']).size != 0 else None\n", + " occluders = np.array(f['static']['occluders']) if np.array(f['static']['occluders']).size != 0 else None if np.array(f['static']['occluders']).size != 0 else None\n", + " \n", + " distractor_ids = np.concatenate([np.where(model_names==distractor)[0] for distractor in distractors], axis=0).tolist() if distractors else []\n", + " occluder_ids = np.concatenate([np.where(model_names==occluder)[0] for occluder in occluders], axis=0).tolist() if occluders else []\n", + " excluded_model_ids = distractor_ids+occluder_ids\n", + " included_model_names = [model_names[idx] for idx in range(len(object_ids)) if idx not in excluded_model_ids]\n", + " included_model_ids = [object_ids[idx]-1 for idx in range(len(object_ids)) if idx not in excluded_model_ids]\n", + "\n", + " scales = np.array(f['static']['scale'])\n", + " meshes_faces = [np.array(f['static']['mesh'][f'faces_{idx}']) for idx in range(len(object_ids))]\n", + " meshes_vertices = [np.array(f['static']['mesh'][f'vertices_{idx}']) for idx in range(len(object_ids))]\n", + " object_scales = [scale for idx, scale in enumerate(scales) if idx in included_model_ids]\n", + " object_meshes = [(scale_mesh(vertex, object_scales[idx]), face) for idx, (face, vertex) in enumerate(zip(meshes_faces, meshes_vertices)) if idx in included_model_ids]\n", + " \n", + " fig, axs = plt.subplots(len(included_model_ids), PLOTS_PER_ROW, figsize=(10, 10))\n", + "\n", + " for obj_idx in included_model_ids:\n", + " mesh_tri = trimesh.Trimesh(vertices=object_meshes[obj_idx][0], faces=object_meshes[obj_idx][1])\n", + " oriented_bbox = mesh_tri.bounding_box\n", + " bounding_box_b3d = b3d.Mesh.from_trimesh(oriented_bbox)\n", + " recorded = []\n", + " computed = []\n", + "\n", + " for key in f['frames'].keys():\n", + " position = np.array(f['frames'][key]['objects']['positions_cam0'])\n", + " rotation = np.array(f['frames'][key]['objects']['rotations_cam0'])\n", + " object_positions = np.asarray([pos for idx, pos in enumerate(position) if idx in included_model_ids])\n", + " object_rotations = np.asarray([rot for idx, rot in enumerate(rotation) if idx in included_model_ids])\n", + " object_pose = b3d.Pose(object_positions[obj_idx], object_rotations[obj_idx])\n", + "\n", + " # Get the axis-aligned bounding box (AABB)\n", + " bounding_box_transform = bounding_box_b3d.transform(object_pose)\n", + " bounding_box_transform = trimesh.Trimesh(bounding_box_transform.vertices, bounding_box_transform.faces)\n", + " # Compute the center of mass using trimesh's built-in function\n", + " center_of_mass = bounding_box_transform.center_mass\n", + "\n", + " center_cam0 = np.array(f['frames'][key]['objects']['center_cam0'])\n", + " object_center_cam0 = np.array([pos for idx, pos in enumerate(center_cam0) if idx in included_model_ids])\n", + "\n", + " recorded.append(object_center_cam0[obj_idx])\n", + " computed.append(center_of_mass)\n", + " recorded = np.array(recorded)\n", + " computed = np.array(computed)\n", + " if obj_idx == 1:\n", + " for i,j in zip(recorded[:,0], computed[:,0]):\n", + " print(i,j)\n", + " frames = [i for i in range(computed[:,0].shape[0])]\n", + " for dim in range(PLOTS_PER_ROW):\n", + " axs[obj_idx][dim].plot(frames, recorded[:,dim], 'blue', label='recorded')\n", + " axs[obj_idx][dim].plot(frames, computed[:,dim], 'red', label='computed')\n", + " axs[obj_idx][dim].set_xlabel(\"frame\")\n", + " axs[obj_idx][dim].set_ylabel(\"center\")\n", + " axs[obj_idx][dim].legend()\n", + " axs[obj_idx][dim].set_title(f'object {obj_idx} dimension {dim}')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## debugging" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def set_axes_equal(ax):\n", + " \"\"\"\n", + " Make axes of 3D plot have equal scale so that spheres appear as spheres,\n", + " cubes as cubes, etc.\n", + "\n", + " Input\n", + " ax: a matplotlib axis, e.g., as output from plt.gca().\n", + " \"\"\"\n", + "\n", + " x_limits = ax.get_xlim3d()\n", + " y_limits = ax.get_ylim3d()\n", + " z_limits = ax.get_zlim3d()\n", + "\n", + " x_range = abs(x_limits[1] - x_limits[0])\n", + " x_middle = np.mean(x_limits)\n", + " y_range = abs(y_limits[1] - y_limits[0])\n", + " y_middle = np.mean(y_limits)\n", + " z_range = abs(z_limits[1] - z_limits[0])\n", + " z_middle = np.mean(z_limits)\n", + "\n", + " # The plot bounding box is a sphere in the sense of the infinity\n", + " # norm, hence I call half the max range the plot radius.\n", + " plot_radius = 0.5*max([x_range, y_range, z_range])\n", + "\n", + " ax.set_xlim3d([x_middle - plot_radius, x_middle + plot_radius])\n", + " ax.set_ylim3d([y_middle - plot_radius, y_middle + plot_radius])\n", + " ax.set_zlim3d([z_middle - plot_radius, z_middle + plot_radius])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ddc79444a9be4920b5028b2812452353", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib widget\n", + "\n", + "obj_idx = 1\n", + "frame = '0000'\n", + "trim = trimesh.Trimesh(vertices=object_meshes[obj_idx][0], faces=object_meshes[obj_idx][1])\n", + "oriented_bbox = trim.bounding_box\n", + "bounding_box_b3d = b3d.Mesh.from_trimesh(oriented_bbox)\n", + "\n", + "mesh_b3d = b3d.Mesh.from_trimesh(trim)\n", + "\n", + "with h5py.File(hdf5_file_path, \"r\") as f:\n", + " position = np.array(f['frames'][frame]['objects']['positions_cam0'])\n", + " rotation = np.array(f['frames'][frame]['objects']['rotations_cam0'])\n", + " object_pose = b3d.Pose(position[obj_idx], rotation[obj_idx])\n", + "\n", + " mesh_transform = mesh_b3d.transform(object_pose)\n", + " mesh_transform = trimesh.Trimesh(mesh_transform.vertices, mesh_transform.faces)\n", + " # Get the axis-aligned bounding box (AABB)\n", + " bounding_box_transform = bounding_box_b3d.transform(object_pose)\n", + " bounding_box_transform = trimesh.Trimesh(bounding_box_transform.vertices, bounding_box_transform.faces)\n", + "\n", + " # Compute the center of mass using trimesh's built-in function\n", + " # center_of_mass = mesh_transform.center_mass\n", + " # center_of_mass[[1,2]] = center_of_mass[[2,1]]\n", + " center_of_mass = bounding_box_transform.center_mass\n", + " center_of_mass[[1,2]] = center_of_mass[[2,1]]\n", + "\n", + " center_cam0 = np.array(f['frames'][frame]['objects']['center_cam0'])[obj_idx]\n", + " center_cam0[[1,2]] = center_cam0[[2,1]]\n", + "\n", + " fig = plt.figure()\n", + " ax = fig.add_subplot(projection='3d')\n", + " ax.set_box_aspect([1,1,1])\n", + " ax.plot_trisurf(mesh_transform.vertices[:, 0], mesh_transform.vertices[:,2], mesh_transform.vertices[:,1], triangles=mesh_transform.faces, \n", + " color=(0.5, 0.5, 0.5, 0.6))\n", + " ax.plot_trisurf(bounding_box_transform.vertices[:, 0], bounding_box_transform.vertices[:,2], bounding_box_transform.vertices[:,1], triangles=bounding_box_transform.faces, \n", + " color=(0.5, 1, 0.5, 0.6))\n", + " ax.scatter(*center_of_mass, color='red', s=100, label='computed', marker='o')\n", + " ax.scatter(*center_cam0, color='blue', s=100, label='recorded', marker='^')\n", + " # Print the corners of the bounding box\n", + " # for corner in oriented_bbox_corners:\n", + " # ax.scatter(*corner, color='green', s=100, marker='*')\n", + " set_axes_equal(ax)\n", + " plt.legend()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([4.9999729e-01, 4.2389247e-06, 2.5066552e-01], dtype=float32)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "center_cam0" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([4.99997294e-01, 4.22775823e-06, 2.50665505e-01])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "center_of_mass" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/tmp/ipykernel_6781/2711862174.py:56: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + " plt.legend()\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0eba62a156854e77ba33ca4e9bb71761", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib widget\n", + "\n", + "obj_idx = 1\n", + "frame = '0000'\n", + "trim = trimesh.Trimesh(vertices=object_meshes[obj_idx][0], faces=object_meshes[obj_idx][1])\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(projection='3d')\n", + "ax.set_box_aspect([1,1,1])\n", + "ax.plot_trisurf(trim.vertices[:, 0], trim.vertices[:,2], trim.vertices[:,1], triangles=trim.faces, \n", + " color=(0.5, 0.5, 0.5, 0.6))\n", + "\n", + "oriented_bbox = trim.bounding_box\n", + "ax.plot_trisurf(oriented_bbox.vertices[:, 0], oriented_bbox.vertices[:,2], oriented_bbox.vertices[:,1], triangles=oriented_bbox.faces, \n", + " color=(1, 0.5, 0.5, 0.6))\n", + "\n", + "# bounding_box_b3d = b3d.Mesh.from_trimesh(oriented_bbox)\n", + "# bounding_box_transform = bounding_box_b3d.transform(object_pose)\n", + "# bounding_box_transform = trimesh.Trimesh(bounding_box_transform.vertices, bounding_box_transform.faces)\n", + "\n", + "\n", + "# mesh_b3d = b3d.Mesh.from_trimesh(trim)\n", + "\n", + "# with h5py.File(hdf5_file_path, \"r\") as f:\n", + "# position = np.array(f['frames'][frame]['objects']['positions_cam0'])\n", + "# rotation = np.array(f['frames'][frame]['objects']['rotations_cam0'])\n", + "# object_pose = b3d.Pose(position[obj_idx], rotation[obj_idx])\n", + "\n", + "# mesh_transform = mesh_b3d.transform(object_pose)\n", + "# mesh_transform = trimesh.Trimesh(mesh_transform.vertices, mesh_transform.faces)\n", + "# # Get the axis-aligned bounding box (AABB)\n", + "# oriented_bbox = mesh_transform.bounding_box\n", + "# bounding_box_b3d = b3d.Mesh.from_trimesh(oriented_bbox)\n", + "# bounding_box_transform = bounding_box_b3d.transform(object_pose)\n", + "# bounding_box_transform = trimesh.Trimesh(bounding_box_transform.vertices, bounding_box_transform.faces)\n", + "\n", + "# # Compute the center of mass using trimesh's built-in function\n", + "# center_of_mass = mesh_transform.center_mass\n", + "# center_of_mass[[1,2]] = center_of_mass[[2,1]]\n", + "\n", + "# center_cam0 = np.array(f['frames'][frame]['objects']['center_cam0'])[obj_idx]\n", + "# center_cam0[[1,2]] = center_cam0[[2,1]]\n", + "\n", + "# fig = plt.figure()\n", + "# ax = fig.add_subplot(projection='3d')\n", + "# ax.set_box_aspect([1,1,1])\n", + "# ax.plot_trisurf(mesh_transform.vertices[:, 0], mesh_transform.vertices[:,2], mesh_transform.vertices[:,1], triangles=mesh_transform.faces, \n", + "# color=(0.5, 0.5, 0.5, 0.6))\n", + "# ax.plot_trisurf(bounding_box_transform.vertices[:, 0], bounding_box_transform.vertices[:,2], bounding_box_transform.vertices[:,1], triangles=bounding_box_transform.faces, \n", + "# color=(1, 0.5, 0.5, 0.6))\n", + "# ax.scatter(*center_of_mass, color='red', s=100, label='computed', marker='o')\n", + "# ax.scatter(*center_cam0, color='blue', s=100, label='recorded', marker='^')\n", + " # Print the corners of the bounding box\n", + " # for corner in oriented_bbox_corners:\n", + " # ax.scatter(*corner, color='green', s=100, marker='*')\n", + "set_axes_equal(ax)\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "gpu", + "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.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/test_vmf.ipynb b/test_vmf.ipynb new file mode 100644 index 00000000..4c4659cd --- /dev/null +++ b/test_vmf.ipynb @@ -0,0 +1,21596 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0, 0, 0],\n", + " [0, 0, 0],\n", + " [0, 0, 1]])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mu = (0,0,1)\n", + "p = 3\n", + "I = np.eye(p)\n", + "np.outer(mu, mu)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 0., 0.],\n", + " [0., 1., 0.],\n", + " [0., 0., 0.]])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "I - np.outer(mu, mu)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from mpl_toolkits.mplot3d import Axes3D # Just to enable 3D projection\n", + "from scipy.spatial.transform import Rotation as R\n", + "\n", + "def sample_vmf_ez(kappa, n_samples):\n", + " \"\"\"\n", + " Sample n_samples points from vMF distribution in 3D\n", + " with mean direction = e_z = (0,0,1).\n", + "\n", + " PDF ~ exp(kappa * z), z in [-1, 1].\n", + " \"\"\"\n", + " # 1) Sample 'z' using inverse transform (cdf is proportional to e^{kappa z})\n", + " u = np.random.rand(n_samples)\n", + " # e^{-kappa}, e^{kappa} for convenience\n", + " a = np.exp(-kappa)\n", + " b = np.exp(kappa)\n", + " \n", + " # Solve for z:\n", + " # u = [e^{kappa z} - e^{-kappa}] / [e^{kappa} - e^{-kappa}]\n", + " # => e^{kappa z} = u*(b - a) + a\n", + " # => z = (1/kappa) ln(...)\n", + " z = (1.0 / kappa) * np.log(u * (b - a) + a)\n", + "\n", + " # 2) Sample azimuth angle phi ~ Uniform(0, 2π)\n", + " phi = 2.0 * np.pi * np.random.rand(n_samples)\n", + "\n", + " # 3) Convert to Cartesian coords on the sphere\n", + " r = np.sqrt(1.0 - z**2)\n", + " x = np.zeros((n_samples, 3))\n", + " x[:, 0] = r * np.cos(phi)\n", + " x[:, 1] = r * np.sin(phi)\n", + " x[:, 2] = z\n", + " return x\n", + "\n", + "def sample_vmf_3d(mu, kappa, n_samples):\n", + " \"\"\"\n", + " Sample n_samples points from vMF(mu, kappa) in 3D.\n", + " Internally, we:\n", + " 1) Sample from vMF(e_z, kappa).\n", + " 2) Rotate e_z to mu.\n", + " \"\"\"\n", + " mu = np.asarray(mu, dtype=float)\n", + " mu /= np.linalg.norm(mu) # ensure it's a unit vector\n", + "\n", + " # Edge case: if mu is effectively the z-axis, no rotation needed\n", + " z_axis = np.array([0, 0, 1.0])\n", + " dot_ = np.dot(mu, z_axis)\n", + "\n", + " if np.allclose(dot_, 1.0, atol=1e-8):\n", + " # mu ~ (0, 0, 1); just sample directly\n", + " return sample_vmf_ez(kappa, n_samples)\n", + " else:\n", + " # Otherwise, find rotation from z-axis to mu\n", + " angle = np.arccos(dot_)\n", + " # Axis of rotation = cross(z, mu)\n", + " axis = np.cross(z_axis, mu)\n", + " axis /= np.linalg.norm(axis)\n", + " # Build the rotation object\n", + " rotvec = angle * axis\n", + " rot = R.from_rotvec(rotvec)\n", + "\n", + " # Sample from vMF(e_z, kappa), then rotate\n", + " x_ez = sample_vmf_ez(kappa, n_samples)\n", + " x = rot.apply(x_ez)\n", + " return x\n", + "\n", + "def sample_gaussian_approx(mu, kappa, n_samples):\n", + " \"\"\"\n", + " Sample n_samples points from the 'Gaussian approximation' of vMF(mu, kappa)\n", + " in 3D and then project them back onto the unit sphere.\n", + "\n", + " Approximate mean = mu (unit vector).\n", + " Approximate covariance = (1/kappa) * (I - mu mu^T).\n", + " \"\"\"\n", + " mu = np.asarray(mu, dtype=float)\n", + " mu /= np.linalg.norm(mu) # ensure unit\n", + " p = 3\n", + " I = np.eye(p)\n", + "\n", + " # Covariance in the tangent space at mu\n", + " # cov_tangent = (1.0 / kappa) * (I - np.outer(mu, mu))\n", + " cov_tangent = np.eye(len(mu)) / kappa\n", + "\n", + " # Draw samples from the Normal in R^3\n", + " # (strictly, it lives only in the subspace orthogonal to mu,\n", + " # but we can just sample from full R^3 with the above covariance.)\n", + " x_gauss = np.random.multivariate_normal(mean=mu, cov=cov_tangent, size=n_samples)\n", + "\n", + " # Project each sample back onto the sphere to ensure norm=1\n", + " norms = np.linalg.norm(x_gauss, axis=1, keepdims=True)\n", + " x_gauss_normed = x_gauss / norms\n", + " return x_gauss_normed\n", + "\n", + "# ------------------------------\n", + "# Main demonstration code\n", + "# ------------------------------\n", + "if __name__ == \"__main__\":\n", + " np.random.seed(42) # for reproducibility\n", + "\n", + " # Set parameters\n", + " n_samples = 1000\n", + " mu = np.array([0, 0, 1]) # mean direction\n", + " kappa = 20.0 # concentration (larger => more peaked)\n", + "\n", + " # 1) Sample from vMF\n", + " x_vmf = sample_vmf_3d(mu, kappa, n_samples)\n", + "\n", + " # 2) Sample from Gaussian approximation\n", + " x_gauss_approx = sample_gaussian_approx(mu, kappa, n_samples)\n", + "\n", + " # 3) Plot\n", + " fig = plt.figure(figsize=(12, 6))\n", + "\n", + " ax1 = fig.add_subplot(121, projection='3d')\n", + " ax1.scatter(x_vmf[:, 0], x_vmf[:, 1], x_vmf[:, 2],\n", + " s=5, alpha=0.4, color='blue')\n", + " ax1.set_title(f\"vMF Samples (kappa={kappa})\")\n", + " ax1.set_xlim([-1, 1]); ax1.set_ylim([-1, 1]); ax1.set_zlim([-1, 1])\n", + "\n", + " ax2 = fig.add_subplot(122, projection='3d')\n", + " ax2.scatter(x_gauss_approx[:, 0], x_gauss_approx[:, 1], x_gauss_approx[:, 2],\n", + " s=5, alpha=0.4, color='red')\n", + " ax2.set_title(\"Gaussian Approx. + Projected to Sphere\")\n", + " ax2.set_xlim([-1, 1]); ax2.set_ylim([-1, 1]); ax2.set_zlim([-1, 1])\n", + "\n", + " # Make them look a bit nicer\n", + " for ax in (ax1, ax2):\n", + " ax.set_xlabel('x')\n", + " ax.set_ylabel('y')\n", + " ax.set_zlabel('z')\n", + " ax.view_init(elev=20., azim=35)\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vMF PDF exact: 8.462449772476251\n", + "Gaussian approx PDF: 0.5317114007316764\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from math import pi, exp, log, sqrt\n", + "from scipy.special import iv # Modified Bessel function of the first kind\n", + "\n", + "def vmf_pdf_3d(x, mu, kappa):\n", + " \"\"\"\n", + " Exact vMF pdf in 3D:\n", + " f_vMF(x) = C_3(kappa) * exp(kappa * mu.dot(x)), where x and mu are unit vectors in R^3.\n", + " C_3(kappa) = (kappa / (2*pi*(exp(kappa) - exp(-kappa)))) [using a known simplification]\n", + " or more generally: C_3(kappa) = kappa/(4*pi*sinh(kappa)).\n", + " \"\"\"\n", + " x = x / np.linalg.norm(x) # ensure unit (if not already)\n", + " mu = mu / np.linalg.norm(mu)\n", + " # Normalizing constant in 3D:\n", + " # C_3(kappa) = kappa / (4*pi*sinh(kappa))\n", + " # also = kappa / (2*pi*(exp(kappa) - exp(-kappa))) \n", + " # they are the same, since sinh(kappa)= (exp(kappa)-exp(-kappa))/2\n", + " C3 = kappa / (4.0 * pi * np.sinh(kappa))\n", + " return C3 * np.exp(kappa * np.dot(mu, x))\n", + "\n", + "def gauss_approx_pdf_3d_on_sphere(x, mu, kappa):\n", + " \"\"\"\n", + " Gaussian approximation to vMF in 3D, evaluated at x on the unit sphere.\n", + " \n", + " We take the exponent from a 2D Gaussian in the tangent space with variance=1/kappa:\n", + " exponent ~ - (kappa/2)*||x - mu||^2 (for x near mu)\n", + " and then multiply by some constant 'A' to approximate normalization on the sphere.\n", + "\n", + " For a quick approximation, we might just ignore the needed spherical normalization\n", + " and return exp( -kappa/2 * ||x - mu||^2 ) up to a multiplicative constant.\n", + " \"\"\"\n", + " x = x / np.linalg.norm(x) # ensure unit\n", + " mu = mu / np.linalg.norm(mu)\n", + " diff = x - mu\n", + " sq_dist = np.dot(diff, diff) # squared Euclidean distance\n", + " # exponent\n", + " exponent = -0.5 * kappa * sq_dist\n", + " \n", + " # We can guess a constant ~ exp(kappa) / (4 pi) just to match the scale at mu.\n", + " # A more careful approach might use expansions of Bessel functions. \n", + " # For large kappa, ~ exp(kappa)/( (2*pi)^(3/2) * (1/kappa)^(1) ), etc.\n", + " # But let's keep it simple:\n", + " A_approx = 1.0 # You can tune or ignore if only relative densities matter.\n", + " \n", + " return A_approx * np.exp(exponent)\n", + "\n", + "# ---------------------------\n", + "# Demo usage:\n", + "if __name__ == \"__main__\":\n", + " mu = np.array([0, 0, 1], dtype=float)\n", + " kappa = 100.0\n", + "\n", + " # Some sample point on or near the sphere:\n", + " x = np.array([0.1, -0.05, 0.99])\n", + " x /= np.linalg.norm(x)\n", + "\n", + " f_vmf_exact = vmf_pdf_3d(x, mu, kappa)\n", + " f_gauss_approx = gauss_approx_pdf_3d_on_sphere(x, mu, kappa)\n", + "\n", + " print(\"vMF PDF exact: \", f_vmf_exact)\n", + " print(\"Gaussian approx PDF: \", f_gauss_approx)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from tensorflow_probability.substrates import jax as tfp\n", + "import jax.numpy as jnp\n", + "import jax\n", + "import matplotlib.pyplot as plt\n", + "import genjax" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array(0.8552929, dtype=float32)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "seed = jax.random.PRNGKey(156)\n", + "tfp.distributions.TruncatedNormal(1, 1, 0, jnp.inf).sample(\n", + " seed=seed\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array(0.8552929, dtype=float32)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "genjax.truncated_normal.sample(seed, 1, 1, 0, jnp.inf)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "jax.random.truncated_normal(seed, low, high, shape=None, dtype=)[source]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mean = 0\n", + "std = 1\n", + "low = 0\n", + "high = jnp.inf\n", + "# dist = tfp.distributions.TruncatedNormal(mean, std, low, high)\n", + "\n", + "x = jnp.linspace(-5, 5, 1000)\n", + "trunc_pdfs = jax.vmap(\n", + " lambda x: genjax.truncated_normal.logpdf(\n", + " x, mean, std, low, high\n", + " )\n", + ")(x)\n", + "normal_pdfs = jax.vmap(\n", + " lambda x: jax.scipy.stats.norm.logpdf(x, loc=mean, scale=std)\n", + ")(x)\n", + "plt.plot(x, trunc_pdfs, label=\"truncnorm\")\n", + "plt.plot(x, normal_pdfs, label=\"normal\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAABYaElEQVR4nO3deVyVdfr/8dc5h02QRUURFRF3lNzA3NKsFLO9mcqZSsdGmxzbjMoyZ6by2y9bzabSasqxsilrbJqabKHFJbeSXErNXUFFEVRAUbZzfn/cgCKgHDiH+5zD+/l43A/vc3MvF6ic63yW62NxOBwORERERExiNTsAERERadyUjIiIiIiplIyIiIiIqZSMiIiIiKmUjIiIiIiplIyIiIiIqZSMiIiIiKmUjIiIiIip/MwOoDbsdjsHDhwgNDQUi8VidjgiIiJSCw6Hg/z8fNq0aYPVWnP7h1ckIwcOHCAmJsbsMERERKQOMjIyaNeuXY1f94pkJDQ0FDC+mbCwMJOjERERkdrIy8sjJiam4n28Jl6RjJR3zYSFhSkZERER8TLnG2KhAawiIiJiKiUjIiIiYiolIyIiImIqrxgzIiIi3snhcFBSUkJpaanZoYgb2Gw2/Pz86l12Q8mIiIi4RVFREZmZmRQUFJgdirhRcHAw0dHRBAQE1PkeSkZERMTl7HY7u3fvxmaz0aZNGwICAlS00sc4HA6Kioo4fPgwu3fvpkuXLucsbHYuSkZERMTlioqKsNvtxMTEEBwcbHY44iZNmjTB39+fvXv3UlRURFBQUJ3uowGsIiLiNnX9pCzewxV/x3W6w5w5c4iLiyMoKIjExESWL19+zvPfffddevfuXdGvdNttt5GTk1OngEVERMS3OJ2MLFy4kClTpjB9+nTWrVvH0KFDGT16NOnp6dWe//333zNu3DgmTJjApk2b+PDDD/nxxx+ZOHFivYMXERER7+d0MjJr1iwmTJjAxIkTiY+PZ/bs2cTExDB37txqz1+9ejUdOnTgnnvuIS4ujosuuog77riDtWvX1jt4ERER8X5OJSNFRUWkpaWRnJxc6XhycjIrV66s9prBgwezb98+Fi9ejMPh4NChQ/z73//myiuvrHvUIiIibjJ8+HCmTJlidhiNilOzabKzsyktLSUqKqrS8aioKA4ePFjtNYMHD+bdd99lzJgxnDp1ipKSEq655hpeeumlGp9TWFhIYWFhxeu8vDxnwhQRL/L99mx+3HOEji1DGN61FeHB/maHJHJODoeD0tJS/Py8d0JqcXEx/v6e83+tTgNYz54r7nA4apw/vnnzZu655x7+9re/kZaWxhdffMHu3buZNGlSjfefOXMm4eHhFVtMTExdwhQRL3DP++t48Zvt3Pv+evo/+TXTPvqZIyeKzA5L3MDhcFBQVGLK5nA4ahXj+PHjWbp0KS+++CIWiwWLxcL8+fOxWCx8+eWXJCUlERgYyPLlyxk/fjzXXXddpeunTJnC8OHDK14PHz6ce+65h6lTp9K8eXNat27NY489VumaY8eO8ac//YmoqCiCgoJISEjgf//7HwDz588nIiKCL7/8kvj4eJo2bcrll19OZmZmxfV2u50ZM2bQrl07AgMD6dOnD1988UXF1/fs2YPFYuGDDz5g+PDhBAUFsWDBgor4n3zySaKiooiIiODxxx+npKSEBx98kObNm9OuXTvmzZvn3F90HTiV1kVGRmKz2aq0gmRlZVVpLSk3c+ZMhgwZwoMPPghAr169CAkJYejQoTzxxBNER0dXuWbatGmkpKRUvM7Ly1NCIuKj8k8VAxAW5EfeqRLe+yGdL37J5OWb+zGkc6TJ0YkrnSwupcffvjTl2ZtnjCI44PxveS+++CLbtm0jISGBGTNmALBp0yYApk6dynPPPUfHjh2JiIio9bPfeustUlJSWLNmDatWrWL8+PEMGTKEkSNHYrfbGT16NPn5+SxYsIBOnTqxefNmbDZbxfUFBQU899xzvPPOO1itVm699VYeeOAB3n333YqYn3/+eV577TX69u3LvHnzuOaaa9i0aRNdunSpuM9DDz3E888/zz//+U8CAwNZunQp3377Le3atWPZsmWsWLGCCRMmsGrVKoYNG8aaNWtYuHAhkyZNYuTIkW59H3aqZSQgIIDExERSU1MrHU9NTWXw4MHVXlNQUFBlDnL5D7mmTDUwMJCwsLBKm4j4JgtGq+oXU4ax8E8D6d46lKMFxYyb9wOL0vaZHJ00NuHh4QQEBBAcHEzr1q1p3bp1xXvWjBkzGDlyJJ06daJFixa1vmevXr149NFH6dKlC+PGjSMpKYlvvvkGgK+//poffviBjz76iJEjR9KxY0euuuoqRo8eXXF9cXExr776KklJSfTr14+77rqr4nqA5557joceeojf/e53dOvWjaeffpo+ffowe/bsSnFMmTKF3/zmN8TFxdGmTRsAmjdvzt///ne6devGH//4R7p160ZBQQGPPPIIXbp0Ydq0aQQEBLBixYq6/khrxekOr5SUFMaOHUtSUhKDBg3i9ddfJz09vaLbZdq0aezfv5+3334bgKuvvprbb7+duXPnMmrUKDIzM5kyZQoXXnhhxQ9DRBovB8aHEosFBnRswcd3DuGRj37mo3X7efDfG/D3s3JNb/2u8AVN/G1snjHKtGfXV1JSUp2u69WrV6XX0dHRZGVlAbB+/XratWtH165da7w+ODiYTp06VXt9Xl4eBw4cYMiQIZWuGTJkCBs2bDhv/D179qzUYBAVFUVCQkLFa5vNRosWLSqe5y5OJyNjxowhJyeHGTNmkJmZSUJCAosXLyY2NhaAzMzMSjVHxo8fT35+Pi+//DL3338/ERERXHrppTz99NOu+y5ExOuVt5AE+dt4/qbeBPpbee+HDB74YAMxzZrQt30zkyOU+rJYLLXqKvFUISEhlV5brdYqLfzFxcVVrjt7oKjFYsFutwNGOfXzqe76s59bm7GcZ8df073PFa+71GkA6+TJk9mzZw+FhYWkpaUxbNiwiq/Nnz+fJUuWVDr/7rvvZtOmTRQUFHDgwAEWLFhA27Zt6xW4iPgui8XC/7vuAkb2iKKo1M6kBWnkHC88/4UiLhAQEEBpael5z2vZsmWlgaRgtHQ4o1evXuzbt49t27Y5dV25sLAw2rRpw/fff1/p+MqVK4mPj6/TPc2gRQNExFQ1TXKwWi3Muqk3nVqGcCivkL99sqlhA5NGq0OHDqxZs4Y9e/aQnZ1dY6vApZdeytq1a3n77bfZvn07jz76KL/88otTz7r44osZNmwYv/3tb0lNTWX37t18/vnnlWbDnM+DDz7I008/zcKFC9m6dSsPP/ww69ev595773UqFjMpGRERj1BddYDQIH9mj+mLzWrhs42ZLP45s+pJIi72wAMPYLPZ6NGjBy1btqxxuZNRo0bx17/+lalTp9K/f3/y8/MZN26c089btGgR/fv35/e//z09evRg6tSptWqZKXfPPfdw//33c//993PBBRfwxRdf8Mknn1SaSePpLI7aTr42UV5eHuHh4eTm5mpmjYiP6fzIYkrsDtY8chlRYdUvP/7cl1t5+bsdtAgJ4NsHhhPexHOKNUn1Tp06xe7duysWVRXfda6/69q+f6tlRERMVZtPQ3df1plOLUPIOVHEK9/tcHtMItKwlIyIiEeovoazIdDPxl+u7AHA/BV72JtzomGCEpEGoWRERLzC8G4tGdolkqJSO09/8avZ4YiICykZERFT1XbYmsViYfqV8VgssPjng/x6UAtoivgKJSMi4hnO1U9TpnvrMK5IMNazevlbjR0R8RVKRkTEq9x1aWcAPvs5kx1Z+SZHIyKuoGREREzlbG2B+OgwkntE4XDAnCU73RKTiDQsJSMi4hEstemnKTP5EqN15H8bMsnKP+WukESkgSgZERFT1aXsYp+YCPq1j6Co1M67q6uvjinSWHTo0IHZs2ebHUa9KBkREa9025A4AN5ds5fCktqXzhYRz6NkREQ8QnVr05zL5QmtiQ4PIvt4Ef/boDVrxHMVFxebHYLHUzIiIl7J32bl1oGxACz8McPkaMSXDB8+nHvuuYepU6fSvHlzWrduzWOPPVbx9fT0dK699lqaNm1KWFgYN910E4cOHar4+mOPPUafPn2YN28eHTt2JDAwEIfDgcVi4bXXXuOqq64iODiY+Ph4Vq1axY4dOxg+fDghISEMGjSInTtPD8zeuXMn1157LVFRUTRt2pT+/fvz9ddfN+SPo0EoGRERj+BkwwgAv+3XDqsFfthzhJ2Hj7s8JnExhwOKTpizOTk46a233iIkJIQ1a9bwzDPPMGPGDFJTU3E4HFx33XUcOXKEpUuXkpqays6dOxkzZkyl63fs2MEHH3zAokWLWL9+fcXx//u//2PcuHGsX7+e7t27c/PNN3PHHXcwbdo01q5dC8Bdd91Vcf7x48e54oor+Prrr1m3bh2jRo3i6quvrnElYW/lZ3YAIiJ11To8iEu6teKbX7P4YG0G00bHmx2SnEtxATzZxpxnP3IAAkJqfXqvXr149NFHAejSpQsvv/wy33zzDQAbN25k9+7dxMTEAPDOO+/Qs2dPfvzxR/r37w9AUVER77zzDi1btqx039tuu42bbroJgIceeohBgwbx17/+lVGjRgFw7733ctttt1Wc37t3b3r37l3x+oknnuA///kPn3zySaWkxdupZURETFPbUvDnclN/4w1hUdp+ikvt9b6fCBjJyJmio6PJyspiy5YtxMTEVCQiAD169CAiIoItW7ZUHIuNja2SiJx936ioKAAuuOCCSsdOnTpFXp6x3MGJEyeYOnVqxTOaNm3Kr7/+qpYRERF3sDg7grXMpd1bEdk0kOzjhXz7axajerZ2cWTiMv7BRguFWc925nR//0qvLRYLdru9YuzH2c4+HhJSfSvMmfctP7+6Y3a7kVg/+OCDfPnllzz33HN07tyZJk2acMMNN1BUVOTU9+PplIyIiFfzt1n5bWJbXlu6iw/X7lMy4sksFqe6SjxRjx49SE9PJyMjo6J1ZPPmzeTm5hIf7/puwuXLlzN+/Hiuv/56wBhDsmfPHpc/x2zqphER07iglwaAG/q1A2DptiyOFfjWJ0bxLCNGjKBXr17ccsst/PTTT/zwww+MGzeOiy++mKSkJJc/r3Pnznz00UesX7+eDRs2cPPNN1e0mvgSJSMi4hHq1klj6BIVSvfWoRSXOvjil4Mui0nkbBaLhY8//phmzZoxbNgwRowYQceOHVm4cKFbnvfCCy/QrFkzBg8ezNVXX82oUaPo16+fW55lJovDFSPI3CwvL4/w8HByc3MJCwszOxwRcRG73UHHRxYDsO6vI2kWElDne81dspOnv/iVQR1b8N6fBroqRKmjU6dOsXv3buLi4ggKCjI7HHGjc/1d1/b9Wy0jImIaV34Surp3NACrd+dwKE+L54l4EyUjIuIR6jiZpkK7ZsEkxjbD4YBPN5g0Y0NE6kTJiIj4jGt6GwW1lIyIeBclIyJiGlcPWbuyVzRWC2zYl8u+owUuvbeIuI+SERHxCJZ6zacxRDYNJKlDcwC+2nToPGeLiKdQMiIiPqW86NmXmzTF1xN4wYRNqSdX/B0rGRER07jjbSq5h7Hex497jpBzvNANT5DaKC9xXlCg7jJfV/53fHYJfWeoHLyIeIb699IAENM8mJ5twth0II9vtmRVLKQnDctmsxEREUFWVhYAwcHBdV5/SDyTw+GgoKCArKwsIiIisNlsdb6XkhER8TnJPVqz6UAeX246qGTERK1bG11m5QmJ+KaIiIiKv+u6qlMyMmfOHJ599lkyMzPp2bMns2fPZujQodWeO378eN56660qx3v06MGmTZvq8ngR8RHuGk4wKiGKF77exvId2ZwoLCEkUJ+7zGCxWIiOjqZVq1YUFxebHY64gb+/f71aRMo5/T904cKFTJkyhTlz5jBkyBBee+01Ro8ezebNm2nfvn2V81988UWeeuqpitclJSX07t2bG2+8sX6Ri4hPcWULfreoUGJbBLM3p4Cl2w5zxQXRrru5OM1ms7nkDUt8l9MDWGfNmsWECROYOHEi8fHxzJ49m5iYGObOnVvt+eHh4bRu3bpiW7t2LUePHuW2226rd/AiItWxWCyaVSPiRZxKRoqKikhLSyM5ObnS8eTkZFauXFmre7z55puMGDGC2NjYGs8pLCwkLy+v0iYivsfhlvk0hpFls2qWbjtMqV3TS0U8mVPJSHZ2NqWlpURFRVU6HhUVxcGD5//0kZmZyeeff87EiRPPed7MmTMJDw+v2GJiNABNxNe5ep5F35gIwoL8OFZQzPqMYy6+u4i4Up3qjJw9PcvhcNRqytb8+fOJiIjguuuuO+d506ZNIzc3t2LLyMioS5gi0oj52awM69oSgCVbNZtDxJM5lYxERkZis9mqtIJkZWVVaS05m8PhYN68eYwdO5aAgIBznhsYGEhYWFilTUR8j7uLc17SrRUA3ykZEfFoTiUjAQEBJCYmkpqaWul4amoqgwcPPue1S5cuZceOHUyYMMH5KEXE57mjINbF3YyWkV/255GVd8rl9xcR13C6myYlJYU33niDefPmsWXLFu677z7S09OZNGkSYHSxjBs3rsp1b775JgMGDCAhIaH+UYuI1EJk00B6twsHYMm2wyZHIyI1cbrOyJgxY8jJyWHGjBlkZmaSkJDA4sWLK2bHZGZmkp6eXuma3NxcFi1axIsvvuiaqEVEaml4t1Zs2JfLkq1Z3JSkwfAinqhOZQknT57M5MmTq/3a/PnzqxwLDw/XYkkick7uWrXkku6tePGb7Szflk1xqR1/m9YHFfE0+l8pIqZpiNXle7UNp0VIAPmFJazdc9T9DxQRpykZERGfZrVaKqb4Lt+ucSMinkjJiIh4BHeuLn9R50gAVuzIdt9DRKTOlIyIiGncWQ7+TEPKkpGN+3M5VlDUIM8UkdpTMiIiPq91eBBdWjXF4YCVO3PMDkdEzqJkREQ8gsVt82kM5a0j36urRsTjKBkREdM0xGyackO7lCUj25WMiHgaJSMi4hHcOYAVYEDHFvhZLaQfKSA9R3WPRDyJkhERaRSaBvrRt30EoK4aEU+jZERETNOAvTQAXNTZqDeiKb4inkXJiIg0Ghd1aQHAip3ZlNobOhUSkZooGRGRRqN3uwhCA/04VlDM5gN5ZocjImWUjIiIaRwNOZ0G8LNZGdjJaB1ZvkOl4UU8hZIREfEI7p5NU25IWTKyeteRhnmgiJyXkhERaVTKW0bW7jlCcand5GhEBJSMiIiJzBhC2rVVKM2C/SkoKuXn/bkmRCAiZ1MyIiIewd3l4MtZrRYGxJV31WidGhFPoGRERBqdgR2bAxo3IuIplIyIiGkaeDJNhQEdNW5ExJMoGRERj9BQs2kAukWFEqFxIyIeQ8mIiDQ6xriR8q4ajRsRMZuSERExj4kV2Qd2VL0REU+hZEREPEID9tIAp5MRjRsRMZ+SERFplDRuRMRzKBkREdM4TOyn0bgREc+hZEREPIKlIafTlNG4ERHPoGRERBotjRsR8QxKRkTENGYVPSt35riRXzRuRMQ0SkZExCM0fCeNMW4kKbYZAGv3HDUhAhEBJSMi0sj172AMYv1xj8aNiJhFyYiImMbkXhoAksqSkbV7j+Iwu99IpJGqUzIyZ84c4uLiCAoKIjExkeXLl5/z/MLCQqZPn05sbCyBgYF06tSJefPm1SlgEfFNJkymAeCCtuEE+lk5cqKInYdPmBOESCPn5+wFCxcuZMqUKcyZM4chQ4bw2muvMXr0aDZv3kz79u2rveamm27i0KFDvPnmm3Tu3JmsrCxKSkrqHbyISH0F+FnpExPBmt1HWLvnCJ1bNTU7JJFGx+mWkVmzZjFhwgQmTpxIfHw8s2fPJiYmhrlz51Z7/hdffMHSpUtZvHgxI0aMoEOHDlx44YUMHjy43sGLiHfzlG6R8nEjP2jciIgpnEpGioqKSEtLIzk5udLx5ORkVq5cWe01n3zyCUlJSTzzzDO0bduWrl278sADD3Dy5Mkan1NYWEheXl6lTUR8mxlFz8r1L6vEqhk1IuZwqpsmOzub0tJSoqKiKh2Piori4MGD1V6za9cuvv/+e4KCgvjPf/5DdnY2kydP5siRIzWOG5k5cyaPP/64M6GJiBfyjHYR6Nc+AqsF0o8UcCjvFFFhQWaHJNKo1GkA69mfYBwOR42faux2OxaLhXfffZcLL7yQK664glmzZjF//vwaW0emTZtGbm5uxZaRkVGXMEVEaiU0yJ/urcMATfEVMYNTyUhkZCQ2m61KK0hWVlaV1pJy0dHRtG3blvDw8Ipj8fHxOBwO9u3bV+01gYGBhIWFVdpERNzpQnXViJjGqWQkICCAxMREUlNTKx1PTU2tcUDqkCFDOHDgAMePH684tm3bNqxWK+3atatDyCLiKzxk/CoASR2MSqxqGRFpeE5306SkpPDGG28wb948tmzZwn333Ud6ejqTJk0CjC6WcePGVZx/880306JFC2677TY2b97MsmXLePDBB/njH/9IkyZNXPediIjUQ/mMmi2ZeeSfKjY5GpHGxek6I2PGjCEnJ4cZM2aQmZlJQkICixcvJjY2FoDMzEzS09Mrzm/atCmpqancfffdJCUl0aJFC2666SaeeOIJ130XIuLVTJxIUyEqLIj2zYNJP1LAT+nHuLhrS7NDEmk0nE5GACZPnszkyZOr/dr8+fOrHOvevXuVrh0REYfHzKcxJHVoRvqRAtbuOaJkRKQBaW0aEZEyF5YXP9utcSMiDUnJiIiYzgN6aYDTi+atzzhGUYnd5GhEGg8lIyJiHs/qpaFTyxCahwRQWGLnlwO5Zocj0mgoGRER05lZCv5MFouFfu2NKb4/7VW9EZGGomREROQMibFGMpKmZESkwSgZERHTeFgvDXA6Gfkp/ajHrCos4uuUjIiI6Tyjk8bQq104flYLh/IK2X+s5tXFRcR1lIyIiJwhyN9Gz7bGWlrqqhFpGEpGRMQ0ntoL0q99BKBBrCINRcmIiJjOQybTVKgYxJquZESkISgZERE5S3kysiUzn4KiEpOjEfF9SkZExDSetjZNuejwJrQJD6LU7mBDhoqfibibkhERMZ3Fo+bTGPqdMcVXRNxLyYiISDXKK7FqRo2I+ykZERHTeOpsGlDxM5GGpGRERMzneb009GgTRpC/lWMFxezKPmF2OCI+TcmIiEg1/G1WerWLANRVI+JuSkZExDSe3vlR0VWjZETErZSMiIjpPLCXBtAgVpGGomRERKQG5WXht2cdJ7eg2NxgRHyYkhERMY2nz1Jp0TSQuMgQAH7KUOuIiLsoGRER03na2jRnKu+qWaeuGhG3UTIiInIOWjRPxP2UjIiIaTy8lwaAfrERAKxPP0ZJqd3cYER8lJIRETGdJ65NU65Lq1BCA/04UVTK1kP5Zocj4pOUjIiInIPNaqFP2awa1RsRcQ8lIyIi51ExbkTJiIhbKBkREdN58mwaOD2j5qf0Y+YGIuKjlIyIiGm8YQArQJ/2EVgskH6kgMP5hWaHI+JzlIyIiJxHWJA/XVuFAvCTpviKuJySERExnYf30gCnp/gqGRFxvTolI3PmzCEuLo6goCASExNZvnx5jecuWbIEi8VSZfv111/rHLSI+AaHx6/be1rfikqsx8wNRMQHOZ2MLFy4kClTpjB9+nTWrVvH0KFDGT16NOnp6ee8buvWrWRmZlZsXbp0qXPQIiINrXxGzYZ9xygqUfEzEVdyOhmZNWsWEyZMYOLEicTHxzN79mxiYmKYO3fuOa9r1aoVrVu3rthsNludgxYR32Lx9Ok0QMfIECKC/SkssbMlM8/scER8ilPJSFFREWlpaSQnJ1c6npyczMqVK895bd++fYmOjuayyy7ju+++O+e5hYWF5OXlVdpExPd4y2waMBKm01N8NW5ExJWcSkays7MpLS0lKiqq0vGoqCgOHjxY7TXR0dG8/vrrLFq0iI8++ohu3bpx2WWXsWzZshqfM3PmTMLDwyu2mJgYZ8IUEXGLfmWVWFX8TMS1/Opy0dlNqg6Ho8Zm1m7dutGtW7eK14MGDSIjI4PnnnuOYcOGVXvNtGnTSElJqXidl5enhETEh3l+J42hvGVknYqfibiUUy0jkZGR2Gy2Kq0gWVlZVVpLzmXgwIFs3769xq8HBgYSFhZWaRMR3+NFvTQA9I6JwGqB/cdOcjD3lNnhiPgMp5KRgIAAEhMTSU1NrXQ8NTWVwYMH1/o+69atIzo62plHi4iYLiTQj+6tjQ9HGjci4jpOd9OkpKQwduxYkpKSGDRoEK+//jrp6elMmjQJMLpY9u/fz9tvvw3A7Nmz6dChAz179qSoqIgFCxawaNEiFi1a5NrvRES8l7f002AUP9ucmcdPe49yxQX6UCXiCk4nI2PGjCEnJ4cZM2aQmZlJQkICixcvJjY2FoDMzMxKNUeKiop44IEH2L9/P02aNKFnz5589tlnXHHFFa77LkTEKzm8aTpNmcTYZixYnU6aWkZEXMbi8ILfBnl5eYSHh5Obm6vxIyI+ZNfh41z6/FLCgvzY+Ngos8Oplb05J7j42SUE2Kz8/HgygX6qmSRSk9q+f2ttGhERJ7RvHkyLkACKSu38sl81kERcQcmIiJjG45tlq2GxWOhXVhr+J9UbEXEJJSMiYjpvKAd/JlViFXEtJSMiIk4qXzTvp/SjXjkIV8TTKBkREdN46/t4r3bh+FktHMorZP+xk2aHI+L1lIyIiOm8rJeGIH8bPdqUFz87Zm4wIj5AyYiISB1UjBvRIFaRelMyIiIm8tJ+Gjg9o0aDWEXqTcmIiJjOy3ppAOjXPgKAzQfyOFVcam4wIl5OyYiISB20jWhCVFggJXYHG/flmh2OiFdTMiIipvHW2TRQVvysbNxImsaNiNSLkhERMZ23FT0rp+JnIq6hZEREpI7OLAuv4mcidadkRERM4+1v3wltwwiwWck5UUT6kQKzwxHxWkpGRMR03tlJA4F+NhLalhc/U1eNSF0pGRERqQcNYhWpPyUjImIaXxhmcXrcyDFzAxHxYkpGRMR0XjqZBji9gu+vB/M4UVhicjQi3knJiIiYxuH1Q1ghKiyIthFNsDtgQ8Yxs8MR8UpKRkRE6qlvWWl4DWIVqRslIyLiAby4n4bTXTU/pR8zNxARL6VkRERM4wsDWKFyJVYVPxNxnpIREZF6io8OI9DPyrGCYnZlnzA7HBGvo2REREznzbNpAAL8rPRuFwEYpeFFxDlKRkTENL7Uo9E3NgLQIFaRulAyIiLiAontVfxMpK6UjIiI6by8lwY4XYl1W1Y+eaeKTY5GxLsoGRER0/hC0bNykU0Dad88GIcD1muKr4hTlIyIiLjI6XojGjci4gwlIyJiOm+fTVOuX1klVq3gK+IcJSMiYhpfmk0D0LdsEOv6jGPY7T72zYm4UZ2SkTlz5hAXF0dQUBCJiYksX768VtetWLECPz8/+vTpU5fHioh4tO6tQwkOsJF/qoQdh4+bHY6I13A6GVm4cCFTpkxh+vTprFu3jqFDhzJ69GjS09PPeV1ubi7jxo3jsssuq3OwIuKbLD4xnwb8bKeLn6mrRqT2nE5GZs2axYQJE5g4cSLx8fHMnj2bmJgY5s6de87r7rjjDm6++WYGDRpU52BFRDxdv/LiZ0pGRGrNz5mTi4qKSEtL4+GHH650PDk5mZUrV9Z43T//+U927tzJggULeOKJJ877nMLCQgoLCyte5+XlOROmiHi6o3vhwDpa7vqZh/y20rTEBqu3QYvO0H4gBIaaHWGdaUaNiPOcSkays7MpLS0lKiqq0vGoqCgOHjxY7TXbt2/n4YcfZvny5fj51e5xM2fO5PHHH3cmNBHxdCePQdp82PgBZG0CIAr4sx9gB7742DjP6g8dhkDSBOh2Bdic+jVlur4xRjKy8/AJjhUUEREcYHJEIp6vTgNYLWfNw3M4HFWOAZSWlnLzzTfz+OOP07Vr11rff9q0aeTm5lZsGRkZdQlTRDxB8UlY8hS8kABfP2okIhYbtOnL0S438EbJaN63XQXx10CzOLAXw64l8MFYeKU//PqZV027aRYSQMfIEADWqfiZSK049ZEjMjISm81WpRUkKyurSmsJQH5+PmvXrmXdunXcddddANjtdhwOB35+fnz11VdceumlVa4LDAwkMDDQmdBExBPtWQH/vROO7jZet4yHQZOh+1UQ3Jx9+3J54ufvaRMSxO/GlA1uz9kJ6xYYrShHdsH7N0OXUXDtK9C0pWnfijP6xTZjV/YJfko/yiXdW5kdjojHc6plJCAggMTERFJTUysdT01NZfDgwVXODwsL4+eff2b9+vUV26RJk+jWrRvr169nwIAB9YteRDyT3Q7LnoW3rjISkdBouGEeTF4F/cZBcPOar23RCUY8ClM2wkUpYAuA7V/C3EGwa2nDfQ/10K+s3ohm1IjUjtOdsSkpKYwdO5akpCQGDRrE66+/Tnp6OpMmTQKMLpb9+/fz9ttvY7VaSUhIqHR9q1atCAoKqnJcRHxESRH8dzL8/KHxuvfv4Ypnqx2Ues61aQJDjaTkghtg0UTI2gwLfgNXzoLEP7gpeNcoH8S6IeMYpXYHNqtvTF0WcRenk5ExY8aQk5PDjBkzyMzMJCEhgcWLFxMbGwtAZmbmeWuOiIiPKsyHhWNh13dg9at14lDdmLMKUT3h9u/gk7uMBOfTe6AgG4be78LAXatLq6aEBvqRX1jC1oP59GgTZnZIIh7N4nB4/siwvLw8wsPDyc3NJSxM/6lFPFLxSVjwW9i7AvxD4Ka3ocuIc16ycd8xrnl5BW0jmrDi4arjxypxOOC7J2HZM8brEY/BRfe5JnY3GPvmGpZvz+b/rktg7MBYs8MRMUVt37+1No2I1F9pMXzwByMRCQyDP3x63kQEnJwkY7HApdPhkr8Yr79+DFbNqVO4DaF83Mg6jRsROS8lIyJSPw6HMWNm+5fgFwQ3L4R2ie573sUPwiXTjf0vH4Etn7rvWfXQr2zcSJqKn4mcl5IREamfFbNh40JjjMhN70Bs1Zl1LjfsQeg/EXDAotthf5r7n+mkPjERAOzNKSD7eOG5TxZp5JSMiEjdbfsSvi6rljz6aeia7NTldR6wZrHA5U9D55FQchLeuxmOH67r3dwivIk/3aKMGURr96h1RORclIyISN0c2W1MucUBibeVtVTUzbkm09TI5gc3/hMiu8Hxg7BoAthL6xyDOyR1MLpqftxzxORIRDybkhERcV5psZGIFOZBuwth9DPmxBEYasza8Q+G3UthqUlx1ODCOKO421olIyLnpGRERJy39GnYvxYCw+GGN8GvbovBuaSyQKvucNXs03HtrXkF8YbWv4ORjPxyII8ThSUmRyPiuZSMiIhz9nwPy54z9q+eDRHt633LOnXTnKn3GOh7K+CAj/8MhcfrHZMrtIloQtuIJpTaHVo0T+QclIyISO0VHof//BlwQJ9bIeE39bqdSysujpoJ4TFwdA+k/s2Vd66X/mXjRn5QV41IjZSMiEjtfff/IDcdwtvD6KfMjqayoDC49mVjf+2bsPNbc+Mp079s3MiPu5WMiNREyYiI1M6+tbB6rrF/9QvVLnxXVxZctJBcx+HQ/3Zj/5N7oOiEa+5bDxeWjRtZl3GUohK7ydGIeCYlIyJyfiVF8MndgAN6/Q46n7/Ue224ZWWskY8bLTe5GR4xu6Zzq6Y0C/bnVLGdTQdyzQ5HxCMpGRGR81v5d8jaDMEtYNSTZkdzbgEhcEVZErLqZcjaYmo4FouFpLLWEdUbEamekhERObfc/bD8eWN/1EwIaeHyR9R7Ns3Zuo2GbleCvQQ+u99NTTC1VzGIdbcqsYpUR8mIiJzb149CcQHEDIReN7n45m5MEkY/ZRRD27sCNrzvvufUQnm9kbV7j2C3m5sYiXgiJSMiUrP01fDzh4DFWHvG5U0YbhTRHi6eaux/87ipg1kT2obTxN/GsYJidhz2jBooIp5EyYiIVM9eCp+XvZn3Gwdt+rjtUW5LcQZOhohYyM+ElS+56ynn5W+z0rd9BKBxIyLVUTIiItVbtwAyNxgl3y9zTxExtw/l8AuEEY8Z+ytehLxMNz+wZhWDWFVvRKQKJSMiUlXRCaPAGcDwhyEk0tx46qPn9cZifsUF8O0TpoVxYcWMGg1iFTmbkhERqWr1XDh+CJp1gP4T3f44izvHolgsp6cjr3/XaO0xQd/2EdisFvYfO8n+YydNiUHEUykZEZHKCo4YXRoAl/ylzivy1kaDzSuJ6Q8JvzWe+NVfG+qplYQE+pHQJgxQV43I2ZSMiEhly5+HwjxofUHZG7iPuOxvYPWH3Uth9zJTQiif4qtF80QqUzIiIqcdy4AfXjf2L3sMrA3zK6JBJgw36wCJfzD2v33ClEJoF5YtmveDWkZEKlEyIiKnLXkKSougw1DofJnbH9fg+cDQB8AvCDLWwPbUBn64kYxYLLAj6zhZ+aca/PkinkrJiIgYcnbChveM/RGPeVeBs9oKi4YLy1b1/fb/wN6wq+hGBAcQ39oYN7Jml1pHRMopGRERw7LnwFEKXZKhXVLDPrsh854h90FAKBzcCFs+acAHGwZ2NNb2Wb0rp8GfLeKplIyICBzZBRsXGvsXP9xgj3WYsYBdSAsYNNnY/+7JBm8dGdjRGDeiZETkNCUjIgLLnjdaRTqPhHaJZkfjfoPuhKBwyN4KW/7boI8eENcCiwV2Hj6hcSMiZZSMiDR2R3adHisyvOFaRc7U4KNTgsJhwJ+N/WXPNehI2vBgf3pEa9yIyJmUjIg0dsvLW0VGNPhYERM6aU4bcAcENIVDv8DWzxv00eXjRlapq0YEUDIi0rgd2Q0b3jf2G3CsiEcIbn56Zs2yZxu0dUSDWEUqq1MyMmfOHOLi4ggKCiIxMZHly5fXeO7333/PkCFDaNGiBU2aNKF79+688MILdQ5YRFxo+fNgL4FOlxkl003i1rVpzmXgneDXBA78BDu/abDHXtjBqDey6/AJsvI0bkTE6WRk4cKFTJkyhenTp7Nu3TqGDh3K6NGjSU9Pr/b8kJAQ7rrrLpYtW8aWLVv4y1/+wl/+8hdef/31egcvIvWQd+CMVpGHTAnBjMk0lTRtCUl/NPaXNlzryJnjRlarGquI88nIrFmzmDBhAhMnTiQ+Pp7Zs2cTExPD3Llzqz2/b9++/P73v6dnz5506NCBW2+9lVGjRp2zNUVEGsCa18BeDO0HQ/sBpoZianm1wXeDLRAyVsOe7xvsseqqETnNqWSkqKiItLQ0kpOTKx1PTk5m5cqVtbrHunXrWLlyJRdffHGN5xQWFpKXl1dpExEXKsyHtH8a+4PvNjcWs4VFQ7+xxv6yZxrssYOUjIhUcCoZyc7OprS0lKioqErHo6KiOHjw4DmvbdeuHYGBgSQlJXHnnXcyceLEGs+dOXMm4eHhFVtMTIwzYYrI+axbAKdyoUVn6Hq5aWE4zJ1Pc9qQKWD1M1bz3Z/WII/sH3d63MghjRuRRq5OA1jPHmzmcDjOOwBt+fLlrF27lldffZXZs2fz3nvv1XjutGnTyM3NrdgyMjLqEqaIVKe0BFbPMfYH3dlgK/Oei+nL4ETEwAU3Gvsr/t4gjwxv4k/PNmXjRtQ6Io2cnzMnR0ZGYrPZqrSCZGVlVWktOVtcXBwAF1xwAYcOHeKxxx7j97//fbXnBgYGEhgY6ExoIlJbWz6BY+kQ3AJ6V/9/sFEafLdR/G3LJ8aigS06uf2RA+Na8Mv+PFbvyuHaPm3d/jwRT+XUR6KAgAASExNJTa289HZqaiqDBw+u9X0cDgeFhYXOPFpEXMHhgJUvGfv9bwf/JibHY+7jK4nqaSwS6LDDqlca5JEVxc92qmVEGjenWkYAUlJSGDt2LElJSQwaNIjXX3+d9PR0Jk2aBBhdLPv37+ftt98G4JVXXqF9+/Z0794dMOqOPPfcc9x9dyMfNCdihvRVRk0NvyDoX/O4rYZmMXc+zWmD74HtX8H6d2H4NGPqrxsN6Ngcm9XCnpwCMo4UENM82K3PE/FUTicjY8aMIScnhxkzZpCZmUlCQgKLFy8mNjYWgMzMzEo1R+x2O9OmTWP37t34+fnRqVMnnnrqKe644w7XfRciUjvlrSK9f+f2N1qv1OEiaNPPSNh+/Adc8ohbHxca5E/fmAjW7j3Kyp3ZjGne3q3PE/FUFocpa3g7Jy8vj/DwcHJzcwkLCzM7HBHvlL0dXu4POOCutRDZxeyIWLEjm1veWEO3qFC+vG+Y2eEYNn0MH/4BmjSD+zZBQIhbH/dC6jZe/GY7V/duw0u/7+vWZ4k0tNq+f5s/jF5EGsaqVwAHdLvCIxKRM5k+m+ZM8VdDszg4edSYAu1mF3WJBIzEzG73+M+GIm6hZESkMTiRbcwUARh0l7mxnMEj22WtttOF4Fa+bEyFdqM+MRGEBNg4cqKILQdV4FEaJyUjIo3Bj29AySljPERs7We+NVp9bobgSMhNh80fu/VR/jYrA8pm1azYke3WZ4l4KiUjIr6u+CT8ULYw5eC7PKxPxEP5N4EBZYPsV8x2exPOkM5GV833OzTFVxonJSMivm7D+1CQA+HtIf5as6OpxGPKwVen/0TwD4aDP8Me9y7seVFZMvLD7hwKS0rd+iwRT6RkRMSX2e2w6mVjf+Cfweb0bP7GK7i50V0Dbi+C1jWqKS1DAzlVbOenvcfc+iwRT6RkRMSXbf8ScnZAYPjplWk90PnWtjLNgD8bf277ArJ3uO0xFoulonVE40akMVIyIuLLyoucJd0GgaHmxlINj5xNc6bIztB1tLFfvrigm5weN6JkRBofJSMivmp/GuxdAVa/04MxxXmD7jT+XP8vKDjitscM6WzMqNm47xi5BcVue46IJ1IyIuKrVpaNFbngRghrY24s5+GhnTSGDhdB615QchLWznPbY6LDm9CpZQh2B6zapdYRaVyUjIj4oqN7T9fHKP9k74E8vZcGMKZClxeK++EfUFLktkcN7WKsF7R022G3PUPEEykZEfFFa14Fhx06XgKtLzA7Gu/X83po2hqOH4RNH7ntMcO7GcnIkq2H8YJlw0RcRsmIiK85eQx+etvYLy9r7uE8dTJNBb8AGPAnY3/Vy24beTuwYwsC/axk5p5i26HjbnmGiCdSMiLia9LmQ9FxaNUTOl1qdjTn5FWf/hNvc3sRtCB/GwPLSsMv3ZbllmeIeCIlIyK+pKTI6KIBlX53tQYqgnZmV41IY6FkRMSX/LII8jON8Q0JN5gdTa15Tc404M+ApawI2na3PGJ4t1YA/LjnCMcL3btisIinUDIi4iscjtOl3wfcYYxz8HBe1EljiOwMXS839lfPdcsj4iJDiG0RTHGpg5UqgCaNhJIREV+x6zs49Av4hxgVV8U9GqAI2sVdy7pqNMVXGgklIyK+orzIWb+x0KSZubE4yeLZZc8qa4AiaOXjRpZqiq80EkpGRHzBoU2w8xuwWI3Veb2FN77PViqC9jqUFLr8EYM6RhLgZ2X/sZPsyNIUX/F9SkZEfEH57I74a6BZB1NDaRQqiqAdgl9cXwStSYCNAXHNAc2qkcZByYiIt8vLhI0fGPteUuTsbF4zm6bcmUXQVr/iliJo5bNqlqjeiDQCSkZEvN0Pr4G9GNoPgnZJZkfjFIdX9tOUcXMRtPJxIz/s1hRf8X1KRkS8WeHx04MovbRVxGudWQStfPCwC3WMDKFD2RTfZZpVIz5OyYiIN1u3AE7lQvNO0HW02dHUmbf10lQoL4K2/Us4vM2lt7ZYLIzsEQXA15sPufTeIp5GyYiItyotgdVzjP1Bd4LV+/47e/2s1cjO0O0KY3+V61tHRsQbyci3W7MoKbW7/P4insL7fnuJiOHXT+HYXghuAb1/b3Y09eN1I1jPMLhsmu+G9+G4a7tTEmObERHsz7GCYtL2HnXpvUU8iZIREW/kcMDKl4z9/hMhINjceBqz9oOgbSKUFsKP/3Dprf1sVi4tm1Xz9RZ11YjvUjIi4o3SV8P+NLAFQv/bzY6mzry+mwaMVp3ywcM//AOKClx6+xFl40ZSNx9SNVbxWUpGRLxReatI799B05bmxuICXtxJY+h+NUS0h5NHYMN7Lr31sK4tCbBZ2ZNTwM7DJ1x6bxFPoWRExNtk74Cti4398rLkYi6bHwwsW0Bv1Stgd91g06aBfgzs1AJQV434rjolI3PmzCEuLo6goCASExNZvrzmgj8fffQRI0eOpGXLloSFhTFo0CC+/PLLOgcs0uiteglwGFN5W3Y1O5p68alOh763QlA4HNkJ2z536a1HxpeNG9EUX/FRTicjCxcuZMqUKUyfPp1169YxdOhQRo8eTXp6erXnL1u2jJEjR7J48WLS0tK45JJLuPrqq1m3bl29gxdpdI5nwfqyboAh95obiwt582SaCoFNIemPxn55N5qLXFY2xTct/SjZx12/MJ+I2ZxORmbNmsWECROYOHEi8fHxzJ49m5iYGObOnVvt+bNnz2bq1Kn079+fLl268OSTT9KlSxc+/fTTegcv0uisec2YtdGuP7QfaHY09eZzAzIvvAOs/pC+Cvatddlt20Q04YK24Tgc8NUmtY6I73EqGSkqKiItLY3k5ORKx5OTk1m5cmWt7mG328nPz6d58+Y1nlNYWEheXl6lTaTRKzwOP75h7A++x0eaE3xMWDT0usnYd3HryOgLWgPw+S+ZLr2viCdwKhnJzs6mtLSUqKioSsejoqI4ePBgre7x/PPPc+LECW666aYaz5k5cybh4eEVW0xMjDNhivimdQvg1DFo3hG6X2l2NC7lU2nVoLKBrFs+gSO7XXbb0QnRAKzcmcPRE0Uuu6+IJ6jTAFbLWZ/IHA5HlWPVee+993jsscdYuHAhrVq1qvG8adOmkZubW7FlZGTUJUwR31FaYixVD8YMGqvN3HhcxMc6aQxRPaHTZeCww+rqu6/rIi4yhPjoMErtDlI1kFV8jFPJSGRkJDabrUorSFZWVpXWkrMtXLiQCRMm8MEHHzBixIhznhsYGEhYWFilTaRR2/wxHEuH4MjTK8WK5yovgrZuARQccdltr0gwumoWq6tGfIxTyUhAQACJiYmkpqZWOp6amsrgwYNrvO69995j/Pjx/Otf/+LKK32reVnE7RwOWPl3Y//CP4F/E3PjcYPatKx6lY7DISoBik/A2nkuu+3oC4yumhU7ssktKHbZfUXM5nQ3TUpKCm+88Qbz5s1jy5Yt3HfffaSnpzNp0iTA6GIZN25cxfnvvfce48aN4/nnn2fgwIEcPHiQgwcPkpub67rvQsSX7V4GmRvAr4mxDo0P8bXJNBXOLBG/5lUoPumS23Zu1ZSuUU0pLnWoAJr4FKeTkTFjxjB79mxmzJhBnz59WLZsGYsXLyY2NhaAzMzMSjVHXnvtNUpKSrjzzjuJjo6u2O6913dqJIi41YoXjT/73gohLcyNRWov4bcQ3h5OHDa6a1ykfCCrZtWIL/Gry0WTJ09m8uTJ1X5t/vz5lV4vWbKkLo8QEYCDv8DOb8BiPT1Lwwf5WCeNweZvtI58/qDRzZY43jhWT1f2iubFb7azbFs2+aeKCQ2q/z1FzKa1aUQ82fcvGH/2uBaax5kbi1v4aj9NmX5jIaSlMfj4l0UuuWWXVk3p1DKEolK7ZtWIz1AyIuKpcnbCpo+M/YtSzI1F6sa/CQz8s7H//QsuWUDPYrFwde82AHy8/kC97yfiCZSMiHiq718walV0GQXRvcyOxq18bTJNJf0nQmAYHP7VZQvoXdenLQDfbz/M4XytVSPeT8mIiCfK3Qcb3jf2h95vbixu5LOzac4UFH56FtTy513yTXeIDKF3TAR2B/xvo1pHxPspGRHxRCv+DvZi6DAU2g8wOxqpr4GTwS8I9qcZU7Vd4Lo+RlfNf9VVIz5AyYiIpzmeBT+9Zez7cKvImSy+OZ/mtKYtoe9YY//7WS655VW92mC1wPqMY+zJPuGSe4qYRcmIiKdZPQdKTkHbRKOSpw9rDL00FYbcA1Y/2LXEaCGpp5ahgQzpHAmodUS8n5IREU9y8ij88IaxP/QBHx/Z2chEtIcLbjT2lz3vkluWD2T97/r9OBrFABzxVUpGRDzJD/+Aonxo1RO6Xm52NA2nseRcF6UAFtj6mVHiv55GJbQmyN/KruwT/LxfS2yI91IyIuIpTuUZXTQAQ1PA6vv/PRvdh/mWXeGCG4z9JU/X+3ZNA/0Y2cNYyXdR2r5630/ELL7/207EW6x5zeimadEFel5vdjTiLsOmGuX9XdQ6ckNiO8AogHaquLTe9xMxg5IREU9w8hisesnYH/4wWG2mhtPQGksvDWC0jiSUt448Ve/bXdQ5krYRTcg9WcyXmw7W+34iZlAyIuIJVs+FU7nQMr5RtYo4Gtd8mtOGPVjWOrIYDqyv161sVktF68gHazNcEJxIw1MyImK2giOnx4o0wlaRRunM1pGl9R87cmNSOywWWLEjh4wjBfW+n0hDUzIiYrZVr0BhHkQlQPw1ZkdjikY5g/niqWe0jqyr163aNQvmorKaI2odEW+kZETETCdyYM2rxv7waY1iBs2ZGt1smjNFdjldd+S7mfW+3U1JMQD8O20fpfbG/IMVb9S4fvOJeJqVf4ei4xDdG7pfaXY00tAufggsNtj+JexdVa9bJfeMIiLYn8zcUyzbfthFAYo0DCUjImbJPwg/vG7sXzK9kfZVGHx+bZqatOgE/crWrPn60Xo1FQX62bi+r1GR9V9r0l0RnUiDUTIiYpYlT0FxAbS7ELokmx2NKdSZAFz8MPg1gYw1sPXzet3qlgHtAfhmyyH2HzvpiuhEGoSSEREzZG+Hn9429kfOaNStIo1eWDQMnGTsfzMD7HUvXNa5VShDOrfA7oB3V+91UYAi7qdkRMQM3zwOjlLodgXEDjI7GtM1+lxsyBQIioDDW2DjwnrdatygDgC8/2OGKrKK11AyItLQMn6ALZ8a0zove9TsaEyllWbLNIkw1iMC+O5JKD5V51td1r0VbSOacOREEZ9tzHRNfCJupmREpCE5HJBaloD0uQVadTc3Hg/R6FtGAC78E4S2gdwMWPtmnW/jZ7Nyy0Bj7Mjbq/a4KDgR91IyItKQtn0B6SvBL8ioKyJSzr+JUYEXYNmzRmXeOhqTFEOAzcqGfbn8lH7URQGKuI+SEZGGUlIEX/3F2B/4Zwhva2484nn63AKtehqrN9djEb0WTQO5pk8bAN5YvstV0Ym4jZIRkYbyw+uQswNCWsFFKWZH41EabZ2Rs9n84PInjf0f34CsX+t8q9uHdgTg818Osif7hCuiE3EbJSMiDeF41ukF0UY8CkFh5sbjITR+tRodh0O3K43ZVl8+UucfUrfWoVzSrSUOB7zxvVpHxLMpGRFpCN/+n7EYXnQf6H2z2dGIp0v+P7D6w85vYPtXdb7Nn4Z1AuDDtfvIPl7oquhEXE7JiIi7HVgHP71j7I9+ptEthlcbmk1zlhadjHFFYLSOlBTV6TYDOzand7twCkvsvL1KRdDEc+m3oog7ORzw+cOAw1ihtf0AsyPyKA4VhK/ZsAchpKUxzmjN3DrdwmKxVLSOvL1qD8cLS1wZoYjLKBkRcacN70PGavAPhhGPmx2NeJOgMBjxmLG/5Ck4VrfF7y5PaE1cZAjHCopVd0Q8Vp2SkTlz5hAXF0dQUBCJiYksX768xnMzMzO5+eab6datG1arlSlTptQ1VhHvUnAEvppu7A97UFN5xXm9b4b2g40FFT9/qE63sFkt3H1pZwD+sWyXWkfEIzmdjCxcuJApU6Ywffp01q1bx9ChQxk9ejTp6dVn7YWFhbRs2ZLp06fTu3fvegcs4jVS/woFOdCqBwy+2+xoPJJm05yH1QpXzQKrH2xdDFv+V6fbXNO7DXGRIRxV64h4KKeTkVmzZjFhwgQmTpxIfHw8s2fPJiYmhrlzq+/T7NChAy+++CLjxo0jPDy83gGLeIU9K2DdAmP/qtlg8zc1HPFireJh8D3G/udToTDf6Vv42azcc5laR8RzOZWMFBUVkZaWRnJycqXjycnJrFy50mVBFRYWkpeXV2kT8RolRfC/+4z9xPEatFoLFk2nObdhD0JELOTtr3Nl1qt7taFjWevIWyv3uDY+kXpyKhnJzs6mtLSUqKioSsejoqI4ePCgy4KaOXMm4eHhFVtMTIzL7i3idsufg+ytxkyI8gGIUi1109RSQDBcOcvYXz0H9q11+hZ+Nit3l7WOvLp0J0dP1G26sIg71GkA69mfYhwOh0s/2UybNo3c3NyKLSMjw2X3FnGrA+th2XPG/uhnoEkzU8MRH9JlhDE93GGHj/8MxaecvsU1vdvSvXUo+adKePm7HW4IUqRunEpGIiMjsdlsVVpBsrKyqrSW1EdgYCBhYWGVNhGPV1IIH082ynj3uA4SfmN2RF5DnTS1NPoZaBoF2dtgyZNOX26zWnjkinjAqDuSnlPg6ghF6sSpZCQgIIDExERSU1MrHU9NTWXw4MEuDUzE6yx9BrI2QXAkXPm82dF4BfXSOCm4uTEgGmDlS5Dxg9O3GNa1JUO7RFJc6uCZL+u+EJ+IKzndTZOSksIbb7zBvHnz2LJlC/fddx/p6elMmjQJMLpYxo0bV+ma9evXs379eo4fP87hw4dZv349mzdvds13IOIJ9qfB9y8Y+1fNgpBIc+MR39X9Cuj1u9PdNUXOt25MGx2PxQL/25jJuvSjbghSxDl+zl4wZswYcnJymDFjBpmZmSQkJLB48WJiY2MBo8jZ2TVH+vbtW7GflpbGv/71L2JjY9mzZ0/9ohfxBIX5sGii0T2T8Fvoca3ZEXkdTaZx0uinYPdSo1T8l4/A1bOdurxHmzB+268d/07bx6OfbOI/k4dgs+ovQcxTpwGskydPZs+ePRQWFpKWlsawYcMqvjZ//nyWLFlS6XyHw1FlUyIiPuOzB+DILghrp+4ZJzk0naZumjSD618FLJD2T9j8X6dvMfXyboQG+rFxXy7v/VC3UvMirqK1aUTqY8P7sPF9sFjht29o9ow0nI7D4aIpxv4ndzu9dk2r0CDuT+4KwLNfbiXneKFr4xNxgpIRkbrK2Qmf3W/sX/wwxA4yNx4vpg6COrpkOrRNglO5sOh2KHWusuqtA2PpER1G7slinvpcg1nFPEpGROqiqAA++AMUHYfYITDsAbMj8krqpKknmz/c8CYEhhmrQ3/zmFOX+9msPHF9AgAfpu1j5Y5sNwQpcn5KRkSc5XDAp/fAoZ+NKqu/+QdYbWZHJY1Vsw5wzUvG/sqX4JdFTl3er30zbh3YHoCpizZq3RoxhZIREWetngs/fwgWG9w4H8Lbmh2R19PaNPXU8zoYcq+x/9+74NAmpy5/eHQ87Zo1Yd/Rk8xcvMX18Ymch5IREWfsXg5f/cXYH/UkdLjI3Hi8nfppXOeyR6HjJVBcAO/fAidrXz+kaaAfz9zQC4B316SzfPthd0UpUi0lIyK1lb0DPhhr1BPpNQYG3GF2RCKnWW1wwzyIaA9Hd8PCscYK0rU0uFMk4wYZ9aIe/HAjR7SQnjQgJSMitXH8MLz7W+PTZttEoyS3uhZcRj9JFwluDr/7FwQ0hT3LjSm/TtRyeejy7nSMDOFg3inu/2A9druarqRhKBkROZ+iAnjvd3B0D0TEwu8XGku6S7051E/jeq0vgJveMsY0bXwfvqv9gnohgX68fHM/AvysfLf1MP9YvsuNgYqcpmRE5FxKS4xS7/vXGgXNbl0ETVuaHZXIuXUeAVeVrZW07BlIm1/rS3u0CePRq3sA8MyXW0nbe8QNAYpUpmREpCb2Uvh4Emz9DGwBRvN3ZBezo/JJ6vFyg8Q/wLAHjf1Pp8DGD2p96c0Xtufq3m0otTu4452fOHDspHtiFCmjZESkOna7UUvk5w/B6gc3vQ2xg82OyudoaRo3u2Q6JE0AHPCfSbVew8ZisTDzNxfQvXUo2ccLmfjWWgqKVH9E3EfJiMjZHA74/EFYt+D0mjPdRpsdlYjzLBa44jnoc6sxC+zff4Stn9fq0qaBfrzxhyRahASwOTOPlIUbNKBV3EbJiMiZSkuMolE/vgFY4LpXoef1ZkfVCKifxm2sVrjm75BwA9hLYOGt8PO/a3Vpu2bBvDY2kQCblS82HWTG/zZrpWVxCyUjIuVKCuHf42F9WYvIdXOg9xizo/JpeltrIFYbXP/q6YRk0UT48c1aXZrUoTnP3tgLiwXmr9zDC19vd3Ow0hgpGREBOJUH/7oJtnxqDFa96R3oc7PZUYm4js3fWEepfAzJZymw7NlaDdy5tk9bZlzTE4C/f7OdNzTlV1xMyYjIkd3wZjLsWgL+IXDLhxB/ldlRNQrl74OaTdNArFa48nkYer/x+tsn4OPJRqvgeYwd1IEHkrsC8MRnW5i7ZKc7I5VGRsmING57V8Ibl8HhLdC0NYz/H3QcbnZUIu5jscBlf4PRzxrdkRv+BW9dY1QZPo87L+nM3Zd2BuDpL37luS+3agyJuISSEWmcHA5Y87rxS7ggB6L7wJ++g7b9zI6sUVLDiAkG/Alu+TcEhkPGavjHJZDx4zkvsVgs3J/cjYcu7w7Ay9/t4K///YWSUntDRCw+TMmIND4njxozCj5/EOzF0OM6uO1zCGtjdmSNjsrBm6zzZTDxa2jeEXIz4J+Xw4oXjTo75/Dn4Z2YcW1PLBZYsDqd2+b/SO7J4gYKWnyRkhFpXPasgFeHwq//MwaqXv403Dhfa81I49WyK/xpiTGF3V4CqX+Df90IeZnnvGzcoA68emsiTfxtLN+ezW/mrGBH1vGGiVl8jpIRaRwK8+Gz+2H+FcYnwGZxMOErGDhJoyc9gP4KTBYUDjf801iN2i8IdnwNrwyAn94552ybUT1b8+GkQbQOC2Ln4RNc/dL3/DttX8PFLT5DyYj4NocDtn4BcwaVFTID+o2DO5ZBm77mxiYqB+9JLBZIug1u/874v1GYC5/cBe9cDzk1z5xJaBvOJ3cPYXCnFpwsLuWBDzdw38L15Bao20ZqT8mI+K6sX2HBb+C9MUZrSEQsjPsvXPMSBIWZHZ2IZ4rqARO+hpEzjFaSXd8ZrSRf/QVO5VZ7SavQIN6ZMICUkV2xWuA/6/Yz4oWlfPHLwQYOXryVkhHxPbn74H8pMHcw7PzWGBsy5F6YvErTdj2URfNpPIvNz/g/M2kFdB5hDPRe+RL8vR+sfhWKT1W9xGrhnsu68MEdg+jYMoTD+YVMWpDG7W+vZXf2CRO+CfEmSkbEd+TuM8aF/L0vrH3TWBis+1Vw5xrjU15AiNkRylnUS+PhIjvDrYuMKcCRXaEgG754CF7sXZaUnKxySVKH5iy+ZyiTh3fCZrWQuvkQI2ctZcanmzlWUGTCNyHewOLwgoo1eXl5hIeHk5ubS1iYmtflDA4HZPwAP7xmLI9uL1vmvMNQGP4wdLjI3PjknN5ZvZe/fvwLl/dszatjE80OR86ltBjWvQPLnoe8skGqwS0gcbxRYj68bZVLth/K58nFW/huq1FQrWmgH7cOjGXCRXG0DA1swODFLLV9/1YyIt7p5FHY9DGkzYfM9aePdxgKFz8EcUNNCkycUZ6MjE5ozdxblYx4hZIiWP8uLJ8FuenGMYsN4q+GvrdCx0uMbp4zLN9+mP/32RZ+PZgPQICflRsT23HrwFjio/U73ZcpGRHfU1RgjAHZuBC2fQGlZU2+tkDodSNceAdE9zI3RnHKO6v28Nf/blIy4o1KS2Db57DmNdiz/PTxkFZwwQ3GCsFt+hrr4QB2u4Nvf83i5e92sD7jWMXpfdtH8PsL2zOqZ2vCm/g38Dch7qZkRHxD3gEj8dj6BexeCiVnDJxr1QN6jYG+YyGkhXkxSp0pGfERB3+Bn96GX/5tLK9QrmkUdEmGbqONweMBITgcDlbvOsI7q/fw1aZDlNiNtyB/m4VhXVpyxQXRjIiPIjxYiYkvUDIi3sfhgGPpkL4K9q4wqqUeOau+QXh76HEN9P4dtL7AnDjFZcqTkSsuaM2cW5SMeL3S4jNaL7+CovzTX7P6QZt+EDsYYodAzIVklQTx4dp9fLxuP9vPqN5qtcAF7SIY2jmSi7pE0icmgiB/mwnfkNSXW5OROXPm8Oyzz5KZmUnPnj2ZPXs2Q4fW3Ee/dOlSUlJS2LRpE23atGHq1KlMmjSp1s9TMuKDik/B0T2QtQkyN0DmRuPPk0fOOtEC7fpDt8uh6+VGa4jKdfqMt1ft4W9KRnxTSZHxoWLbF7D1czi2t+o5zeKMrtXo3uwL6sIXhyL4cFspW7MKKp3mZ7XQPTqUvjHN6BMTQffoUDq1bKoExQvU9v3br8av1GDhwoVMmTKFOXPmMGTIEF577TVGjx7N5s2bad++fZXzd+/ezRVXXMHtt9/OggULWLFiBZMnT6Zly5b89re/dfbx4i1KiuD4QWN9i/xMo7vlyC7I2WG0dhzLoNqJnVY/YwXd2MHGTJiYAdAkooGDF5F68wuATpcY2+in4ehe2LsS9n5vtHoe3X162/xf2gETgYl+QRS3i+OQX1u2FLVi7bEQdpwK4+CBFny2vznvrA4FLFgs0L55MF1ahdKxZQhtI5oYWzNjCwtSN483cbplZMCAAfTr14+5c+dWHIuPj+e6665j5syZVc5/6KGH+OSTT9iyZUvFsUmTJrFhwwZWrVpVq2eqZaSBORxG/YDik1BcUPXPouPGbJaTx+DUsdP7J48aLRt5mUY9gvMJDIPILhDd29ha9zJaPvyD3PwNiqcobxm58oJoXrmln9nhSEMqOAIHN55uGT24EY7sNgqsnUMx/mQRQbY9lGOOphylKcccTTlGU446Qsl1hHCSQBz+Ifg3aUpAcChBwWEENw0jJDSMsNAwwpoEEhLoR0igjaaBfsZ+gPE6JNCPAJsVq1UtsK7glpaRoqIi0tLSePjhhysdT05OZuXKldVes2rVKpKTkysdGzVqFG+++SbFxcX4+1fNXgsLCyksLKz0zbjDjx+/jP3AenA4zqj/aORmlopP7WWvHae/XuVr5a/L/jBen31O+UtHlXMsZ7UQWBynr63ytYpnVb32zLisjtKKzeYoKdsvwcqZr8uOVZxTgp+jiAB71eqKdVFi8SffP5J8/5bkB0RyNLAtOYEx5ATFkBMYQ4FfM6PLxQEcKNuoeQ0M8T1bMt3zf1u8QHBzY1DrmVWRS0uM6cI5OyF7u9GKmnfg9HYiC3+Kacth2loPn/8Zp8q2s3p/ix02ivGjGBtF+Bn7Dj+O4kcWfhThRwl+lFr8jN9RFisOiw0sVrBYsZT9icWC3WIDLDgsVhzlx894bbEYs4ksFuN9wGKxcGbNYYflzPrDZyRAFuMdoPyoo5qvn/6a5azLK9+x0n0slesdn/nuF3nReDr3Nqc2k1PJSHZ2NqWlpURFRVU6HhUVxcGD1a9BcPDgwWrPLykpITs7m+jo6CrXzJw5k8cff9yZ0OrEuvMb+ud/6/bneLNChx+nCOAkgZx0BHCSIE4QSK4jhFyakusI4ZijKbmEcMwRwjFCOeRoxiFHBEcJhZM1fbrIK9tEjGJYItj8oHlHY+sysurXz+z+LW+JLThSef9ULqWFJyg5lY+jqABL0QmsJQX4l54eh+JvKcWf0sr3PldDyJmfL33Y2n0DwBuSkXKWswYQOhyOKsfOd351x8tNmzaNlJSUitd5eXnExMTUJdRz634lqw7EGjFVHLRUDJA8nTFaKp9T49ctFf+gz/5abe5xdnZb7f3PPKHSeZXPsVtsZZtfDX9W/7USaxDF1kCKbUGUWANxWGr3T6Rp2dYOSKjVFSKGAJuNG5PamR2GeAO/AIhob2znYCvbKqnofi4wahSVFhmzf87YLy0upLDwFCVFhZSUFFJaXERpaSklpaWUlJRSWlq+lVBaasfhKAWHHYe9FOx2HA5jw24HR6lxHLA7HEZjtsNh7J8RU/n+ma3cDsfp1+X7lXKhSqMrzsqSaviao+wZlQdmVL42Kta8Ok1OJSORkZHYbLYqrSBZWVlVWj/KtW7dutrz/fz8aNGi+toQgYGBBAa6v1Rw4pUT3f4MERHxABYLBAQbWw1sQM1fFXdyaqG8gIAAEhMTSU1NrXQ8NTWVwYMHV3vNoEGDqpz/1VdfkZSUVO14EREREWlcnF61NyUlhTfeeIN58+axZcsW7rvvPtLT0yvqhkybNo1x48ZVnD9p0iT27t1LSkoKW7ZsYd68ebz55ps88MADrvsuRERExGs5PWZkzJgx5OTkMGPGDDIzM0lISGDx4sXExhpjLzIzM0lPT684Py4ujsWLF3Pffffxyiuv0KZNG/7+97+rxoiIiIgAKgcvIiIiblLb92+nu2lEREREXEnJiIiIiJhKyYiIiIiYSsmIiIiImErJiIiIiJhKyYiIiIiYSsmIiIiImErJiIiIiJhKyYiIiIiYyuly8GYoLxKbl5dnciQiIiJSW+Xv2+cr9u4VyUh+fj4AMTExJkciIiIizsrPzyc8PLzGr3vF2jR2u50DBw4QGhqKxWIxOxxT5eXlERMTQ0ZGhtbpcTP9rBuGfs4NQz/nhqGfc2UOh4P8/HzatGmD1VrzyBCvaBmxWq20a9fO7DA8SlhYmP6hNxD9rBuGfs4NQz/nhqGf82nnahEppwGsIiIiYiolIyIiImIqJSNeJjAwkEcffZTAwECzQ/F5+lk3DP2cG4Z+zg1DP+e68YoBrCIiIuK71DIiIiIiplIyIiIiIqZSMiIiIiKmUjIiIiIiplIy4iMKCwvp06cPFouF9evXmx2OT9mzZw8TJkwgLi6OJk2a0KlTJx599FGKiorMDs3rzZkzh7i4OIKCgkhMTGT58uVmh+RzZs6cSf/+/QkNDaVVq1Zcd911bN261eywfNrMmTOxWCxMmTLF7FC8hpIRHzF16lTatGljdhg+6ddff8Vut/Paa6+xadMmXnjhBV599VUeeeQRs0PzagsXLmTKlClMnz6ddevWMXToUEaPHk16errZofmUpUuXcuedd7J69WpSU1MpKSkhOTmZEydOmB2aT/rxxx95/fXX6dWrl9mheBVN7fUBn3/+OSkpKSxatIiePXuybt06+vTpY3ZYPu3ZZ59l7ty57Nq1y+xQvNaAAQPo168fc+fOrTgWHx/Pddddx8yZM02MzLcdPnyYVq1asXTpUoYNG2Z2OD7l+PHj9OvXjzlz5vDEE0/Qp08fZs+ebXZYXkEtI17u0KFD3H777bzzzjsEBwebHU6jkZubS/Pmzc0Ow2sVFRWRlpZGcnJypePJycmsXLnSpKgah9zcXAD9+3WDO++8kyuvvJIRI0aYHYrX8YqF8qR6DoeD8ePHM2nSJJKSktizZ4/ZITUKO3fu5KWXXuL55583OxSvlZ2dTWlpKVFRUZWOR0VFcfDgQZOi8n0Oh4OUlBQuuugiEhISzA7Hp7z//vv89NNP/Pjjj2aH4pXUMuKBHnvsMSwWyzm3tWvX8tJLL5GXl8e0adPMDtkr1fbnfKYDBw5w+eWXc+ONNzJx4kSTIvcdFoul0muHw1HlmLjOXXfdxcaNG3nvvffMDsWnZGRkcO+997JgwQKCgoLMDscracyIB8rOziY7O/uc53To0IHf/e53fPrpp5V+eZeWlmKz2bjlllt466233B2qV6vtz7n8l8uBAwe45JJLGDBgAPPnz8dqVS5fV0VFRQQHB/Phhx9y/fXXVxy/9957Wb9+PUuXLjUxOt9099138/HHH7Ns2TLi4uLMDsenfPzxx1x//fXYbLaKY6WlpVgsFqxWK4WFhZW+JlUpGfFi6enp5OXlVbw+cOAAo0aN4t///jcDBgygXbt2JkbnW/bv388ll1xCYmIiCxYs0C8WFxgwYACJiYnMmTOn4liPHj249tprNYDVhRwOB3fffTf/+c9/WLJkCV26dDE7JJ+Tn5/P3r17Kx277bbb6N69Ow899JC6xGpBY0a8WPv27Su9btq0KQCdOnVSIuJCBw4cYPjw4bRv357nnnuOw4cPV3ytdevWJkbm3VJSUhg7dixJSUkMGjSI119/nfT0dCZNmmR2aD7lzjvv5F//+hf//e9/CQ0NrRiTEx4eTpMmTUyOzjeEhoZWSThCQkJo0aKFEpFaUjIich5fffUVO3bsYMeOHVWSPDUs1t2YMWPIyclhxowZZGZmkpCQwOLFi4mNjTU7NJ9SPnV6+PDhlY7/85//ZPz48Q0fkEg11E0jIiIiptIIPBERETGVkhERERExlZIRERERMZWSERERETGVkhERERExlZIRERERMZWSERERETGVkhERERExlZIRERERMZWSERERETGVkhERERExlZIRERERMdX/B628pI8KAf8TAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mean = 0\n", + "std = 1\n", + "low = 0\n", + "high = jnp.inf\n", + "dist = tfp.distributions.TruncatedNormal(mean, std, low, high)\n", + "\n", + "x = jnp.linspace(-5, 5, 1000)\n", + "trunc_pdfs = jax.vmap(\n", + " lambda x: dist.prob(\n", + " x,\n", + " )\n", + ")(x)\n", + "normal_pdfs = jax.vmap(\n", + " lambda x: jax.scipy.stats.norm.pdf(x, loc=mean, scale=std)\n", + ")(x)\n", + "plt.plot(x, trunc_pdfs, label=\"truncnorm\")\n", + "plt.plot(x, normal_pdfs, label=\"normal\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import jax.numpy as jnp\n", + "import jax" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bounds = jnp.array([0.5, 0.5, 0.5, 0.5])\n", + "observed_rgbd = jnp.zeros((480, 640, 4))\n", + "rendered_rgbd = jnp.zeros((480, 640, 4))\n", + "variances = jnp.array([0.2, 0.2, 0.2, 0.2])\n", + "\n", + "x = jnp.linspace(-0.5, 0.5, 1000)\n", + "trunc_pdfs = jax.vmap(\n", + " lambda x: jax.scipy.stats.truncnorm.pdf(\n", + " x, -bounds[0], bounds[0], loc=0, scale=variances[0]\n", + " )\n", + ")(x)\n", + "normal_pdfs = jax.vmap(\n", + " lambda x: jax.scipy.stats.norm.pdf(x, loc=0, scale=variances[0])\n", + ")(x)\n", + "plt.plot(x, trunc_pdfs, label=\"truncnorm\")\n", + "plt.plot(x, normal_pdfs, label=\"normal\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.stats import vonmises, norm\n", + "\n", + "# Parameters for von Mises distribution\n", + "mu = np.pi / 4 # mean direction (in radians), non-zero\n", + "kappa = 10 # concentration parameter (higher kappa = more concentrated)\n", + "\n", + "# Compute equivalent Gaussian parameters\n", + "sigma = 1 / np.sqrt(kappa) # Approximate standard deviation for Gaussian\n", + "mu_gaussian = mu # Same mean as von Mises\n", + "\n", + "# Define x range for plotting\n", + "x = np.linspace(-np.pi, np.pi, 500)\n", + "\n", + "# Evaluate von Mises and Gaussian distributions\n", + "vonmises_pdf = vonmises.pdf(x, kappa, loc=mu)\n", + "gaussian_pdf = norm.pdf(x, loc=mu_gaussian, scale=sigma)\n", + "\n", + "# Plot the distributions\n", + "plt.figure(figsize=(8, 5))\n", + "plt.plot(x, vonmises_pdf, label=\"Von Mises PDF\", linewidth=2)\n", + "plt.plot(x, gaussian_pdf, label=\"Gaussian Approximation\", linestyle=\"--\", linewidth=2)\n", + "plt.axvline(mu, color='r', linestyle=':', label=\"Mean (mu)\")\n", + "plt.xlabel(\"Angle (radians)\")\n", + "plt.ylabel(\"Density\")\n", + "plt.title(\"Von Mises Distribution vs Gaussian Approximation (mu ≠ 0)\")\n", + "plt.legend()\n", + "plt.grid()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.stats import vonmises_fisher\n", + "from matplotlib.colors import Normalize\n", + "n_grid = 100\n", + "u = np.linspace(0, np.pi, n_grid)\n", + "v = np.linspace(0, 2 * np.pi, n_grid)\n", + "u_grid, v_grid = np.meshgrid(u, v)\n", + "vertices = np.stack([np.cos(v_grid) * np.sin(u_grid),\n", + " np.sin(v_grid) * np.sin(u_grid),\n", + " np.cos(u_grid)],\n", + " axis=2)\n", + "x = np.outer(np.cos(v), np.sin(u))\n", + "y = np.outer(np.sin(v), np.sin(u))\n", + "z = np.outer(np.ones_like(u), np.cos(u))\n", + "def plot_vmf_density(ax, x, y, z, vertices, mu, kappa):\n", + " vmf = vonmises_fisher(mu, kappa)\n", + " pdf_values = vmf.pdf(vertices)\n", + " pdfnorm = Normalize(vmin=pdf_values.min(), vmax=pdf_values.max())\n", + " ax.plot_surface(x, y, z, rstride=1, cstride=1,\n", + " facecolors=plt.cm.viridis(pdfnorm(pdf_values)),\n", + " linewidth=0)\n", + " ax.set_aspect('equal')\n", + " ax.view_init(azim=-130, elev=0)\n", + " ax.axis('off')\n", + " ax.set_title(rf\"$\\kappa={kappa}$\")\n", + "fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(9, 4),\n", + " subplot_kw={\"projection\": \"3d\"})\n", + "left, middle, right = axes\n", + "mu = np.array([-np.sqrt(0.5), -np.sqrt(0.5), 0])\n", + "plot_vmf_density(left, x, y, z, vertices, mu, 5)\n", + "plot_vmf_density(middle, x, y, z, vertices, mu, 20)\n", + "plot_vmf_density(right, x, y, z, vertices, mu, 100)\n", + "plt.subplots_adjust(top=1, bottom=0.0, left=0.0, right=1.0, wspace=0.)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.stats import vonmises_fisher\n", + "from scipy.stats import multivariate_normal\n", + "\n", + "# Parameters for von Mises-Fisher distribution\n", + "mu = np.array([0, 0, 1]) # Mean direction (unit vector)\n", + "kappa = 1000 # Concentration parameter\n", + "num_samples = 1000 # Number of samples\n", + "\n", + "# Approximate vMF using Multivariate Gaussian\n", + "def approximate_vmf_with_gaussian(mu, kappa, num_samples):\n", + " # Generate samples\n", + " samples = np.random.multivariate_normal(mu, np.eye(len(mu)) / kappa, size=num_samples)\n", + " # Normalize samples to project them back onto the unit sphere\n", + " samples_normalized = samples / np.linalg.norm(samples, axis=1, keepdims=True)\n", + " return samples_normalized\n", + "\n", + "# Generate samples from the Gaussian approximation\n", + "gaussian_samples = approximate_vmf_with_gaussian(mu, kappa, num_samples)\n", + "\n", + "# Generate samples from true von Mises-Fisher distribution for comparison\n", + "def von_mises_fisher_sampling(mu, kappa, num_samples):\n", + " samples = vonmises_fisher(mu, kappa).rvs(num_samples)\n", + " return samples\n", + "\n", + "vmf_samples = von_mises_fisher_sampling(mu, kappa, num_samples)\n", + "\n", + "# Plot the samples\n", + "fig = plt.figure(figsize=(12, 6))\n", + "\n", + "# Plot Gaussian Approximation\n", + "ax1 = fig.add_subplot(121, projection='3d')\n", + "u = np.linspace(0, 2 * np.pi, 100)\n", + "v = np.linspace(0, np.pi, 100)\n", + "x = np.outer(np.cos(u), np.sin(v))\n", + "y = np.outer(np.sin(u), np.sin(v))\n", + "z = np.outer(np.ones(np.size(u)), np.cos(v))\n", + "ax1.plot_surface(x, y, z, rstride=4, cstride=4, color='lightblue', alpha=0.2)\n", + "ax1.scatter(gaussian_samples[:, 0], gaussian_samples[:, 1], gaussian_samples[:, 2], color='red', s=10)\n", + "ax1.set_title(\"Gaussian Approximation to vMF\")\n", + "ax1.set_xlabel(\"X\")\n", + "ax1.set_ylabel(\"Y\")\n", + "ax1.set_zlabel(\"Z\")\n", + "\n", + "# Plot True vMF Distribution\n", + "ax2 = fig.add_subplot(122, projection='3d')\n", + "ax2.plot_surface(x, y, z, rstride=4, cstride=4, color='lightblue', alpha=0.2)\n", + "ax2.scatter(vmf_samples[:, 0], vmf_samples[:, 1], vmf_samples[:, 2], color='blue', s=10)\n", + "ax2.set_title(\"True vMF Distribution\")\n", + "ax2.set_xlabel(\"X\")\n", + "ax2.set_ylabel(\"Y\")\n", + "ax2.set_zlabel(\"Z\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sample: [ 0.85279007 -0.09873086 -0.51283654], PDF Estimate: 4.64507351618476e-08\n", + "Sample: [ 0.07578151 0.44244186 -0.89358959], PDF Estimate: 1.0313428811986419e-09\n", + "Sample: [-0.17264695 -0.76729735 0.61761461], PDF Estimate: 0.003771200030080044\n", + "Sample: [-0.65623626 0.72541136 0.20768322], PDF Estimate: 6.25417647935347e-05\n", + "Sample: [-0.98238007 0.03132889 0.18424958], PDF Estimate: 4.9476518523081384e-05\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from scipy.stats import multivariate_normal\n", + "\n", + "# Parameters for von Mises-Fisher distribution\n", + "mu = np.array([0, 0, 1]) # Mean direction (unit vector)\n", + "kappa = 10 # Concentration parameter\n", + "\n", + "# Covariance matrix for Gaussian approximation\n", + "dim = len(mu)\n", + "sigma = (1 / kappa) * np.eye(dim)\n", + "\n", + "# Gaussian PDF function for a sample\n", + "def gaussian_approximation_pdf(sample, mu, sigma):\n", + " # Evaluate the multivariate normal PDF at the sample point\n", + " pdf_value = multivariate_normal.pdf(sample, mean=mu, cov=sigma)\n", + " return pdf_value\n", + "\n", + "# Normalize the Gaussian PDF for the unit sphere\n", + "def normalize_gaussian_pdf(samples, mu, sigma):\n", + " # Compute Gaussian PDF for all samples\n", + " pdf_values = np.array([gaussian_approximation_pdf(sample, mu, sigma) for sample in samples])\n", + " # Normalize so it sums/integrates to 1\n", + " pdf_values /= pdf_values.sum()\n", + " return pdf_values\n", + "\n", + "# Example samples (generate random points on the unit sphere)\n", + "num_samples = 100\n", + "samples = np.random.randn(num_samples, 3)\n", + "samples = samples / np.linalg.norm(samples, axis=1, keepdims=True) # Normalize to unit sphere\n", + "\n", + "# Estimate PDF using Gaussian approximation\n", + "pdf_values = normalize_gaussian_pdf(samples, mu, sigma)\n", + "\n", + "# Print results for a few points\n", + "for i in range(5): # Display for first 5 points\n", + " print(f\"Sample: {samples[i]}, PDF Estimate: {pdf_values[i]}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.stats import vonmises\n", + "\n", + "# Define distribution parameters\n", + "mu = 0 # Mean direction\n", + "kappa = 2 # Concentration parameter\n", + "\n", + "# Create an array of x values\n", + "x = np.linspace(-np.pi, np.pi, 1000)\n", + "\n", + "# Calculate the PDF\n", + "pdf = vonmises.pdf(x, kappa, loc=mu)\n", + "\n", + "# Plot the PDF\n", + "plt.plot(x, pdf)\n", + "plt.title(\"Von Mises Distribution PDF\")\n", + "plt.xlabel(\"Angle (radians)\")\n", + "plt.ylabel(\"Probability Density\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.stats import norm\n", + "\n", + "# Generate x values\n", + "x = np.linspace(-5, 5, 100)\n", + "\n", + "# Calculate PDF values\n", + "mean = 0\n", + "std_dev = 1\n", + "pdf_values = norm.pdf(x, mean, std_dev)\n", + "\n", + "# Plot the PDF\n", + "plt.plot(x, pdf_values)\n", + "plt.title('PDF of Normal Distribution')\n", + "plt.xlabel('x')\n", + "plt.ylabel('Probability Density')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "from tensorflow_probability.substrates import jax as tfp\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array(5.93e-43, dtype=float32)" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tfd = tfp.distributions\n", + "\n", + "# Initialize a single 3-dimension vMF distribution.\n", + "mu = [0., 1, 0]\n", + "conc = 100.\n", + "vmf = tfd.VonMisesFisher(mean_direction=mu, concentration=conc)\n", + "\n", + "# Evaluate this on an observation in S^2 (in R^3), returning a scalar.\n", + "vmf.prob([1., 0, 0])" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.1415927\n", + "-3.1353033\n", + "-3.1290138\n", + "-3.1227243\n", + "-3.1164348\n", + "-3.1101453\n", + "-3.1038558\n", + "-3.0975664\n", + "-3.091277\n", + "-3.0849874\n", + "-3.078698\n", + "-3.0724084\n", + "-3.066119\n", + "-3.0598295\n", + "-3.05354\n", + "-3.0472505\n", + "-3.040961\n", + "-3.0346715\n", + "-3.028382\n", + "-3.0220926\n", + "-3.015803\n", + "-3.0095136\n", + "-3.0032241\n", + "-2.9969347\n", + "-2.9906452\n", + "-2.9843557\n", + "-2.9780662\n", + "-2.9717767\n", + "-2.9654872\n", + "-2.959198\n", + "-2.9529085\n", + "-2.946619\n", + "-2.9403296\n", + "-2.93404\n", + "-2.9277506\n", + "-2.921461\n", + "-2.9151716\n", + "-2.9088821\n", + "-2.9025927\n", + "-2.8963032\n", + "-2.8900137\n", + "-2.8837242\n", + "-2.8774347\n", + "-2.8711452\n", + "-2.8648558\n", + "-2.8585663\n", + "-2.8522768\n", + "-2.8459873\n", + "-2.8396978\n", + "-2.8334084\n", + "-2.8271189\n", + "-2.8208294\n", + "-2.81454\n", + "-2.8082504\n", + "-2.801961\n", + "-2.7956715\n", + "-2.789382\n", + "-2.7830925\n", + "-2.776803\n", + "-2.7705135\n", + "-2.764224\n", + "-2.7579348\n", + "-2.7516453\n", + "-2.7453558\n", + "-2.7390664\n", + "-2.7327769\n", + "-2.7264874\n", + "-2.720198\n", + "-2.7139084\n", + "-2.707619\n", + "-2.7013295\n", + "-2.69504\n", + "-2.6887505\n", + "-2.682461\n", + "-2.6761715\n", + "-2.669882\n", + "-2.6635926\n", + "-2.657303\n", + "-2.6510136\n", + "-2.6447241\n", + "-2.6384346\n", + "-2.6321452\n", + "-2.6258557\n", + "-2.6195662\n", + "-2.6132767\n", + "-2.6069872\n", + "-2.6006978\n", + "-2.5944083\n", + "-2.5881188\n", + "-2.5818293\n", + "-2.5755398\n", + "-2.5692503\n", + "-2.5629609\n", + "-2.5566714\n", + "-2.5503821\n", + "-2.5440927\n", + "-2.5378032\n", + "-2.5315137\n", + "-2.5252242\n", + "-2.5189347\n", + "-2.5126452\n", + "-2.5063558\n", + "-2.5000663\n", + "-2.4937768\n", + "-2.4874873\n", + "-2.4811978\n", + "-2.4749084\n", + "-2.4686189\n", + "-2.4623294\n", + "-2.45604\n", + "-2.4497504\n", + "-2.443461\n", + "-2.4371715\n", + "-2.430882\n", + "-2.4245925\n", + "-2.418303\n", + "-2.4120135\n", + "-2.405724\n", + "-2.3994346\n", + "-2.393145\n", + "-2.3868556\n", + "-2.3805661\n", + "-2.3742766\n", + "-2.3679872\n", + "-2.3616977\n", + "-2.3554082\n", + "-2.349119\n", + "-2.3428295\n", + "-2.33654\n", + "-2.3302505\n", + "-2.323961\n", + "-2.3176715\n", + "-2.311382\n", + "-2.3050926\n", + "-2.298803\n", + "-2.2925136\n", + "-2.2862241\n", + "-2.2799346\n", + "-2.2736452\n", + "-2.2673557\n", + "-2.2610662\n", + "-2.2547767\n", + "-2.2484872\n", + "-2.2421978\n", + "-2.2359083\n", + "-2.2296188\n", + "-2.2233293\n", + "-2.2170398\n", + "-2.2107503\n", + "-2.2044609\n", + "-2.1981714\n", + "-2.191882\n", + "-2.1855924\n", + "-2.179303\n", + "-2.1730134\n", + "-2.166724\n", + "-2.1604345\n", + "-2.154145\n", + "-2.1478555\n", + "-2.1415663\n", + "-2.1352768\n", + "-2.1289873\n", + "-2.1226978\n", + "-2.1164083\n", + "-2.1101189\n", + "-2.1038294\n", + "-2.09754\n", + "-2.0912504\n", + "-2.084961\n", + "-2.0786715\n", + "-2.072382\n", + "-2.0660925\n", + "-2.059803\n", + "-2.0535135\n", + "-2.047224\n", + "-2.0409346\n", + "-2.034645\n", + "-2.0283556\n", + "-2.022066\n", + "-2.0157766\n", + "-2.0094872\n", + "-2.0031977\n", + "-1.9969082\n", + "-1.9906188\n", + "-1.9843293\n", + "-1.9780399\n", + "-1.9717504\n", + "-1.9654609\n", + "-1.9591714\n", + "-1.9528819\n", + "-1.9465925\n", + "-1.940303\n", + "-1.9340135\n", + "-1.927724\n", + "-1.9214345\n", + "-1.915145\n", + "-1.9088556\n", + "-1.9025661\n", + "-1.8962766\n", + "-1.8899872\n", + "-1.8836977\n", + "-1.8774083\n", + "-1.8711188\n", + "-1.8648293\n", + "-1.8585398\n", + "-1.8522503\n", + "-1.8459609\n", + "-1.8396714\n", + "-1.8333819\n", + "-1.8270924\n", + "-1.8208029\n", + "-1.8145134\n", + "-1.808224\n", + "-1.8019345\n", + "-1.795645\n", + "-1.7893555\n", + "-1.7830662\n", + "-1.7767767\n", + "-1.7704872\n", + "-1.7641977\n", + "-1.7579082\n", + "-1.7516187\n", + "-1.7453293\n", + "-1.7390398\n", + "-1.7327503\n", + "-1.7264608\n", + "-1.7201713\n", + "-1.7138819\n", + "-1.7075924\n", + "-1.7013029\n", + "-1.6950134\n", + "-1.6887239\n", + "-1.6824346\n", + "-1.6761451\n", + "-1.6698556\n", + "-1.6635661\n", + "-1.6572766\n", + "-1.6509871\n", + "-1.6446977\n", + "-1.6384082\n", + "-1.6321187\n", + "-1.6258292\n", + "-1.6195397\n", + "-1.6132503\n", + "-1.6069608\n", + "-1.6006713\n", + "-1.5943818\n", + "-1.5880923\n", + "-1.581803\n", + "-1.5755135\n", + "-1.569224\n", + "-1.5629345\n", + "-1.556645\n", + "-1.5503556\n", + "-1.5440661\n", + "-1.5377766\n", + "-1.5314871\n", + "-1.5251976\n", + "-1.5189081\n", + "-1.5126187\n", + "-1.5063292\n", + "-1.5000397\n", + "-1.4937502\n", + "-1.4874607\n", + "-1.4811714\n", + "-1.4748819\n", + "-1.4685924\n", + "-1.4623029\n", + "-1.4560134\n", + "-1.449724\n", + "-1.4434345\n", + "-1.437145\n", + "-1.4308555\n", + "-1.424566\n", + "-1.4182765\n", + "-1.4119871\n", + "-1.4056976\n", + "-1.3994081\n", + "-1.3931186\n", + "-1.3868291\n", + "-1.3805397\n", + "-1.3742503\n", + "-1.3679608\n", + "-1.3616713\n", + "-1.3553818\n", + "-1.3490924\n", + "-1.3428029\n", + "-1.3365134\n", + "-1.3302239\n", + "-1.3239344\n", + "-1.317645\n", + "-1.3113555\n", + "-1.305066\n", + "-1.2987765\n", + "-1.292487\n", + "-1.2861975\n", + "-1.2799081\n", + "-1.2736187\n", + "-1.2673292\n", + "-1.2610397\n", + "-1.2547503\n", + "-1.2484608\n", + "-1.2421713\n", + "-1.2358818\n", + "-1.2295923\n", + "-1.2233028\n", + "-1.2170134\n", + "-1.2107239\n", + "-1.2044344\n", + "-1.1981449\n", + "-1.1918554\n", + "-1.185566\n", + "-1.1792765\n", + "-1.1729871\n", + "-1.1666976\n", + "-1.1604081\n", + "-1.1541187\n", + "-1.1478292\n", + "-1.1415397\n", + "-1.1352502\n", + "-1.1289607\n", + "-1.1226712\n", + "-1.1163818\n", + "-1.1100923\n", + "-1.1038028\n", + "-1.0975133\n", + "-1.0912238\n", + "-1.0849344\n", + "-1.0786449\n", + "-1.0723555\n", + "-1.066066\n", + "-1.0597765\n", + "-1.0534871\n", + "-1.0471976\n", + "-1.0409081\n", + "-1.0346186\n", + "-1.0283291\n", + "-1.0220397\n", + "-1.0157502\n", + "-1.0094607\n", + "-1.0031712\n", + "-0.9968817\n", + "-0.9905923\n", + "-0.9843028\n", + "-0.97801334\n", + "-0.97172385\n", + "-0.9654344\n", + "-0.9591449\n", + "-0.9528554\n", + "-0.9465659\n", + "-0.9402765\n", + "-0.933987\n", + "-0.92769754\n", + "-0.92140806\n", + "-0.9151186\n", + "-0.9088291\n", + "-0.9025396\n", + "-0.8962501\n", + "-0.8899607\n", + "-0.8836712\n", + "-0.87738174\n", + "-0.87109226\n", + "-0.8648028\n", + "-0.8585133\n", + "-0.8522238\n", + "-0.84593433\n", + "-0.8396449\n", + "-0.8333554\n", + "-0.82706594\n", + "-0.82077646\n", + "-0.814487\n", + "-0.8081975\n", + "-0.801908\n", + "-0.79561853\n", + "-0.7893291\n", + "-0.7830396\n", + "-0.77675015\n", + "-0.77046067\n", + "-0.7641712\n", + "-0.7578817\n", + "-0.7515922\n", + "-0.74530274\n", + "-0.7390133\n", + "-0.73272383\n", + "-0.72643435\n", + "-0.72014487\n", + "-0.7138554\n", + "-0.7075659\n", + "-0.7012764\n", + "-0.69498694\n", + "-0.6886975\n", + "-0.68240803\n", + "-0.67611855\n", + "-0.6698291\n", + "-0.6635396\n", + "-0.6572501\n", + "-0.6509606\n", + "-0.64467114\n", + "-0.6383817\n", + "-0.63209224\n", + "-0.62580276\n", + "-0.6195133\n", + "-0.6132238\n", + "-0.6069343\n", + "-0.6006448\n", + "-0.59435534\n", + "-0.58806586\n", + "-0.58177644\n", + "-0.57548696\n", + "-0.5691975\n", + "-0.562908\n", + "-0.5566185\n", + "-0.550329\n", + "-0.54403955\n", + "-0.53775007\n", + "-0.53146064\n", + "-0.52517116\n", + "-0.5188817\n", + "-0.5125922\n", + "-0.5063027\n", + "-0.50001323\n", + "-0.49372378\n", + "-0.4874343\n", + "-0.48114482\n", + "-0.47485533\n", + "-0.46856588\n", + "-0.4622764\n", + "-0.45598692\n", + "-0.44969743\n", + "-0.44340798\n", + "-0.4371185\n", + "-0.43082902\n", + "-0.42453954\n", + "-0.41825008\n", + "-0.4119606\n", + "-0.40567112\n", + "-0.39938164\n", + "-0.3930922\n", + "-0.3868027\n", + "-0.38051322\n", + "-0.37422374\n", + "-0.3679343\n", + "-0.3616448\n", + "-0.35535532\n", + "-0.34906584\n", + "-0.3427764\n", + "-0.3364869\n", + "-0.33019742\n", + "-0.32390794\n", + "-0.3176185\n", + "-0.311329\n", + "-0.30503953\n", + "-0.29875004\n", + "-0.2924606\n", + "-0.2861711\n", + "-0.27988163\n", + "-0.27359214\n", + "-0.2673027\n", + "-0.2610132\n", + "-0.25472373\n", + "-0.24843426\n", + "-0.24214478\n", + "-0.23585531\n", + "-0.22956583\n", + "-0.22327636\n", + "-0.21698688\n", + "-0.21069741\n", + "-0.20440793\n", + "-0.19811845\n", + "-0.19182898\n", + "-0.1855395\n", + "-0.17925003\n", + "-0.17296055\n", + "-0.16667108\n", + "-0.1603816\n", + "-0.15409213\n", + "-0.14780265\n", + "-0.14151318\n", + "-0.1352237\n", + "-0.12893423\n", + "-0.12264476\n", + "-0.116355285\n", + "-0.11006581\n", + "-0.103776336\n", + "-0.09748686\n", + "-0.09119739\n", + "-0.08490791\n", + "-0.07861844\n", + "-0.07232896\n", + "-0.06603949\n", + "-0.05975001\n", + "-0.053460535\n", + "-0.04717106\n", + "-0.040881585\n", + "-0.03459211\n", + "-0.028302636\n", + "-0.022013161\n", + "-0.015723687\n", + "-0.009434212\n", + "-0.0031447373\n", + "0.0031447373\n", + "0.009434212\n", + "0.015723687\n", + "0.022013161\n", + "0.028302636\n", + "0.03459211\n", + "0.040881585\n", + "0.04717106\n", + "0.053460535\n", + "0.05975001\n", + "0.06603949\n", + "0.07232896\n", + "0.07861844\n", + "0.08490791\n", + "0.09119739\n", + "0.09748686\n", + "0.103776336\n", + "0.11006581\n", + "0.116355285\n", + "0.12264476\n", + "0.12893423\n", + "0.1352237\n", + "0.14151318\n", + "0.14780265\n", + "0.15409213\n", + "0.1603816\n", + "0.16667108\n", + "0.17296055\n", + "0.17925003\n", + "0.1855395\n", + "0.19182898\n", + "0.19811845\n", + "0.20440793\n", + "0.21069741\n", + "0.21698688\n", + "0.22327636\n", + "0.22956583\n", + "0.23585531\n", + "0.24214478\n", + "0.24843426\n", + "0.25472373\n", + "0.2610132\n", + "0.2673027\n", + "0.27359214\n", + "0.27988163\n", + "0.2861711\n", + "0.2924606\n", + "0.29875004\n", + "0.30503953\n", + "0.311329\n", + "0.3176185\n", + "0.32390794\n", + "0.33019742\n", + "0.3364869\n", + "0.3427764\n", + "0.34906584\n", + "0.35535532\n", + "0.3616448\n", + "0.3679343\n", + "0.37422374\n", + "0.38051322\n", + "0.3868027\n", + "0.3930922\n", + "0.39938164\n", + "0.40567112\n", + "0.4119606\n", + "0.41825008\n", + "0.42453954\n", + "0.43082902\n", + "0.4371185\n", + "0.44340798\n", + "0.44969743\n", + "0.45598692\n", + "0.4622764\n", + "0.46856588\n", + "0.47485533\n", + "0.48114482\n", + "0.4874343\n", + "0.49372378\n", + "0.50001323\n", + "0.5063027\n", + "0.5125922\n", + "0.5188817\n", + "0.52517116\n", + "0.53146064\n", + "0.53775007\n", + "0.54403955\n", + "0.550329\n", + "0.5566185\n", + "0.562908\n", + "0.5691975\n", + "0.57548696\n", + "0.58177644\n", + "0.58806586\n", + "0.59435534\n", + "0.6006448\n", + "0.6069343\n", + "0.6132238\n", + "0.6195133\n", + "0.62580276\n", + "0.63209224\n", + "0.6383817\n", + "0.64467114\n", + "0.6509606\n", + "0.6572501\n", + "0.6635396\n", + "0.6698291\n", + "0.67611855\n", + "0.68240803\n", + "0.6886975\n", + "0.69498694\n", + "0.7012764\n", + "0.7075659\n", + "0.7138554\n", + "0.72014487\n", + "0.72643435\n", + "0.73272383\n", + "0.7390133\n", + "0.74530274\n", + "0.7515922\n", + "0.7578817\n", + "0.7641712\n", + "0.77046067\n", + "0.77675015\n", + "0.7830396\n", + "0.7893291\n", + "0.79561853\n", + "0.801908\n", + "0.8081975\n", + "0.814487\n", + "0.82077646\n", + "0.82706594\n", + "0.8333554\n", + "0.8396449\n", + "0.84593433\n", + "0.8522238\n", + "0.8585133\n", + "0.8648028\n", + "0.87109226\n", + "0.87738174\n", + "0.8836712\n", + "0.8899607\n", + "0.8962501\n", + "0.9025396\n", + "0.9088291\n", + "0.9151186\n", + "0.92140806\n", + "0.92769754\n", + "0.933987\n", + "0.9402765\n", + "0.9465659\n", + "0.9528554\n", + "0.9591449\n", + "0.9654344\n", + "0.97172385\n", + "0.97801334\n", + "0.9843028\n", + "0.9905923\n", + "0.9968817\n", + "1.0031712\n", + "1.0094607\n", + "1.0157502\n", + "1.0220397\n", + "1.0283291\n", + "1.0346186\n", + "1.0409081\n", + "1.0471976\n", + "1.0534871\n", + "1.0597765\n", + "1.066066\n", + "1.0723555\n", + "1.0786449\n", + "1.0849344\n", + "1.0912238\n", + "1.0975133\n", + "1.1038028\n", + "1.1100923\n", + "1.1163818\n", + "1.1226712\n", + "1.1289607\n", + "1.1352502\n", + "1.1415397\n", + "1.1478292\n", + "1.1541187\n", + "1.1604081\n", + "1.1666976\n", + "1.1729871\n", + "1.1792765\n", + "1.185566\n", + "1.1918554\n", + "1.1981449\n", + "1.2044344\n", + "1.2107239\n", + "1.2170134\n", + "1.2233028\n", + "1.2295923\n", + "1.2358818\n", + "1.2421713\n", + "1.2484608\n", + "1.2547503\n", + "1.2610397\n", + "1.2673292\n", + "1.2736187\n", + "1.2799081\n", + "1.2861975\n", + "1.292487\n", + "1.2987765\n", + "1.305066\n", + "1.3113555\n", + "1.317645\n", + "1.3239344\n", + "1.3302239\n", + "1.3365134\n", + "1.3428029\n", + "1.3490924\n", + "1.3553818\n", + "1.3616713\n", + "1.3679608\n", + "1.3742503\n", + "1.3805397\n", + "1.3868291\n", + "1.3931186\n", + "1.3994081\n", + "1.4056976\n", + "1.4119871\n", + "1.4182765\n", + "1.424566\n", + "1.4308555\n", + "1.437145\n", + "1.4434345\n", + "1.449724\n", + "1.4560134\n", + "1.4623029\n", + "1.4685924\n", + "1.4748819\n", + "1.4811714\n", + "1.4874607\n", + "1.4937502\n", + "1.5000397\n", + "1.5063292\n", + "1.5126187\n", + "1.5189081\n", + "1.5251976\n", + "1.5314871\n", + "1.5377766\n", + "1.5440661\n", + "1.5503556\n", + "1.556645\n", + "1.5629345\n", + "1.569224\n", + "1.5755135\n", + "1.581803\n", + "1.5880923\n", + "1.5943818\n", + "1.6006713\n", + "1.6069608\n", + "1.6132503\n", + "1.6195397\n", + "1.6258292\n", + "1.6321187\n", + "1.6384082\n", + "1.6446977\n", + "1.6509871\n", + "1.6572766\n", + "1.6635661\n", + "1.6698556\n", + "1.6761451\n", + "1.6824346\n", + "1.6887239\n", + "1.6950134\n", + "1.7013029\n", + "1.7075924\n", + "1.7138819\n", + "1.7201713\n", + "1.7264608\n", + "1.7327503\n", + "1.7390398\n", + "1.7453293\n", + "1.7516187\n", + "1.7579082\n", + "1.7641977\n", + "1.7704872\n", + "1.7767767\n", + "1.7830662\n", + "1.7893555\n", + "1.795645\n", + "1.8019345\n", + "1.808224\n", + "1.8145134\n", + "1.8208029\n", + "1.8270924\n", + "1.8333819\n", + "1.8396714\n", + "1.8459609\n", + "1.8522503\n", + "1.8585398\n", + "1.8648293\n", + "1.8711188\n", + "1.8774083\n", + "1.8836977\n", + "1.8899872\n", + "1.8962766\n", + "1.9025661\n", + "1.9088556\n", + "1.915145\n", + "1.9214345\n", + "1.927724\n", + "1.9340135\n", + "1.940303\n", + "1.9465925\n", + "1.9528819\n", + "1.9591714\n", + "1.9654609\n", + "1.9717504\n", + "1.9780399\n", + "1.9843293\n", + "1.9906188\n", + "1.9969082\n", + "2.0031977\n", + "2.0094872\n", + "2.0157766\n", + "2.022066\n", + "2.0283556\n", + "2.034645\n", + "2.0409346\n", + "2.047224\n", + "2.0535135\n", + "2.059803\n", + "2.0660925\n", + "2.072382\n", + "2.0786715\n", + "2.084961\n", + "2.0912504\n", + "2.09754\n", + "2.1038294\n", + "2.1101189\n", + "2.1164083\n", + "2.1226978\n", + "2.1289873\n", + "2.1352768\n", + "2.1415663\n", + "2.1478555\n", + "2.154145\n", + "2.1604345\n", + "2.166724\n", + "2.1730134\n", + "2.179303\n", + "2.1855924\n", + "2.191882\n", + "2.1981714\n", + "2.2044609\n", + "2.2107503\n", + "2.2170398\n", + "2.2233293\n", + "2.2296188\n", + "2.2359083\n", + "2.2421978\n", + "2.2484872\n", + "2.2547767\n", + "2.2610662\n", + "2.2673557\n", + "2.2736452\n", + "2.2799346\n", + "2.2862241\n", + "2.2925136\n", + "2.298803\n", + "2.3050926\n", + "2.311382\n", + "2.3176715\n", + "2.323961\n", + "2.3302505\n", + "2.33654\n", + "2.3428295\n", + "2.349119\n", + "2.3554082\n", + "2.3616977\n", + "2.3679872\n", + "2.3742766\n", + "2.3805661\n", + "2.3868556\n", + "2.393145\n", + "2.3994346\n", + "2.405724\n", + "2.4120135\n", + "2.418303\n", + "2.4245925\n", + "2.430882\n", + "2.4371715\n", + "2.443461\n", + "2.4497504\n", + "2.45604\n", + "2.4623294\n", + "2.4686189\n", + "2.4749084\n", + "2.4811978\n", + "2.4874873\n", + "2.4937768\n", + "2.5000663\n", + "2.5063558\n", + "2.5126452\n", + "2.5189347\n", + "2.5252242\n", + "2.5315137\n", + "2.5378032\n", + "2.5440927\n", + "2.5503821\n", + "2.5566714\n", + "2.5629609\n", + "2.5692503\n", + "2.5755398\n", + "2.5818293\n", + "2.5881188\n", + "2.5944083\n", + "2.6006978\n", + "2.6069872\n", + "2.6132767\n", + "2.6195662\n", + "2.6258557\n", + "2.6321452\n", + "2.6384346\n", + "2.6447241\n", + "2.6510136\n", + "2.657303\n", + "2.6635926\n", + "2.669882\n", + "2.6761715\n", + "2.682461\n", + "2.6887505\n", + "2.69504\n", + "2.7013295\n", + "2.707619\n", + "2.7139084\n", + "2.720198\n", + "2.7264874\n", + "2.7327769\n", + "2.7390664\n", + "2.7453558\n", + "2.7516453\n", + "2.7579348\n", + "2.764224\n", + "2.7705135\n", + "2.776803\n", + "2.7830925\n", + "2.789382\n", + "2.7956715\n", + "2.801961\n", + "2.8082504\n", + "2.81454\n", + "2.8208294\n", + "2.8271189\n", + "2.8334084\n", + "2.8396978\n", + "2.8459873\n", + "2.8522768\n", + "2.8585663\n", + "2.8648558\n", + "2.8711452\n", + "2.8774347\n", + "2.8837242\n", + "2.8900137\n", + "2.8963032\n", + "2.9025927\n", + "2.9088821\n", + "2.9151716\n", + "2.921461\n", + "2.9277506\n", + "2.93404\n", + "2.9403296\n", + "2.946619\n", + "2.9529085\n", + "2.959198\n", + "2.9654872\n", + "2.9717767\n", + "2.9780662\n", + "2.9843557\n", + "2.9906452\n", + "2.9969347\n", + "3.0032241\n", + "3.0095136\n", + "3.015803\n", + "3.0220926\n", + "3.028382\n", + "3.0346715\n", + "3.040961\n", + "3.0472505\n", + "3.05354\n", + "3.0598295\n", + "3.066119\n", + "3.0724084\n", + "3.078698\n", + "3.0849874\n", + "3.091277\n", + "3.0975664\n", + "3.1038558\n", + "3.1101453\n", + "3.1164348\n", + "3.1227243\n", + "3.1290138\n", + "3.1353033\n", + "3.1415927\n" + ] + } + ], + "source": [ + "tfd = tfp.distributions\n", + "\n", + "# Initialize a single 3-dimension vMF distribution.\n", + "mu = [0]\n", + "conc = 1.\n", + "vmf = tfd.VonMisesFisher(mean_direction=mu, concentration=conc)\n", + "\n", + "# Evaluate this on an observation in S^2 (in R^3), returning a scalar.\n", + "x = np.linspace(-np.pi, np.pi, 1000, dtype=np.float32)\n", + "pdfs = []\n", + "for quat in x:\n", + " print(quat)\n", + " pdfs.append(float(vmf.prob([quat])))" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x, pdfs, label='gaussian')\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gaussian_approx_pdf = []\n", + "for quat in x:\n", + " print(quat)\n", + " gaussian_approx_pdf.append(float(tfp.distributions.MultivariateNormalDiag(\n", + " [mu], [np.sqrt(1/conc)]\n", + " ).prob([quat])))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "Argument diag must have at least 1 dimension. Found: 1.0", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[20], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m mvn \u001b[38;5;241m=\u001b[39m \u001b[43mtfd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mMultivariateNormalDiag\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2\u001b[0m \u001b[43m \u001b[49m\u001b[43mloc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1.\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[43m \u001b[49m\u001b[43mscale_diag\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[38;5;66;03m# Evaluate this on an observation in `R^2`, returning a scalar.\u001b[39;00m\n\u001b[1;32m 6\u001b[0m mvn\u001b[38;5;241m.\u001b[39mprob([\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1.\u001b[39m]) \u001b[38;5;66;03m# shape: []\u001b[39;00m\n", + "File \u001b[0;32m~/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/decorator.py:232\u001b[0m, in \u001b[0;36mdecorate..fun\u001b[0;34m(*args, **kw)\u001b[0m\n\u001b[1;32m 230\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m kwsyntax:\n\u001b[1;32m 231\u001b[0m args, kw \u001b[38;5;241m=\u001b[39m fix(args, kw, sig)\n\u001b[0;32m--> 232\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mcaller\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mextras\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkw\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/substrates/jax/distributions/distribution.py:342\u001b[0m, in \u001b[0;36m_DistributionMeta.__new__..wrapped_init\u001b[0;34m(***failed resolving arguments***)\u001b[0m\n\u001b[1;32m 339\u001b[0m \u001b[38;5;66;03m# Note: if we ever want to have things set in `self` before `__init__` is\u001b[39;00m\n\u001b[1;32m 340\u001b[0m \u001b[38;5;66;03m# called, here is the place to do it.\u001b[39;00m\n\u001b[1;32m 341\u001b[0m self_\u001b[38;5;241m.\u001b[39m_parameters \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m--> 342\u001b[0m \u001b[43mdefault_init\u001b[49m\u001b[43m(\u001b[49m\u001b[43mself_\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 343\u001b[0m \u001b[38;5;66;03m# Note: if we ever want to override things set in `self` by subclass\u001b[39;00m\n\u001b[1;32m 344\u001b[0m \u001b[38;5;66;03m# `__init__`, here is the place to do it.\u001b[39;00m\n\u001b[1;32m 345\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m self_\u001b[38;5;241m.\u001b[39m_parameters \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 346\u001b[0m \u001b[38;5;66;03m# We prefer subclasses will set `parameters = dict(locals())` because\u001b[39;00m\n\u001b[1;32m 347\u001b[0m \u001b[38;5;66;03m# this has nearly zero overhead. However, failing to do this, we will\u001b[39;00m\n\u001b[1;32m 348\u001b[0m \u001b[38;5;66;03m# resolve the input arguments dynamically and only when needed.\u001b[39;00m\n", + "File \u001b[0;32m~/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/substrates/jax/distributions/mvn_diag.py:191\u001b[0m, in \u001b[0;36mMultivariateNormalDiag.__init__\u001b[0;34m(self, loc, scale_diag, validate_args, allow_nan_stats, experimental_use_kahan_sum, name)\u001b[0m\n\u001b[1;32m 188\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m scale_diag \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 189\u001b[0m diag_cls \u001b[38;5;241m=\u001b[39m (KahanLogDetLinOpDiag \u001b[38;5;28;01mif\u001b[39;00m experimental_use_kahan_sum \u001b[38;5;28;01melse\u001b[39;00m\n\u001b[1;32m 190\u001b[0m tf\u001b[38;5;241m.\u001b[39mlinalg\u001b[38;5;241m.\u001b[39mLinearOperatorDiag)\n\u001b[0;32m--> 191\u001b[0m scale \u001b[38;5;241m=\u001b[39m \u001b[43mdiag_cls\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 192\u001b[0m \u001b[43m \u001b[49m\u001b[43mdiag\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscale_diag\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 193\u001b[0m \u001b[43m \u001b[49m\u001b[43mis_non_singular\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 194\u001b[0m \u001b[43m \u001b[49m\u001b[43mis_self_adjoint\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 195\u001b[0m \u001b[43m \u001b[49m\u001b[43mis_positive_definite\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 196\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 197\u001b[0m \u001b[38;5;66;03m# Deprecated behavior; breaks variable-safety rules by calling\u001b[39;00m\n\u001b[1;32m 198\u001b[0m \u001b[38;5;66;03m# `tf.shape(loc)`.\u001b[39;00m\n\u001b[1;32m 199\u001b[0m num_rows \u001b[38;5;241m=\u001b[39m tf\u001b[38;5;241m.\u001b[39mcompat\u001b[38;5;241m.\u001b[39mdimension_value(loc\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m])\n", + "File \u001b[0;32m~/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/gen/linear_operator_diag.py:173\u001b[0m, in \u001b[0;36mLinearOperatorDiag.__init__\u001b[0;34m(self, diag, is_non_singular, is_self_adjoint, is_positive_definite, is_square, name)\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m ops\u001b[38;5;241m.\u001b[39mname_scope(name, values\u001b[38;5;241m=\u001b[39m[diag]):\n\u001b[1;32m 171\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_diag \u001b[38;5;241m=\u001b[39m linear_operator_util\u001b[38;5;241m.\u001b[39mconvert_nonref_to_tensor(\n\u001b[1;32m 172\u001b[0m diag, name\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdiag\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m--> 173\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_check_diag\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_diag\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 175\u001b[0m \u001b[38;5;66;03m# Check and auto-set hints.\u001b[39;00m\n\u001b[1;32m 176\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m np\u001b[38;5;241m.\u001b[39missubdtype(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_diag\u001b[38;5;241m.\u001b[39mdtype, np\u001b[38;5;241m.\u001b[39mcomplexfloating):\n", + "File \u001b[0;32m~/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/gen/linear_operator_diag.py:198\u001b[0m, in \u001b[0;36mLinearOperatorDiag._check_diag\u001b[0;34m(self, diag)\u001b[0m\n\u001b[1;32m 196\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Static check of diag.\"\"\"\u001b[39;00m\n\u001b[1;32m 197\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m tensor_shape\u001b[38;5;241m.\u001b[39mTensorShape(diag\u001b[38;5;241m.\u001b[39mshape)\u001b[38;5;241m.\u001b[39mndims \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m tensor_shape\u001b[38;5;241m.\u001b[39mTensorShape(diag\u001b[38;5;241m.\u001b[39mshape)\u001b[38;5;241m.\u001b[39mndims \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m--> 198\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mArgument diag must have at least 1 dimension. \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 199\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFound: \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m diag)\n", + "\u001b[0;31mValueError\u001b[0m: Argument diag must have at least 1 dimension. Found: 1.0" + ] + } + ], + "source": [ + "mvn = tfd.MultivariateNormalDiag(\n", + " loc=[1.],\n", + " scale_diag=[1])\n", + "\n", + "# Evaluate this on an observation in `R^2`, returning a scalar.\n", + "mvn.prob([-1.]) # shape: []" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "default_factory = [(0.05, 1000.0), (0.02, 1500.0), (0.005, 2000.0)]\n", + "# default_factory = [(0.05, 1000.0)]\n", + "index = 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "scores_vmf = jax.vmap(b3d.Pose.logpdf_gaussian_vmf_pose, in_axes=(0, None, None, None))(\n", + " poses_vmf,\n", + " b3d.Pose.identity(),\n", + " default_factory[index][0],\n", + " default_factory[index][1]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x, [float(x) for x in vmf_pdf], label='vmf')\n", + "plt.plot(x, [float(x) for x in gaussian_approx_pdf], label='gaussian')\n", + "plt.legend()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "-3.1415927\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.1353033\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.1290138\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.1227243\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.1164348\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.1101453\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.1038558\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.0975664\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.091277\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.0849874\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.078698\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.0724084\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.066119\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.0598295\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.05354\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.0472505\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.040961\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.0346715\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.028382\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.0220926\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.015803\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.0095136\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.0032241\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.9969347\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.9906452\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.9843557\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.9780662\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.9717767\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.9654872\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.959198\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.9529085\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.946619\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.9403296\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.93404\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.9277506\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.921461\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.9151716\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.9088821\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.9025927\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.8963032\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.8900137\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.8837242\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.8774347\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.8711452\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.8648558\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.8585663\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.8522768\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.8459873\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.8396978\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.8334084\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.8271189\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.8208294\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.81454\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.8082504\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.801961\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.7956715\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.789382\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.7830925\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.776803\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.7705135\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.764224\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.7579348\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.7516453\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.7453558\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.7390664\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.7327769\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.7264874\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.720198\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.7139084\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.707619\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.7013295\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.69504\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.6887505\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.682461\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.6761715\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.669882\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.6635926\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.657303\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.6510136\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.6447241\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.6384346\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.6321452\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.6258557\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.6195662\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.6132767\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.6069872\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.6006978\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.5944083\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.5881188\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.5818293\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.5755398\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.5692503\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.5629609\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.5566714\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.5503821\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.5440927\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.5378032\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.5315137\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.5252242\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.5189347\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.5126452\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.5063558\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.5000663\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.4937768\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.4874873\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.4811978\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.4749084\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.4686189\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.4623294\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.45604\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.4497504\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.443461\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.4371715\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.430882\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.4245925\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.418303\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.4120135\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.405724\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.3994346\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.393145\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.3868556\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.3805661\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.3742766\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.3679872\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.3616977\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.3554082\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.349119\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.3428295\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.33654\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.3302505\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.323961\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.3176715\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.311382\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.3050926\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.298803\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.2925136\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.2862241\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.2799346\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.2736452\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.2673557\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.2610662\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.2547767\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.2484872\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.2421978\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.2359083\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.2296188\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.2233293\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.2170398\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.2107503\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.2044609\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.1981714\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.191882\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.1855924\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.179303\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.1730134\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.166724\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.1604345\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.154145\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.1478555\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.1415663\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.1352768\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.1289873\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.1226978\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.1164083\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.1101189\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.1038294\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.09754\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.0912504\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.084961\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.0786715\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.072382\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.0660925\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.059803\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.0535135\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.047224\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.0409346\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.034645\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.0283556\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.022066\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.0157766\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.0094872\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.0031977\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.9969082\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.9906188\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.9843293\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.9780399\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.9717504\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.9654609\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.9591714\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.9528819\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.9465925\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.940303\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.9340135\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.927724\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.9214345\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.915145\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.9088556\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.9025661\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.8962766\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.8899872\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.8836977\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.8774083\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.8711188\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.8648293\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.8585398\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.8522503\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.8459609\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.8396714\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.8333819\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.8270924\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.8208029\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.8145134\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.808224\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.8019345\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.795645\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.7893555\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.7830662\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.7767767\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.7704872\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.7641977\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.7579082\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.7516187\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.7453293\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.7390398\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.7327503\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.7264608\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.7201713\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.7138819\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.7075924\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.7013029\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.6950134\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.6887239\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.6824346\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.6761451\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.6698556\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.6635661\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.6572766\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.6509871\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.6446977\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.6384082\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.6321187\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.6258292\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.6195397\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.6132503\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.6069608\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.6006713\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.5943818\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.5880923\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.581803\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.5755135\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.569224\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.5629345\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.556645\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.5503556\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.5440661\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.5377766\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.5314871\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.5251976\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.5189081\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.5126187\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.5063292\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.5000397\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.4937502\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.4874607\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.4811714\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.4748819\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.4685924\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.4623029\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.4560134\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.449724\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.4434345\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.437145\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.4308555\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.424566\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.4182765\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.4119871\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.4056976\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.3994081\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.3931186\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.3868291\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.3805397\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.3742503\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.3679608\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.3616713\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.3553818\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.3490924\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.3428029\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.3365134\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.3302239\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.3239344\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.317645\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.3113555\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.305066\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.2987765\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.292487\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.2861975\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.2799081\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.2736187\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.2673292\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.2610397\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.2547503\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.2484608\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.2421713\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.2358818\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.2295923\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.2233028\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.2170134\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.2107239\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.2044344\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.1981449\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.1918554\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.185566\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.1792765\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.1729871\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.1666976\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.1604081\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.1541187\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.1478292\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.1415397\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.1352502\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.1289607\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.1226712\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.1163818\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.1100923\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.1038028\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.0975133\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.0912238\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.0849344\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.0786449\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.0723555\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.066066\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.0597765\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.0534871\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.0471976\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.0409081\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.0346186\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.0283291\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.0220397\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.0157502\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.0094607\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.0031712\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.9968817\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.9905923\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.9843028\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.97801334\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.97172385\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.9654344\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.9591449\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.9528554\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.9465659\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.9402765\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.933987\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.92769754\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.92140806\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.9151186\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.9088291\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.9025396\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.8962501\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.8899607\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.8836712\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.87738174\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.87109226\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.8648028\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.8585133\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.8522238\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.84593433\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.8396449\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.8333554\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.82706594\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.82077646\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.814487\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.8081975\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.801908\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.79561853\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.7893291\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.7830396\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.77675015\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.77046067\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.7641712\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.7578817\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.7515922\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.74530274\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.7390133\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.73272383\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.72643435\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.72014487\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.7138554\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.7075659\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.7012764\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.69498694\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.6886975\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.68240803\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.67611855\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.6698291\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.6635396\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.6572501\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.6509606\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.64467114\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.6383817\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.63209224\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.62580276\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.6195133\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.6132238\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.6069343\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.6006448\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.59435534\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.58806586\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.58177644\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.57548696\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.5691975\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.562908\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.5566185\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.550329\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.54403955\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.53775007\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.53146064\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.52517116\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.5188817\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.5125922\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.5063027\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.50001323\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.49372378\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.4874343\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.48114482\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.47485533\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.46856588\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.4622764\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.45598692\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.44969743\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.44340798\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.4371185\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.43082902\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.42453954\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.41825008\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.4119606\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.40567112\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.39938164\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.3930922\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.3868027\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.38051322\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.37422374\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.3679343\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.3616448\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.35535532\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.34906584\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.3427764\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.3364869\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.33019742\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.32390794\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.3176185\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.311329\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.30503953\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.29875004\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.2924606\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.2861711\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.27988163\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.27359214\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.2673027\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.2610132\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.25472373\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.24843426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.24214478\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.23585531\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.22956583\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.22327636\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.21698688\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.21069741\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.20440793\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.19811845\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.19182898\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.1855395\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.17925003\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.17296055\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.16667108\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.1603816\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.15409213\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.14780265\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.14151318\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.1352237\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.12893423\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.12264476\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.116355285\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.11006581\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.103776336\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.09748686\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.09119739\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.08490791\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.07861844\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.07232896\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.06603949\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.05975001\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.053460535\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.04717106\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.040881585\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.03459211\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.028302636\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.022013161\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.015723687\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.009434212\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.0031447373\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0031447373\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.009434212\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.015723687\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.022013161\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.028302636\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.03459211\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.040881585\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.04717106\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.053460535\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.05975001\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.06603949\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.07232896\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.07861844\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.08490791\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.09119739\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.09748686\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.103776336\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.11006581\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.116355285\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.12264476\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.12893423\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.1352237\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.14151318\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.14780265\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.15409213\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.1603816\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.16667108\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.17296055\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.17925003\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.1855395\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.19182898\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.19811845\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.20440793\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.21069741\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.21698688\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.22327636\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.22956583\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.23585531\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.24214478\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.24843426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.25472373\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.2610132\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.2673027\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.27359214\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.27988163\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.2861711\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.2924606\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.29875004\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.30503953\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.311329\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.3176185\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.32390794\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.33019742\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.3364869\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.3427764\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.34906584\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.35535532\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.3616448\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.3679343\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.37422374\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.38051322\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.3868027\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.3930922\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.39938164\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.40567112\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4119606\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.41825008\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.42453954\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.43082902\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4371185\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.44340798\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.44969743\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.45598692\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4622764\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.46856588\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.47485533\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.48114482\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4874343\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.49372378\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.50001323\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5063027\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5125922\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5188817\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.52517116\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.53146064\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.53775007\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.54403955\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.550329\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5566185\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.562908\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5691975\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.57548696\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.58177644\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.58806586\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.59435534\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6006448\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6069343\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6132238\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6195133\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.62580276\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.63209224\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6383817\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.64467114\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6509606\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6572501\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6635396\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6698291\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.67611855\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.68240803\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6886975\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.69498694\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7012764\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7075659\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7138554\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.72014487\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.72643435\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.73272383\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7390133\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.74530274\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7515922\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7578817\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7641712\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.77046067\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.77675015\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7830396\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7893291\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.79561853\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.801908\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8081975\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.814487\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.82077646\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.82706594\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8333554\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8396449\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.84593433\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8522238\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8585133\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8648028\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.87109226\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.87738174\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8836712\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8899607\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8962501\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9025396\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9088291\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9151186\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.92140806\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.92769754\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.933987\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9402765\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9465659\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9528554\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9591449\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9654344\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.97172385\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.97801334\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9843028\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9905923\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9968817\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0031712\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0094607\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0157502\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0220397\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0283291\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0346186\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0409081\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0471976\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0534871\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0597765\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.066066\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0723555\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0786449\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0849344\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0912238\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0975133\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.1038028\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.1100923\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.1163818\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.1226712\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.1289607\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.1352502\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.1415397\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.1478292\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.1541187\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.1604081\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.1666976\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.1729871\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.1792765\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.185566\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.1918554\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.1981449\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.2044344\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.2107239\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.2170134\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.2233028\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.2295923\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.2358818\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.2421713\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.2484608\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.2547503\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.2610397\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.2673292\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.2736187\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.2799081\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.2861975\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.292487\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.2987765\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.305066\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.3113555\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.317645\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.3239344\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.3302239\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.3365134\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.3428029\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.3490924\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.3553818\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.3616713\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.3679608\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.3742503\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.3805397\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.3868291\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.3931186\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.3994081\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.4056976\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.4119871\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.4182765\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.424566\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.4308555\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.437145\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.4434345\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.449724\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.4560134\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.4623029\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.4685924\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.4748819\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.4811714\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.4874607\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.4937502\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.5000397\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.5063292\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.5126187\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.5189081\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.5251976\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.5314871\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.5377766\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.5440661\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.5503556\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.556645\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.5629345\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.569224\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.5755135\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.581803\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.5880923\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.5943818\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.6006713\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.6069608\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.6132503\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.6195397\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.6258292\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.6321187\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.6384082\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.6446977\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.6509871\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.6572766\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.6635661\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.6698556\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.6761451\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.6824346\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.6887239\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.6950134\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.7013029\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.7075924\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.7138819\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.7201713\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.7264608\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.7327503\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.7390398\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.7453293\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.7516187\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.7579082\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.7641977\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.7704872\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.7767767\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.7830662\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.7893555\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.795645\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.8019345\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.808224\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.8145134\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.8208029\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.8270924\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.8333819\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.8396714\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.8459609\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.8522503\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.8585398\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.8648293\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.8711188\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.8774083\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.8836977\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.8899872\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.8962766\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.9025661\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.9088556\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.915145\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.9214345\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.927724\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.9340135\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.940303\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.9465925\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.9528819\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.9591714\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.9654609\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.9717504\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.9780399\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.9843293\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.9906188\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.9969082\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.0031977\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.0094872\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.0157766\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.022066\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.0283556\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.034645\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.0409346\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.047224\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.0535135\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.059803\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.0660925\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.072382\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.0786715\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.084961\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.0912504\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.09754\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.1038294\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.1101189\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.1164083\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.1226978\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.1289873\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.1352768\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.1415663\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.1478555\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.154145\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.1604345\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.166724\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.1730134\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.179303\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.1855924\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.191882\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.1981714\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.2044609\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.2107503\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.2170398\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.2233293\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.2296188\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.2359083\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.2421978\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.2484872\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.2547767\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.2610662\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.2673557\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.2736452\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.2799346\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.2862241\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.2925136\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.298803\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.3050926\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.311382\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.3176715\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.323961\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.3302505\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.33654\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.3428295\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.349119\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.3554082\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.3616977\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.3679872\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.3742766\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.3805661\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.3868556\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.393145\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.3994346\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.405724\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.4120135\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.418303\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.4245925\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.430882\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.4371715\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.443461\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.4497504\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.45604\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.4623294\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.4686189\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.4749084\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.4811978\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.4874873\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.4937768\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.5000663\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.5063558\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.5126452\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.5189347\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.5252242\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.5315137\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.5378032\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.5440927\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.5503821\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.5566714\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.5629609\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.5692503\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.5755398\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.5818293\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.5881188\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.5944083\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.6006978\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.6069872\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.6132767\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.6195662\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.6258557\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.6321452\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.6384346\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.6447241\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.6510136\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.657303\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.6635926\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.669882\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.6761715\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.682461\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.6887505\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.69504\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.7013295\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.707619\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.7139084\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.720198\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.7264874\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.7327769\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.7390664\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.7453558\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.7516453\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.7579348\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.764224\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.7705135\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.776803\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.7830925\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.789382\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.7956715\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.801961\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.8082504\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.81454\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.8208294\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.8271189\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.8334084\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.8396978\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.8459873\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.8522768\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.8585663\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.8648558\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.8711452\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.8774347\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.8837242\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.8900137\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.8963032\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.9025927\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.9088821\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.9151716\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.921461\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.9277506\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.93404\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.9403296\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.946619\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.9529085\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.959198\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.9654872\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.9717767\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.9780662\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.9843557\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.9906452\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.9969347\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.0032241\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.0095136\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.015803\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.0220926\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.028382\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.0346715\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.040961\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.0472505\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.05354\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.0598295\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.066119\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.0724084\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.078698\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.0849874\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.091277\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.0975664\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.1038558\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.1101453\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.1164348\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.1227243\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.1290138\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.1353033\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.1415927\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py:68: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype, copy=copy, device=device)\n", + "/home/haoliangwang/b3d/.pixi/envs/gpu/lib/python3.12/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n" + ] + }, + { + "ename": "TypeError", + "evalue": "'Axes' object is not subscriptable", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[15], line 17\u001b[0m\n\u001b[1;32m 11\u001b[0m vmf_pdf\u001b[38;5;241m.\u001b[39mappend(tfp\u001b[38;5;241m.\u001b[39mdistributions\u001b[38;5;241m.\u001b[39mVonMisesFisher(\n\u001b[1;32m 12\u001b[0m [\u001b[38;5;241m1.0\u001b[39m], concentration\n\u001b[1;32m 13\u001b[0m )\u001b[38;5;241m.\u001b[39mlog_prob([quat]))\n\u001b[1;32m 14\u001b[0m gaussian_approx_pdf\u001b[38;5;241m.\u001b[39mappend(tfp\u001b[38;5;241m.\u001b[39mdistributions\u001b[38;5;241m.\u001b[39mMultivariateNormalDiag(\n\u001b[1;32m 15\u001b[0m [\u001b[38;5;241m1.0\u001b[39m], [np\u001b[38;5;241m.\u001b[39msqrt(\u001b[38;5;241m1\u001b[39m\u001b[38;5;241m/\u001b[39mconcentration)]\n\u001b[1;32m 16\u001b[0m )\u001b[38;5;241m.\u001b[39mlog_prob([quat]))\n\u001b[0;32m---> 17\u001b[0m \u001b[43maxs\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[38;5;241m.\u001b[39mplot(x, vmf_pdf, label\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mvmf\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 18\u001b[0m axs[i]\u001b[38;5;241m.\u001b[39mplot(x, gaussian_approx_pdf, label\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mgaussian\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 19\u001b[0m axs[i]\u001b[38;5;241m.\u001b[39mlegend()\n", + "\u001b[0;31mTypeError\u001b[0m: 'Axes' object is not subscriptable" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(len(default_factory), figsize=(10, 10))\n", + "x = np.linspace(-np.pi, np.pi, 1000, dtype=np.float32)\n", + "\n", + "for i, pair in enumerate(default_factory):\n", + " print(i)\n", + " concentration = pair[1]\n", + " vmf_pdf = []\n", + " gaussian_approx_pdf = []\n", + " for quat in x:\n", + " print(quat)\n", + " vmf_pdf.append(float(tfp.distributions.VonMisesFisher(\n", + " [1.0], concentration\n", + " ).prob([quat])))\n", + " gaussian_approx_pdf.append(float(tfp.distributions.MultivariateNormalDiag(\n", + " [1.0], [np.sqrt(1/concentration)]\n", + " ).prob([quat])))\n", + " axs[i].plot(x, vmf_pdf, label='vmf')\n", + " axs[i].plot(x, gaussian_approx_pdf, label='gaussian')\n", + " axs[i].legend()\n", + " axs[i].set_title(f'{concentration}')\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import b3d\n", + "import jax\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "default_factory= [(0.05, 1000.0), (0.02, 1500.0), (0.005, 2000.0)]\n", + "index = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "poses_vmf = jax.vmap(b3d.Pose.sample_gaussian_vmf_pose, in_axes=(0, None, None, None))(\n", + " jax.random.split(\n", + " jax.random.PRNGKey(0), 2000\n", + " ),\n", + " b3d.Pose.identity(),\n", + " default_factory[index][0],\n", + " default_factory[index][1]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "scores_vmf = jax.vmap(b3d.Pose.logpdf_gaussian_vmf_pose, in_axes=(0, None, None, None))(\n", + " poses_vmf,\n", + " b3d.Pose.identity(),\n", + " default_factory[index][0],\n", + " default_factory[index][1]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "poses_approx = jax.vmap(b3d.Pose.sample_gaussian_vmf_pose_approx, in_axes=(0, None, None, None))(\n", + " jax.random.split(\n", + " jax.random.PRNGKey(0), 2000\n", + " ),\n", + " b3d.Pose.identity(),\n", + " default_factory[index][0],\n", + " default_factory[index][1]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "scores_approx = jax.vmap(b3d.Pose.logpdf_gaussian_vmf_pose_approx, in_axes=(0, None, None, None))(\n", + " poses_approx,\n", + " b3d.Pose.identity(),\n", + " default_factory[index][0],\n", + " default_factory[index][1]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array([19.278034, 17.956137, 13.500204, ..., 18.808498, 19.053682,\n", + " 18.673601], dtype=float32)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scores_approx" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(scores_vmf*1.2, bins=50, alpha=0.5, label='vmf')\n", + "plt.hist(scores_approx, bins=50, alpha=0.5, label='gaussian')\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "dims_pos = ['x', 'y', 'z']\n", + "dims_rot = ['x', 'y', 'z', 'w']\n", + "\n", + "positions = dict([(dim, {'t':[], 'a':[]}) for dim in dims_pos])\n", + "rotations = dict([(dim, {'t':[], 'a':[]}) for dim in dims_rot])\n", + "for t, a in zip(poses_vmf, poses_approx):\n", + " for i, dim in enumerate(dims_pos):\n", + " positions[dim]['t'].append(t._position[i])\n", + " positions[dim]['a'].append(a._position[i])\n", + " for i, dim in enumerate(dims_rot):\n", + " rotations[dim]['t'].append(t._quaternion[i])\n", + " rotations[dim]['a'].append(a._quaternion[i])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(len(dims_pos), figsize=(10, 10))\n", + "for i, dim in enumerate(dims_pos):\n", + " axs[i].hist(positions[dim]['t'], bins=50, alpha=0.5, label='vmf')\n", + " axs[i].hist(positions[dim]['a'], bins=50, alpha=0.5, label='gaussian')\n", + " axs[i].legend()\n", + " axs[i].set_title(f'{dim}')\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(len(dims_rot), figsize=(10, 10))\n", + "for i, dim in enumerate(dims_rot):\n", + " axs[i].hist(rotations[dim]['t'], bins=50, alpha=0.5, label='vmf')\n", + " axs[i].hist(rotations[dim]['a'], bins=50, alpha=0.5, label='gaussian')\n", + " axs[i].legend()\n", + " axs[i].set_title(f'{dim}')\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "trial_name = 'pilot_it2_collision_non-sphere_box_0012'\n", + "high_std_file_path = f'/home/haoliangwang/data/b3d_tracking_results/gt_all_info/collide/{trial_name}.json'\n", + "low_std_file_path = f'/home/haoliangwang/data/b3d_tracking_results/gt_all_info_0.01_std/collide/{trial_name}.json'" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "with open(high_std_file_path) as f:\n", + " high_std_file = json.load(f)\n", + "with open(low_std_file_path) as f:\n", + " low_std_file = json.load(f)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for key, val in high_std_file['position'].items():\n", + " xs = []\n", + " ys = []\n", + " zs = []\n", + " for pos in val:\n", + " xs.append(list(pos.values())[0])\n", + " ys.append(list(pos.values())[1])\n", + " zs.append(list(pos.values())[2])\n", + " fig = plt.figure()\n", + " fig.suptitle(key, fontsize=16)\n", + " ax1 = fig.add_subplot(131)\n", + " ax1.hist(xs)\n", + " ax1.set_title('x')\n", + " ax2 = fig.add_subplot(132)\n", + " ax2.hist(ys)\n", + " ax2.set_title('y')\n", + " ax3 = fig.add_subplot(133)\n", + " ax3.hist(zs)\n", + " ax3.set_title('z')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhYAAAHNCAYAAABCVjKiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/GU6VOAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAoyUlEQVR4nO3de3RUVZr+8ScmUFwm4aaBREJAYIzcJIaLCAq0QDeNtM7YIjYg4mVA0shlOW0ibQMyJNDTrXEGjRIyiDIJNC0os9RwcQx4i4RAFIEBIUGigqiNCZemIMn+/dGL+nWZBFKVfaoq8P2sdZaeU/tUvbt4ZT3uOlUnzBhjBAAAYMFVwS4AAABcPggWAADAGoIFAACwhmABAACsIVgAAABrCBYAAMAaggUAALCGYAEAAKwhWAAAAGsIFgAAwBqCBYA6vf7665o6daqSkpIUExOjpk2bqnXr1rrlllv03HPP6dy5c8EuEUCICeNeIQDqMmTIEH3wwQdyuVyKjY1Vu3btdPToUX311VeSpKSkJG3ZskWtW7cObqEAQgYrFgDq9PDDD+vdd9/VyZMnVVJSosLCQn355Zf66KOP1LFjRxUVFWnu3LnBLhNACGHFAoBf1q5dq3Hjxik2NtazggEArFgA8EtCQoIk6cyZM0GuBEAoIVgA8MtHH30kSbrpppuCXAmAUMJHIQDqraqqSkePHtWGDRuUkpKi6upq/e///q8GDBgQ7NIAhAhWLABcUkZGhsLCwhQREaG4uDglJyfr9ttvV0FBAaECgBeCBYBLuvbaazV48GANGDBA7du3lyS9++67ys3NVVVVVZCrAxBK+CgEgM8+/vhjTZ06VZ988ommTZumzMzMYJcEIEQQLAD45euvv9Z1112n8+fPq6SkRPHx8cEuCUAI4KMQAH6JjY1V3759VV1drU8++STY5QAIEQQLAH6rrKz0+icAECwA+OXw4cOelYobb7wxyNUACBUECwC1Kioq0rx581RSUlLjsby8PI0ePVqVlZX6+c9/rq5duwahQgChiIs3AdQqPz9fw4cPlyR16NBBHTt21Llz53TkyBH98MMPkqT+/fvrrbfe0tVXXx3ESgGEEoIFgFqdOHFCr776qt555x3t2bNH33zzjc6dO6d27dqpb9++GjdunCZOnKiIiIhglwoghBAsAACANVxjAQAArCFYAAAAawgWAADAGoIFAACwhmABAACsIVgAAABrCBYAAMAaggUAALCGYAEAAKwhWAAAAGsIFgAAwBqCBQAAsIZgEQLOnj2rxMREdevWTeXl5Z7jx44dU4cOHTRs2DBVVVUFsUKgdu+9957CwsKUm5tb47FXXnlFYWFhKiwsDEJlQP2EhYXVuR0+fDjY5TVK3N00RHz++edKSkrSyJEj9dprr6m6ulojR47UZ599puLiYsXExAS7RKBWN910k1q0aKH333/f6/iAAQMkSdu3bw9GWUC9FBQUeO3/9a9/1aRJk1RVVaX9+/crKioqSJU1XhHBLgB/0717dy1fvlz33nuvnnvuOf3lL39Rfn6+8vLyCBUIaY899pimTJmi4uJi9e3bV5JUWFiowsJCrVy5MrjFAZdw8803e/69qqpKd999t8rLy7V161ZChZ9YsQgx06dP1/Lly1VVVaUnn3xSCxcuDHZJwEW53W516tRJv/jFL5SVlSVJuv/++5WXl6eysjK5XK4gVwjUz6OPPqrly5frf/7nf/Szn/0s2OU0WlxjEWIefPBBnT9/XhEREXrssceCXQ5wSS6XS1OnTlVOTo5++OEHffvtt/rTn/6khx9+mFCBRuPf/u3f9OKLL+qll14iVDQQKxYh5PTp0+rXr5+qq6v1zTffaOjQoXrjjTeCXRZwSUePHlV8fLwWL16ss2fP6ne/+51KSkrUqVOnYJcGXNLLL7+sKVOmaP78+Zo3b16wy2n0CBYhZNKkSVq3bp22b9+u//u//9Mvf/lLPfPMM5o9e3awSwMuacKECfr444917tw5JSUlaf369cEuCbikvLw8jR07Vvfff7+ys7ODXc5lgWARIpYvX65HHnlEK1as0AMPPCBJmjFjhl566SW9//77nivsgVC1fft2DRw4UJK0ZcsW3X777UGuCLi40tJS9enTR7GxscrOzlZEhPf3GRITE/k4zw8EixCwe/duDRw4UOPGjdPLL7/sOe52uzV48GB9//332rVrl1q3bh20GoH66NKli5o3b669e/cGuxTgkvLz8zV8+PA6Hy8tLVXnzp0DV9BlgmABwIpPP/1UN954o55//nlNnz492OUACBKCBYAGOXTokL744gs9+eSTOnLkiA4ePKgWLVoEuywAQcLXTQE0yMKFCzVy5EidOnVKa9euJVQAVzhWLAAAgDWsWAAAAGsIFgAAwBqCBQAAsCbgdzetrq7W119/rcjISIWFhQX65XEZMMbo5MmTio2N1VVXBS4b07uwIRj9S+/Chvr2bsCDxddff624uLhAvywuQ2VlZerYsWPAXo/ehU2B7F96FzZdqncDHiwiIyMl/a0w7nUPf1RUVCguLs7TS4FC78KGYPQvvQsb6tu7AQ8WF5bhoqKiaHA0SKCXdOld2BTI/qV3YdOlepeLNwEAgDUECwAAYA3BAgAAWEOwAAAA1hAsAACANQQLAABgDcECAABYQ7AAAADWECwAAIA1BAsAAGCNT8Gic+fOCgsLq7ElJyc7VR9gBb2LULVt2zaNHTtWsbGxCgsL0+uvv+71uDFG8+fPV2xsrJo3b65hw4Zpz549wSkWqAefgkVhYaGOHj3q2TZv3ixJuueeexwpDrCF3kWoOn36tG688UYtXbq01sd///vf65lnntHSpUtVWFioDh06aOTIkTp58mSAKwXqx6ebkF1zzTVe+4sXL1bXrl01dOhQq0UBttG7CFWjR4/W6NGja33MGKOMjAzNnTtX//zP/yxJWrlypdq3b6+cnBxNnTo1kKUC9eL3NRbnzp3TqlWr9OCDD170Tmdut1sVFRVeGxBM9C4ai9LSUh07dkyjRo3yHHO5XBo6dKg+/PDDOs+jdxFMft82/fXXX9cPP/ygBx544KLj0tPTtWDBAn9fBpeRzilv+nzO4cVjrNcRSr0bKu8JQtOxY8ckSe3bt/c63r59e33xxRd1nheqf+/S71cGv1cssrOzNXr0aMXGxl50XGpqqsrLyz1bWVmZvy8JWEHvorH58cqaMeaiq230LoLJrxWLL774Qlu2bNG6desuOdblcsnlcvnzMoB19C4akw4dOkj628pFTEyM5/jx48drrGL8PXoXweTXisWKFSsUHR2tMWNYokLjQu+iMenSpYs6dOjg+RaT9LdrhLZu3apbbrkliJUBdfN5xaK6ulorVqzQ5MmTFRHh9yUaQMDRuwhFp06d0sGDBz37paWlKi4uVtu2bdWpUyfNmjVLaWlp6t69u7p37660tDS1aNFCv/rVr4JYNVA3n/923bJli44cOaIHH3zQiXoAx9C7CEU7duzQ8OHDPftz5syRJE2ePFkvv/yyfvOb3+ivf/2rpk+frhMnTmjgwIHatGmTIiMjg1UycFE+B4tRo0bJGONELYCj6F2EomHDhl20L8PCwjR//nzNnz8/cEUBDcC9QgAAgDUECwAAYA3BAgAAWEOwAAAA1hAsAACANQQLAABgDcECAABYQ7AAAADWECwAAIA1BAsAAGANwQIAAFhDsAAAANYQLAAAgDUECwAAYA3BAgAAWEOwAAAA1hAsAACANQQLAABgDcECAABYQ7AAAADWECwAAIA1BAsAAGANwQIAAFhDsAAAANYQLAAAgDUECwAAYA3BAgAAWEOwAAAA1hAsAACANQQLAABgDcECAABYQ7AAAADWECwAAIA1BAsAAGANwQIAAFhDsAAAANYQLAAAgDUECwAAYA3BAgAAWONzsPjqq680ceJEtWvXTi1atFDfvn1VVFTkRG2AVfQuADgvwpfBJ06c0ODBgzV8+HC9/fbbio6O1qFDh9S6dWuHygPsoHcBIDB8ChZLlixRXFycVqxY4TnWuXNn2zUB1tG7ABAYPn0UsmHDBvXr10/33HOPoqOjlZiYqKysLKdqA6yhdwEgMHwKFiUlJcrMzFT37t21ceNGTZs2TY899pheeeWVOs9xu92qqKjw2oBAo3cBIDB8+iikurpa/fr1U1pamiQpMTFRe/bsUWZmpu6///5az0lPT9eCBQsaXinQAPQuAASGTysWMTEx6tGjh9exG264QUeOHKnznNTUVJWXl3u2srIy/yoFGoDeBYDA8GnFYvDgwdq/f7/XsQMHDig+Pr7Oc1wul1wul3/VAZbQuwAQGD6tWMyePVsFBQVKS0vTwYMHlZOTo2XLlik5Odmp+gAr6F0ACAyfgkX//v21fv165ebmqlevXlq4cKEyMjI0YcIEp+oDrKB3ASAwfPooRJLuuOMO3XHHHU7UAjiK3gUA53GvEAAAYA3BAgAAWEOwAAAA1hAsAACANQQLAABgDcECAABYQ7AAAADWECwAAIA1BAsAAGANwQIAQlhlZaV++9vfqkuXLmrevLmuu+46Pf3006qurg52aUCtfP5JbwBA4CxZskQvvviiVq5cqZ49e2rHjh2aMmWKWrVqpZkzZwa7PKAGggUAhLCPPvpId955p8aMGSNJ6ty5s3Jzc7Vjx44gVwbUjo9CACCEDRkyRO+8844OHDggSfrkk0/0/vvv6+c//3mQKwNqx4oFAISwJ554QuXl5UpISFB4eLiqqqq0aNEi3XfffXWe43a75Xa7PfsVFRWBKBWQxIoFAIS0NWvWaNWqVcrJydHOnTu1cuVK/eEPf9DKlSvrPCc9PV2tWrXybHFxcQGsGFc6ggUAhLB//dd/VUpKisaPH6/evXtr0qRJmj17ttLT0+s8JzU1VeXl5Z6trKwsgBXjSsdHIQAQws6cOaOrrvL+f8Dw8PCLft3U5XLJ5XI5XRpQK4IFAISwsWPHatGiRerUqZN69uypXbt26ZlnntGDDz4Y7NKAWhEsACCE/ed//qeeeuopTZ8+XcePH1dsbKymTp2q3/3ud8EuDagVwQIAQlhkZKQyMjKUkZER7FKAeuHiTQAAYA3BAgAAWEOwAAAA1hAsAACANQQLAABgDcECAABYQ7AAAADWECwAAIA1BAsAAGANwQIAAFhDsAAAANYQLAAAgDUECwAAYA3BAgAAWEOwAAAA1hAsAACANQQLAABgDcECAABYQ7AAAADWECwAAIA1PgWL+fPnKywszGvr0KGDU7UB1tC7ABAYEb6e0LNnT23ZssWzHx4ebrUgwCn0LgA4z+dgERERwf/poVGidwHAeT5fY/H5558rNjZWXbp00fjx41VSUnLR8W63WxUVFV4bEAz0LgA4z6dgMXDgQL3yyivauHGjsrKydOzYMd1yyy36/vvv6zwnPT1drVq18mxxcXENLhrwFb0LAIHhU7AYPXq07r77bvXu3VsjRozQm2++KUlauXJlneekpqaqvLzcs5WVlTWsYsAP9C4ABIbP11j8vZYtW6p37976/PPP6xzjcrnkcrka8jKAdfQuADijQb9j4Xa7tW/fPsXExNiqBwgIehcAnOFTsHj88ce1detWlZaW6uOPP9Yvf/lLVVRUaPLkyU7VB1hB7wJAYPj0UciXX36p++67T999952uueYa3XzzzSooKFB8fLxT9QFW0LsAEBg+BYvVq1c7VQfgKHoXAAKDe4UAAABrCBYAAMAaggUAALCGYAEAAKwhWAAAAGsIFgAAwBqCBQAAsIZgAQAArCFYAAAAawgWAADAGoIFAACwhmABAACsIVgAAABrCBYAAMAaggUAALCGYAEAAKwhWAAAAGsIFgAAwBqCBQAAsIZgAQAArCFYAAAAawgWAADAGoIFAACwhmABAACsIVgAAABrCBYAAMAaggUAALCGYAEAAKwhWAAAAGsIFgAQ4r766itNnDhR7dq1U4sWLdS3b18VFRUFuyygVhHBLgAAULcTJ05o8ODBGj58uN5++21FR0fr0KFDat26dbBLA2pFsACAELZkyRLFxcVpxYoVnmOdO3cOXkHAJfBRCACEsA0bNqhfv3665557FB0drcTERGVlZV30HLfbrYqKCq8NCBSCBQCEsJKSEmVmZqp79+7auHGjpk2bpscee0yvvPJKneekp6erVatWni0uLi6AFeNKR7AAgBBWXV2tm266SWlpaUpMTNTUqVP1yCOPKDMzs85zUlNTVV5e7tnKysoCWDGudAQLAAhhMTEx6tGjh9exG264QUeOHKnzHJfLpaioKK8NCBSCBQCEsMGDB2v//v1exw4cOKD4+PggVQRcHMECAELY7NmzVVBQoLS0NB08eFA5OTlatmyZkpOTg10aUCuCBQCEsP79+2v9+vXKzc1Vr169tHDhQmVkZGjChAnBLg2oVYOCRXp6usLCwjRr1ixL5QCBQe+iMbnjjju0e/dunT17Vvv27dMjjzwS7JKAOvkdLAoLC7Vs2TL16dPHZj2A4+hdAHCOX8Hi1KlTmjBhgrKystSmTRvbNQGOoXcBwFl+BYvk5GSNGTNGI0aMuORYfgEOoYTeBQBn+XyvkNWrV2vnzp0qLCys1/j09HQtWLDA58IQujqnvBnsEvxC7wKA83xasSgrK9PMmTO1atUqNWvWrF7n8AtwCAX0LgAEhk8rFkVFRTp+/LiSkpI8x6qqqrRt2zYtXbpUbrdb4eHhXue4XC65XC471QJ+oncBIDB8Cha33367du/e7XVsypQpSkhI0BNPPFHjL2YgVNC7ABAYPgWLyMhI9erVy+tYy5Yt1a5duxrHgVBC7wJAYPDLmwAAwBqfvxXyY/n5+RbKAAKP3gUA+1ixAAAA1hAsAACANQQLAABgDcECAABYQ7AAAADWECwAAIA1BAsAAGANwQIAAFhDsAAAANYQLAAAgDUECwAAYA3BAgAAWEOwAAAA1hAsAACANQQLAABgDcECAABYQ7AAAADWECwAAIA1BAsAAGANwQIAAFhDsAAAANYQLAAAgDUECwAAYA3BAgAAWEOwAAAA1hAsAACANQQLAABgDcECAABYQ7AAAADWECwAAIA1BAsAAGANwQIAAFhDsAAAANYQLAAAgDUECwAAYA3BAgAAWEOwAAAA1hAsAACANQQLAABgjU/BIjMzU3369FFUVJSioqI0aNAgvf32207VBlhD7wJAYPgULDp27KjFixdrx44d2rFjh37yk5/ozjvv1J49e5yqD7CC3gWAwIjwZfDYsWO99hctWqTMzEwVFBSoZ8+eVgsDbKJ3ASAwfAoWf6+qqkpr167V6dOnNWjQoDrHud1uud1uz35FRYW/LwlYQe8CgHN8Dha7d+/WoEGDdPbsWf3DP/yD1q9frx49etQ5Pj09XQsWLGhQkYANTvZu55Q3bZXpyGsdXjzGgUqCi/cBCE0+fyvk+uuvV3FxsQoKCvToo49q8uTJ2rt3b53jU1NTVV5e7tnKysoaVDDgL3oXAJzn84pF06ZN1a1bN0lSv379VFhYqOeee04vvfRSreNdLpdcLlfDqgQsoHcBwHkN/h0LY4zX59BAY0HvAoB9Pq1YPPnkkxo9erTi4uJ08uRJrV69Wvn5+crLy3OqPsAKehcAAsOnYPHNN99o0qRJOnr0qFq1aqU+ffooLy9PI0eOdKo+wAp6FwACw6dgkZ2d7VQdgKPoXVwu0tPT9eSTT2rmzJnKyMgIdjlADdwrBAAaicLCQi1btkx9+vQJdilAnQgWANAInDp1ShMmTFBWVpbatGkT7HKAOhEsAKARSE5O1pgxYzRixIhLjnW73aqoqPDagEDx+ye9AQCBsXr1au3cuVOFhYX1Gs8vHiOYWLEAgBBWVlammTNnatWqVWrWrFm9zuFXYxFMrFgAQAgrKirS8ePHlZSU5DlWVVWlbdu2aenSpXK73QoPD/c6h1+NRTARLAAghN1+++3avXu317EpU6YoISFBTzzxRI1QAQQbwQIAQlhkZKR69erldaxly5Zq165djeNAKOAaCwAAYA0rFgDQyOTn5we7BKBOrFgAAABrCBYAAMAaggUAALCGYAEAAKwhWAAAAGsIFgAAwBqCBQAAsIZgAQAArCFYAAAAawgWAADAGoIFAACwhmABAACsIVgAAABrCBYAAMAaggUAALCGYAEAAKwhWAAAAGsIFgAAwBqCBQAAsIZgAQAArCFYAAAAawgWAADAGoIFAACwhmABAACsIVgAAABrCBYAAMAaggUAALCGYAEAAKwhWAAAAGsigl0AAAChoHPKmz6fc3jxGAcqadx8WrFIT09X//79FRkZqejoaN11113av3+/U7UB1tC7ABAYPgWLrVu3Kjk5WQUFBdq8ebMqKys1atQonT592qn6ACvoXQAIDJ8+CsnLy/PaX7FihaKjo1VUVKTbbrvNamGATfQuAARGg66xKC8vlyS1bdu2zjFut1tut9uzX1FR0ZCXBKygdwHAGX4HC2OM5syZoyFDhqhXr151jktPT9eCBQvq9ZyhfuEM9V0enOhdAMDf+P1101//+tf69NNPlZube9FxqampKi8v92xlZWX+viRgBb0LAM7xa8VixowZ2rBhg7Zt26aOHTtedKzL5ZLL5fKrOMA2ehcAnOVTsDDGaMaMGVq/fr3y8/PVpUsXp+oCrKJ3ASAwfAoWycnJysnJ0RtvvKHIyEgdO3ZMktSqVSs1b97ckQIBG+hdAAgMn66xyMzMVHl5uYYNG6aYmBjPtmbNGqfqA6ygdwEgMHz+KARojOhdAAgMbkIGAACsIVgAAABrCBYAAMAaggUAALCGYAEAAKwhWAAAAGsIFgAAwBqCBQAAsIZgAQAArCFYAAAAawgWAADAGoIFAACwhmABAACsIVgAAABrCBYAAMAaggUAALCGYAEAAKwhWAAAAGsIFgAAwBqCBQCEsPT0dPXv31+RkZGKjo7WXXfdpf379we7LKBOBAsACGFbt25VcnKyCgoKtHnzZlVWVmrUqFE6ffp0sEsDahUR7AIAAHXLy8vz2l+xYoWio6NVVFSk2267LUhVAXUjWABAI1JeXi5Jatu2bZ1j3G633G63Z7+iosLxuoALCBYA0EgYYzRnzhwNGTJEvXr1qnNcenq6FixYUK/n7Jzypq3yAElcYwEAjcavf/1rffrpp8rNzb3ouNTUVJWXl3u2srKyAFUIsGIBAI3CjBkztGHDBm3btk0dO3a86FiXyyWXyxWgygBvBAsACGHGGM2YMUPr169Xfn6+unTpEuySgIsiWABACEtOTlZOTo7eeOMNRUZG6tixY5KkVq1aqXnz5kGuDqiJaywAIIRlZmaqvLxcw4YNU0xMjGdbs2ZNsEsDasWKBQCEMGNMsEsAfMKKBQAAsIZgAQAArCFYAAAAawgWAADAGoIFAACwhmABAACsIVgAAABrCBYAAMAaggUAALDG52Cxbds2jR07VrGxsQoLC9Prr7/uQFmAffQuADjP52Bx+vRp3XjjjVq6dKkT9QCOoXcBwHk+3ytk9OjRGj16tBO1AI6idwHAeY7fhMztdsvtdnv2KyoqnH5JwAp6FwB853iwSE9P14IFCxx7/s4pbzr23Db4W9/hxWMsVwJfOd27geRPH/rbg6H+36Q/Avn+AY2d498KSU1NVXl5uWcrKytz+iUBK+hdAPCd4ysWLpdLLpfL6ZcBrKN3AcB3/I4FAACwxucVi1OnTungwYOe/dLSUhUXF6tt27bq1KmT1eIAm+hdAHCez8Fix44dGj58uGd/zpw5kqTJkyfr5ZdftlYYYBu9CwDO8zlYDBs2TMYYJ2oBHEXvAoDzuMYCAABYQ7AAAADWECwAAIA1BAsAAGANwQIAAFhDsAAAANYQLAAAgDUECwAAYI3jNyEDAMBf/tyyHv+fP+/f4cVjGvSarFgAAABrCBYAAMAaggUAALCGYAEAAKwhWAAAAGsIFgAAwBqCBQAAsIZgAQAArCFYAAAAawgWAADAGoIFAACwhmABAACsIVgAAABrCBYAAMAaggUAALCGYAEAAKwhWAAAAGsIFgAAwBqCBQAAsIZgAQAArCFYAAAAawgWAADAGoIFAACwhmABAACsIVgAAABrCBYAAMAaggUAALCGYAEAAKwhWAAAAGsIFgAAwBq/gsULL7ygLl26qFmzZkpKStJ7771nuy7AEfQuGit6F42Fz8FizZo1mjVrlubOnatdu3bp1ltv1ejRo3XkyBEn6gOsoXfRWNG7aEx8DhbPPPOMHnroIT388MO64YYblJGRobi4OGVmZjpRH2ANvYvGit5FYxLhy+Bz586pqKhIKSkpXsdHjRqlDz/8sNZz3G633G63Z7+8vFySVFFRUWNstfuML+Vc1mp7fy7Fn/cvUK/jr9rqu3DMGFPv56F3fedPb0ih/V4Eck51vZav/UvvhjZ/eypQgtK7xgdfffWVkWQ++OADr+OLFi0y//iP/1jrOfPmzTOS2Nisb2VlZfQuW6Pd6tu/9C5bqG2X6l2fViwuCAsL89o3xtQ4dkFqaqrmzJnj2a+urtZf/vIXtWvXrs5zGqqiokJxcXEqKytTVFSUI68RTJf7/KSLz9EYo5MnTyo2Ntbn5w313v2xK+HP+oIrZa7+9m9j611/XQl90FjnWN/e9SlYXH311QoPD9exY8e8jh8/flzt27ev9RyXyyWXy+V1rHXr1r68rN+ioqIa1R+ary73+Ul1z7FVq1Y+PU9j690fuxL+rC+4EubqS/829t7115XQB41xjvXpXZ8u3mzatKmSkpK0efNmr+ObN2/WLbfc4lt1QADRu2is6F00Nj5/FDJnzhxNmjRJ/fr106BBg7Rs2TIdOXJE06ZNc6I+wBp6F40VvYvGxOdgce+99+r777/X008/raNHj6pXr1566623FB8f70R9fnG5XJo3b16NpcDLxeU+P8mZOTaG3v2xK+HP+oIraa6+aoy9668roQ8u9zmGGePDd/YAAAAugnuFAAAAawgWAADAGoIFAACwhmABAACsaRTBwpfbBb///vsaPHiw2rVrp+bNmyshIUHPPvus15isrCzdeuutatOmjdq0aaMRI0Zo+/btTk/jomzPcd26derXr59at26tli1bqm/fvnr11VednsZF2Z7j31u9erXCwsJ01113OVC5Pb68B+vWrdPIkSN1zTXXKCoqSoMGDdLGjRtrjHvttdfUo0cPuVwu9ejRQ+vXr3dyCj6xPd89e/bo7rvvVufOnRUWFqaMjAyHZwAbfL3l+9atW5WUlKRmzZrpuuuu04svvuj1+LBhwxQWFlZjGzNmjJPTqJPt+UlSRkaGrr/+ejVv3lxxcXGaPXu2zp4969QU7KrXj9UH0erVq02TJk1MVlaW2bt3r5k5c6Zp2bKl+eKLL2odv3PnTpOTk2M+++wzU1paal599VXTokUL89JLL3nG/OpXvzLPP/+82bVrl9m3b5+ZMmWKadWqlfnyyy8DNS0vTszx3XffNevWrTN79+41Bw8eNBkZGSY8PNzk5eUFalpenJjjBYcPHzbXXnutufXWW82dd97p8Ez85+t7MHPmTLNkyRKzfft2c+DAAZOammqaNGlidu7c6Rnz4YcfmvDwcJOWlmb27dtn0tLSTEREhCkoKAjUtOrkxHy3b99uHn/8cZObm2s6dOhgnn322QDNBv7ytQ9KSkpMixYtzMyZM83evXtNVlaWadKkifnzn//sGfP999+bo0ePerbPPvvMhIeHmxUrVgRoVv+fE/NbtWqVcblc5r//+79NaWmp2bhxo4mJiTGzZs0K1LQaJOSDxYABA8y0adO8jiUkJJiUlJR6P8c//dM/mYkTJ9b5eGVlpYmMjDQrV670u86GCMQcjTEmMTHR/Pa3v/WrxoZyao6VlZVm8ODBZvny5Wby5MkhHSxsvAc9evQwCxYs8OyPGzfO/OxnP/Ma89Of/tSMHz++YcVa4MR8/158fDzBohHwtQ9+85vfmISEBK9jU6dONTfffHOdr/Hss8+ayMhIc+rUqYYX7CMn5pecnGx+8pOfeI2ZM2eOGTJkiKWqnRXSH4VcuF3wqFGjvI5f7HbBP7Zr1y59+OGHGjp0aJ1jzpw5o/Pnz6tt27YNqtcfgZijMUbvvPOO9u/fr9tuu63BNfvKyTk+/fTTuuaaa/TQQw9Zq9cJNt6D6upqnTx50qtPP/rooxrP+dOf/rTez+kUp+aLxsWfPqirp3fs2KHz58/Xek52drbGjx+vli1b2im8npya35AhQ1RUVOT5iL6kpERvvfVW0D7q8ZVfdzcNlO+++05VVVU1brTTvn37Gjfk+bGOHTvq22+/VWVlpebPn6+HH364zrEpKSm69tprNWLECCt1+8LJOZaXl+vaa6+V2+1WeHi4XnjhBY0cOdL6HC7FqTl+8MEHys7OVnFxsRNlW9WQ9+CCP/7xjzp9+rTGjRvnOXbs2LEGPadTnJovGhd/+qCunq6srNR3332nmJgYr8e2b9+uzz77TNnZ2XaLrwen5jd+/Hh9++23GjJkiIwxqqys1KOPPqqUlBTH5mJTSAeLC3y5XfAF7733nk6dOqWCggKlpKSoW7duuu+++2qM+/3vf6/c3Fzl5+erWbNmVuv2hRNzjIyMVHFxsU6dOqV33nlHc+bM0XXXXadhw4Y5MYVLsjnHkydPauLEicrKytLVV1/tZNlW+fMeSFJubq7mz5+vN954Q9HR0VaeMxCcmC8aH1/7oLbxtR2X/rZa0atXLw0YMMBCpf6xPb/8/HwtWrRIL7zwggYOHKiDBw9q5syZiomJ0VNPPWW5evtCOlj4c7vgC7p06SJJ6t27t7755hvNnz+/RrD4wx/+oLS0NG3ZskV9+vSxW3w9OTnHq666St26dZMk9e3bV/v27VN6enrAg4UTczx06JAOHz6ssWPHesZWV1dLkiIiIrR//3517drV8kz815D3YM2aNXrooYe0du3aGqtqHTp08Os5nebUfNG4+NMHdfV0RESE2rVr53X8zJkzWr16tZ5++mm7hdeTU/N76qmnNGnSJM8Kbe/evXX69Gn9y7/8i+bOnaurrgrpqxhC++umtm4XbIyR2+32Ovbv//7vWrhwofLy8tSvXz8r9frDyTn6M8YJTswxISFBu3fvVnFxsWf7xS9+oeHDh6u4uFhxcXFW59BQ/r4Hubm5euCBB5STk1Pr56uDBg2q8ZybNm0K+u20nZovGhd/+qCunu7Xr5+aNGnidfxPf/qT3G63Jk6caLfwenJqfmfOnKkRHsLDw2X+9oULizNwSKCvFvXVha/yZGdnm71795pZs2aZli1bmsOHDxtjjElJSTGTJk3yjF+6dKnZsGGDOXDggDlw4ID5r//6LxMVFWXmzp3rGbNkyRLTtGlT8+c//9nrK0snT54M+PyMcWaOaWlpZtOmTebQoUNm37595o9//KOJiIgwWVlZAZ+fMc7M8cdC/Vshvr4HOTk5JiIiwjz//PNeffrDDz94xnzwwQcmPDzcLF682Ozbt88sXrw45L5uanO+brfb7Nq1y+zatcvExMSYxx9/3Ozatct8/vnnAZ8f6sfXPrjwdczZs2ebvXv3muzs7Bpfx7xgyJAh5t577w3YXGrjxPzmzZtnIiMjTW5urikpKTGbNm0yXbt2NePGjQv4/PwR8sHCGGOef/55Ex8fb5o2bWpuuukms3XrVs9jkydPNkOHDvXs/8d//Ifp2bOnadGihYmKijKJiYnmhRdeMFVVVZ4x8fHxRlKNbd68eQGclTfbc5w7d67p1q2badasmWnTpo0ZNGiQWb16dSCnVIPtOf5YqAcLY3x7D4YOHVprn06ePNnrOdeuXWuuv/5606RJE5OQkGBee+21AM3m0mzPt7S0tNYxf/88CD2+9IExxuTn55vExETTtGlT07lzZ5OZmVnjOffv328kmU2bNjld/iXZnt/58+fN/PnzTdeuXU2zZs1MXFycmT59ujlx4kQAZtNw3DYdAABYE9LXWAAAgMaFYAEAAKwhWAAAAGsIFgAAwBqCBQAAsIZgAQAArCFYAAAAawgWAADAGoIFAACwhmABAACsIVgAAABrCBYAAMCa/wdg1KCTOS8rogAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for key, val in low_std_file['position'].items():\n", + " xs = []\n", + " ys = []\n", + " zs = []\n", + " for pos in val:\n", + " xs.append(list(pos.values())[0])\n", + " ys.append(list(pos.values())[1])\n", + " zs.append(list(pos.values())[2])\n", + " fig = plt.figure()\n", + " fig.suptitle(key, fontsize=16)\n", + " ax1 = fig.add_subplot(131)\n", + " ax1.hist(xs)\n", + " ax1.set_title('x')\n", + " ax2 = fig.add_subplot(132)\n", + " ax2.hist(ys)\n", + " ax2.set_title('y')\n", + " ax3 = fig.add_subplot(133)\n", + " ax3.hist(zs)\n", + " ax3.set_title('z')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import b3d\n", + "import jax\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Pose(position=Array([[ 0.35498047, 0.24438477, -1.0976562 ],\n", + " [-1.3544922 , -0.71435547, -1.375 ],\n", + " [ 0.10894775, 0.07788086, 0.05038452],\n", + " ...,\n", + " [-0.88183594, -0.7573242 , 1.1220703 ],\n", + " [-1.2539062 , -1.2626953 , -0.19128418],\n", + " [ 0. , 0. , 0. ]], dtype=float32), quaternion=Array([[-0.2883732 , -0.28577614, -0.00555005, 0.91386116],\n", + " [ 0.21153456, 0.17379175, -0.08844002, 0.95772016],\n", + " [-0.23730218, -0.31130645, -0.3244914 , 0.8610931 ],\n", + " ...,\n", + " [-0.03866065, -0.49035713, 0.28554052, 0.8225095 ],\n", + " [ 0.33344486, 0.08678766, 0.33143833, 0.87831146],\n", + " [ 0. , 0. , 0. , 1. ]], dtype=float32))" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "num_pose_grid = 11\n", + "rotation_deltas = b3d.Pose.concatenate_poses(\n", + " [\n", + " jax.vmap(b3d.Pose.sample_gaussian_vmf_pose, in_axes=(0, None, None, None))(\n", + " jax.random.split(\n", + " jax.random.PRNGKey(0), num_pose_grid * num_pose_grid * num_pose_grid\n", + " ),\n", + " b3d.Pose.identity(),\n", + " 1,\n", + " 10.0,\n", + " ),\n", + " b3d.Pose.identity()[None, ...],\n", + " ]\n", + ")\n", + "rotation_deltas" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "xs = []\n", + "ys = []\n", + "zs = []\n", + "for rotation_delta in rotation_deltas:\n", + " xs.append(rotation_delta._position[0])\n", + " ys.append(rotation_delta._position[1])\n", + " zs.append(rotation_delta._position[2])" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([ 2., 8., 45., 159., 321., 372., 267., 122., 28., 8.]),\n", + " array([-3.80273438, -3.0851562 , -2.36757803, -1.64999998, -0.93242186,\n", + " -0.21484375, 0.50273436, 1.22031248, 1.93789065, 2.6554687 ,\n", + " 3.37304688]),\n", + " )" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(ys)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "gpu", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tests/dense_model_unit_tests/triangle_depth_posterior/solver/importance.py b/tests/dense_model_unit_tests/triangle_depth_posterior/solver/importance.py index 613ad101..911b4e04 100644 --- a/tests/dense_model_unit_tests/triangle_depth_posterior/solver/importance.py +++ b/tests/dense_model_unit_tests/triangle_depth_posterior/solver/importance.py @@ -67,8 +67,8 @@ def importance_sample_with_depth_in_partition( C.d( { "triangle_vertices": new_triangle_W, - "observed_rgbs": genjax.ChoiceMap.idx( - jnp.arange(T), C.n().at["observed_rgb"].set(task_input["video"]) + "observed_rgbs": C[jnp.arange(T), "observed_rgb"].set( + task_input["video"] ), } ), diff --git a/tests/dynamic_object_model/kfold_image_kernel_real_data.py b/tests/dynamic_object_model/kfold_image_kernel_real_data.py deleted file mode 100644 index d4154169..00000000 --- a/tests/dynamic_object_model/kfold_image_kernel_real_data.py +++ /dev/null @@ -1,127 +0,0 @@ -### IMPORTS ### - -import os - -import b3d -import b3d.chisight.dynamic_object_model.kfold_image_kernel as kik -import jax -import jax.numpy as jnp -from b3d import Mesh - -b3d.rr_init("kfold_image_kernel2") - - -def test_sampling_on_real_data(): - ### Loading data ### - - scene_id = 55 - FRAME_RATE = 50 - ycb_dir = os.path.join(b3d.get_assets_path(), "bop/ycbv") - print(f"Scene {scene_id}") - b3d.reload(b3d.io.data_loader) - num_scenes = b3d.io.data_loader.get_ycbv_num_test_images(ycb_dir, scene_id) - - # image_ids = [image] if image is not None else range(1, num_scenes, FRAME_RATE) - image_ids = range(1, num_scenes + 1, FRAME_RATE) - all_data = b3d.io.data_loader.get_ycbv_test_images(ycb_dir, scene_id, image_ids) - - meshes = [ - Mesh.from_obj_file( - os.path.join(ycb_dir, f'models/obj_{f"{id + 1}".rjust(6, "0")}.ply') - ).scale(0.001) - for id in all_data[0]["object_types"] - ] - - image_height, image_width = all_data[0]["rgbd"].shape[:2] - fx, fy, cx, cy = all_data[0]["camera_intrinsics"] - scaling_factor = 1.0 - renderer = b3d.renderer.renderer_original.RendererOriginal( - image_width * scaling_factor, - image_height * scaling_factor, - fx * scaling_factor, - fy * scaling_factor, - cx * scaling_factor, - cy * scaling_factor, - 0.01, - 2.0, - ) - b3d.viz_rgb(all_data[0]["rgbd"]) - - ###### - - T = 0 - OBJECT_INDEX = 2 - - template_pose = ( - all_data[T]["camera_pose"].inv() @ all_data[T]["object_poses"][OBJECT_INDEX] - ) - rendered_rgbd = renderer.render_rgbd_from_mesh( - meshes[OBJECT_INDEX].transform(template_pose) - ) - xyz_rendered = b3d.xyz_from_depth(rendered_rgbd[..., 3], fx, fy, cx, cy) - - fx, fy, cx, cy = all_data[T]["camera_intrinsics"] - xyz_observed = b3d.xyz_from_depth(all_data[T]["rgbd"][..., 3], fx, fy, cx, cy) - mask = ( - all_data[T]["masks"][OBJECT_INDEX] - * (xyz_observed[..., 2] > 0) - * (jnp.linalg.norm(xyz_rendered - xyz_observed, axis=-1) < 0.01) - ) - - vertices = xyz_rendered[mask] - vertices.shape - - model_rgbd = all_data[T]["rgbd"][mask] - model_rgbd.shape - - intrinsics = { - "fx": fx // 4, - "fy": fy // 4, - "cx": cx // 4, - "cy": cy // 4, - "height": image_height // 4, - "width": image_width // 4, - "near": 0.001, - "far": 100.0, - } - - image_kernel = kik.KfoldMixturePointsToImageKernel(5) - - def get_sample(key): - sample, _ = image_kernel.random_weighted( - key, - intrinsics, - vertices, - model_rgbd, - # color outlier probs - 0.003 * jnp.ones(vertices.shape[0]), - # depth outlier probs - 0.001 * jnp.ones(vertices.shape[0]), - # color scale - 0.01, - # depth scale - 0.04, - ) - return sample - - samples_20 = jax.vmap(get_sample)(jax.random.split(jax.random.PRNGKey(0), 20)) - assert samples_20.shape == (20, image_height // 4, image_width // 4, 4) - - assert ( - image_kernel.estimate_logpdf( - jax.random.PRNGKey(10), - samples_20[0], - intrinsics, - vertices, - model_rgbd, - # color outlier probs - 0.003 * jnp.ones(vertices.shape[0]), - # depth outlier probs - 0.001 * jnp.ones(vertices.shape[0]), - # color scale - 0.01, - # depth scale - 0.04, - ).shape - == () - ) diff --git a/tests/dynamic_object_model/kfold_image_kernel_unit_test.py b/tests/dynamic_object_model/kfold_image_kernel_unit_test.py deleted file mode 100644 index f2465bec..00000000 --- a/tests/dynamic_object_model/kfold_image_kernel_unit_test.py +++ /dev/null @@ -1,162 +0,0 @@ -import importlib - -import b3d -import b3d.chisight.dynamic_object_model.likelihoods.kfold_image_kernel as kik -import jax.numpy as jnp -from jax.random import PRNGKey - -importlib.reload(kik) - - -def expected_logpdf_given_idx(args, value, point_idx): - ( - _, - all_rgbds, - color_outlier_probs, - depth_outlier_probs, - color_scale, - depth_scale, - near, - far, - ) = args - i = point_idx - - color_pdf_should_be = jnp.logaddexp( - jnp.log(1 - color_outlier_probs[i]) - + kik.truncated_color_laplace.logpdf(value[:3], all_rgbds[i][:3], color_scale), - jnp.log(color_outlier_probs[i]) + jnp.log(1.0**3), - ) - depth_pdf_should_be = jnp.logaddexp( - jnp.log(1 - depth_outlier_probs[i]) - + kik.truncated_laplace.logpdf( - value[3], - all_rgbds[i][3], - depth_scale, - near, - far, - kik._FIXED_DEPTH_UNIFORM_WINDOW, - ), - jnp.log(depth_outlier_probs[i]) + jnp.log(1 / (far - near)), - ) - return color_pdf_should_be + depth_pdf_should_be - - -def test_logpdfs_in_image_with_one_point_per_pixel(): - intrinsics = ( - 3, - 3, - 200.0, - 200.0, - 50.0, - 50.0, - 0.01, - 10.0, - ) - image_width, image_height, fx, fy, cx, cy, _, _ = intrinsics - - intrinsics_dict = { - "fx": fx, - "fy": fy, - "cx": cx, - "cy": cy, - "width": image_width, - "height": image_height, - "near": 0.01, - "far": 100.0, - } - depth_image = jnp.ones((image_height, image_width), dtype=jnp.float32) - vertices = b3d.camera.camera_from_depth(depth_image, intrinsics).reshape(-1, 3) - - # result = kik.raycast_to_image_nondeterministic( - # PRNGKey(0), - # { - # "height": image_height, - # "width": image_width, - # "fx": fx, - # "fy": fy, - # "cx": cx, - # "cy": cy, - # }, - # vertices, - # 2, - # ) - # result - - rgbds = jnp.tile(jnp.array([1.0, 0.0, 0.0, 5.0]), (9, 1)) - color_outlier_probs = 0.003 * jnp.arange(9) - depth_outlier_probs = (10 - jnp.arange(9)) / 100 - color_scale = 0.01 - depth_scale = 0.04 - - image_kernel = kik.KfoldMixturePointsToImageKernel(1) - sample, lp1 = image_kernel.random_weighted( - PRNGKey(0), - intrinsics_dict, - vertices, - rgbds, - color_outlier_probs, - depth_outlier_probs, - color_scale, - depth_scale, - ) - lp2 = image_kernel.estimate_logpdf( - PRNGKey(10), - sample, - intrinsics_dict, - vertices, - rgbds, - color_outlier_probs, - depth_outlier_probs, - color_scale, - depth_scale, - ) - assert lp1 == lp2 - expected_lp = sum( - [ - expected_logpdf_given_idx( - ( - None, - rgbds, - color_outlier_probs, - depth_outlier_probs, - color_scale, - depth_scale, - intrinsics_dict["near"], - intrinsics_dict["far"], - ), - sample[*jnp.unravel_index(i, (3, 3))], - i, - ) - for i in range(9) - ] - ) - assert lp1 == expected_lp - - test_image = jnp.tile(jnp.array([1.0, 0.0, 0.0, 5.0]), (3, 3, 1)) - test_image_2 = jnp.tile(jnp.array([1.0, 0.0, 1.0, 5.0]), (3, 3, 1)) - lp3 = image_kernel.estimate_logpdf( - PRNGKey(10), - test_image, - intrinsics_dict, - vertices, - rgbds, - color_outlier_probs, - depth_outlier_probs, - color_scale, - depth_scale, - ) - lp4 = image_kernel.estimate_logpdf( - PRNGKey(10), - test_image_2, - intrinsics_dict, - vertices, - rgbds, - color_outlier_probs, - depth_outlier_probs, - color_scale, - depth_scale, - ) - assert lp3 > lp4 - - -# TODO: we could do more thorough testing. diff --git a/tests/dynamic_object_model/test_dynamic_object_model.py b/tests/dynamic_object_model/test_dynamic_object_model.py deleted file mode 100644 index 92053858..00000000 --- a/tests/dynamic_object_model/test_dynamic_object_model.py +++ /dev/null @@ -1,99 +0,0 @@ -### IMPORTS ### - - -import b3d -import jax -import jax.numpy as jnp -from b3d import Pose -from genjax import ChoiceMapBuilder as C -from genjax import Pytree - -b3d.reload(b3d.chisight.dynamic_object_model) - - -def make_trace_and_condition_values(): - key = jax.random.PRNGKey(0) - model_vertices = jax.random.uniform(key, (1000, 3), minval=-0.5, maxval=0.5) - - fx, fy, cx, cy = 100.0, 100.0, 50.0, 50.0 - image_height, image_width = 100, 100 - - hyperparams = { - "vertices": model_vertices, - "fx": fx, - "fy": fy, - "cx": cx, - "cy": cy, - "image_height": Pytree.const(image_height), - "image_width": Pytree.const(image_width), - "max_pose_position_shift": 0.1, - "color_shift_scale": 0.1, - "color_outlier_probability_shift_scale": 0.1, - "depth_outlier_probability_shift_scale": 0.1, - } - - template_pose = Pose.identity() - model_colors = jnp.zeros((len(model_vertices), 3)) - color_outlier_probabilities = jnp.ones(len(model_vertices)) * 0.01 - depth_outlier_probabilities = jnp.ones(len(model_vertices)) * 0.01 - - previous_state = { - "pose": template_pose, - "colors": model_colors, - "color_outlier_probabilities": color_outlier_probabilities, - "depth_outlier_probabilities": depth_outlier_probabilities, - } - - choicemap = C.n() - - key = jax.random.PRNGKey(0) - trace, _ = ( - b3d.chisight.dynamic_object_model.dynamic_object_model.dynamic_object_generative_model.importance( - key, choicemap, (hyperparams, previous_state) - ) - ) - - # Overwrite colors - colors = trace.get_choices()("colors").c.v - new_colors = jnp.ones_like(colors) - assert not jnp.allclose(trace.get_choices()("colors").c.v, new_colors) - chm = jax.vmap(lambda idx: C["colors", idx].set(new_colors[idx]))( - jnp.arange(len(new_colors)) - ) - trace = trace.update(key, chm)[0] - assert jnp.allclose(trace.get_choices()("colors").c.v, new_colors) - - # Overwite pose - # pose = trace.get_choices()("pose").v - new_pose = Pose.from_translation(jnp.array([0.1, 0.1, 0.1])) - chm = C["pose"].set(new_pose) - trace = trace.update(key, chm)[0] - assert jnp.allclose(trace.get_choices()("pose").v.pos, new_pose.pos) - assert jnp.allclose(trace.get_choices()("pose").v.quat, new_pose.quat) - - # TODO test choicemap creators - - # Test proposals - b3d.reload(b3d.chisight.dynamic_object_model.dynamic_object_inference) - from b3d.chisight.dynamic_object_model.dynamic_object_inference import ( - propose_color_and_color_outlier_probability, - propose_depth_outlier_probability, - propose_pose, - ) - - sampled_values, _ = propose_depth_outlier_probability( - trace, key, jnp.linspace(0.0, 1.0, 128) - ) - print(sampled_values.max(), sampled_values.mean()) - propose_pose(trace, key, 0.2, 200.0) - ( - _, - sampled_color_outlier_probabilities, - _, - ) = propose_color_and_color_outlier_probability( - trace, key, jnp.array([0.0, 0.5, 1.0]) - ) - print( - sampled_color_outlier_probabilities.max(), - sampled_color_outlier_probabilities.mean(), - ) diff --git a/tests/dynamic_object_model/test_pixel_distribution.py b/tests/dynamic_object_model/test_pixel_distribution.py deleted file mode 100644 index a29828d9..00000000 --- a/tests/dynamic_object_model/test_pixel_distribution.py +++ /dev/null @@ -1,380 +0,0 @@ -import importlib - -import b3d.chisight.dynamic_object_model.likelihoods.kfold_image_kernel as kik -import jax -import jax.numpy as jnp - -importlib.reload(kik) - - -def test_pixel_distribution_sampling_with_two_of_three_slots(): - registered_point_indices = jnp.array([0, -1, 1]) - all_rgbds = jnp.array( - [[1.0, 0.0, 0.0, 2.0], [0.0, 1.0, 0.0, 3.0], [0.0, 0.0, 1.0, 4.0]] - ) - near, far = 0.001, 100.0 - color_outlier_probs = jnp.array([0.01, 0.5, 0.95]) - depth_outlier_probs = jnp.array([0.5, 0.01, 0.1]) - color_scale = 0.04 - depth_scale = 0.01 - - args = ( - registered_point_indices, - all_rgbds, - color_outlier_probs, - depth_outlier_probs, - color_scale, - depth_scale, - near, - far, - ) - - key = jax.random.PRNGKey(0) - samples_100 = jax.vmap(lambda k: kik.pixel_distribution.sample(k, *args))( - jax.random.split(key, 100) - ) - samples_100 - - # shouldn't be able to pick index 2, so should have very few - # that are close to [0.0, 0.0, 1.0, 4.0] - def is_close_to_0014(rgbd): - return jnp.logical_and( - jnp.allclose(rgbd[:3], jnp.array([0.0, 0.0, 1.0]), atol=0.1), - jnp.abs(rgbd[3] - 4.0) < 0.1, - ) - - n_close = jnp.sum(jax.vmap(is_close_to_0014)(samples_100)) - assert n_close < 4 - - # Should have close to half the samples pick index 0. - # Most of these should have color values close to [1.0, 0.0, 0.0]. - def color_near_100(rgbd): - return jnp.allclose(rgbd[:3], jnp.array([1.0, 0.0, 0.0]), atol=0.15) - - n_color_near_100 = jnp.sum(jax.vmap(color_near_100)(samples_100)) - assert n_color_near_100 > 40 - assert n_color_near_100 < 60 - - # Of these, about half should have a depth outlier, and half should have - # a depth value close to 2.0. - def color_near_100_and_depth_near_2(rgbd): - return jnp.logical_and(color_near_100(rgbd), jnp.abs(rgbd[3] - 2.0) < 0.15) - - n_color_near_100_and_depth_near_2 = jnp.sum( - jax.vmap(color_near_100_and_depth_near_2)(samples_100) - ) - assert n_color_near_100_and_depth_near_2 > n_color_near_100 / 2 - 5 - assert n_color_near_100_and_depth_near_2 < n_color_near_100 / 2 + 5 - - # Test that of the outliers, some are far from 2.0 - def color_near_100_and_far_depth_outlier(rgbd): - return jnp.logical_and(color_near_100(rgbd), jnp.abs(rgbd[3] - 2.0) > 5.0) - - n_color_near_100_and_far_depth_outlier = jnp.sum( - jax.vmap(color_near_100_and_far_depth_outlier)(samples_100) - ) - assert n_color_near_100_and_far_depth_outlier > 1 - - # Should have close to half the samples pick index 1. - # Most of these should have depth values close to 3.0. - def depth_near_3(rgbd): - return jnp.abs(rgbd[3] - 3.0) < 0.15 - - n_depth_near_3 = jnp.sum(jax.vmap(depth_near_3)(samples_100)) - assert n_depth_near_3 > 40 - assert n_depth_near_3 < 60 - - # Of these, about half should have a color outlier, and half should have - # a color value close to [0.0, 1.0, 0.0]. - def depth_near_3_and_color_near_010(rgbd): - return jnp.logical_and( - depth_near_3(rgbd), - jnp.allclose(rgbd[:3], jnp.array([0.0, 1.0, 0.0]), atol=0.15), - ) - - n_depth_near_3_and_color_near_010 = jnp.sum( - jax.vmap(depth_near_3_and_color_near_010)(samples_100) - ) - assert n_depth_near_3_and_color_near_010 > n_depth_near_3 / 2 - 5 - assert n_depth_near_3_and_color_near_010 < n_depth_near_3 / 2 + 5 - - # Test that of the outliers, some are far from [0.0, 1.0, 0.0] - def depth_near_3_and_far_color_outlier(rgbd): - return jnp.logical_and( - depth_near_3(rgbd), - ~jnp.allclose(rgbd[:3], jnp.array([0.0, 1.0, 0.0]), atol=0.3), - ) - - n_depth_near_3_and_far_color_outlier = jnp.sum( - jax.vmap(depth_near_3_and_far_color_outlier)(samples_100) - ) - assert n_depth_near_3_and_far_color_outlier > 1 - - -def test_pixel_distribution_sampling_with_no_slots(): - registered_point_indices = jnp.array([-1, -1, -1]) - all_rgbds = jnp.array( - [[1.0, 0.0, 0.0, 2.0], [0.0, 1.0, 0.0, 3.0], [0.0, 0.0, 1.0, 4.0]] - ) - near, far = 0.001, 100.0 - color_outlier_probs = jnp.array([0.01, 0.5, 0.95]) - depth_outlier_probs = jnp.array([0.5, 0.01, 0.1]) - color_scale = 0.04 - depth_scale = 0.01 - - args = ( - registered_point_indices, - all_rgbds, - color_outlier_probs, - depth_outlier_probs, - color_scale, - depth_scale, - near, - far, - ) - - key = jax.random.PRNGKey(0) - samples_100 = jax.vmap(lambda k: kik.pixel_distribution.sample(k, *args))( - jax.random.split(key, 100) - ) - samples_100 - - # Check that almost all of these seem to be outliers in both color - # and depth. - def is_color_and_depth_outlier(rgbd, base_rgbd): - return jnp.logical_and( - ~jnp.allclose(rgbd[:3], base_rgbd[:3], atol=0.15), - jnp.abs(rgbd[3] - base_rgbd[3]) > 2.0, - ) - - def is_color_and_depth_outlier_for_all(rgbd): - return jnp.all( - jax.vmap(lambda base_rgbd: is_color_and_depth_outlier(rgbd, base_rgbd))( - all_rgbds - ) - ) - - n_color_and_depth_outliers = jnp.sum( - jax.vmap(is_color_and_depth_outlier_for_all)(samples_100) - ) - assert n_color_and_depth_outliers > 90 - - -def test_singleslot_pixel_distribution_sampling(): - registered_point_indices = jnp.array([0, 0, 0]) - all_rgbds = jnp.array( - [[1.0, 0.0, 0.0, 2.0], [0.0, 1.0, 0.0, 3.0], [0.0, 0.0, 1.0, 4.0]] - ) - near, far = 0.001, 100.0 - color_outlier_probs = jnp.array([0.01, 0.5, 0.95]) - depth_outlier_probs = jnp.array([0.5, 0.01, 0.1]) - color_scale = 0.04 - depth_scale = 0.01 - - args = ( - registered_point_indices, - all_rgbds, - color_outlier_probs, - depth_outlier_probs, - color_scale, - depth_scale, - near, - far, - ) - key = jax.random.PRNGKey(0) - samples_100 = jax.vmap(lambda k: kik.pixel_distribution.sample(k, *args))( - jax.random.split(key, 100) - ) - - # Should have close to all the samples pick index 0. - # Most of these should have color values close to [1.0, 0.0, 0.0]. - def color_near_100(rgbd): - return jnp.allclose(rgbd[:3], jnp.array([1.0, 0.0, 0.0]), atol=0.15) - - n_color_near_100 = jnp.sum(jax.vmap(color_near_100)(samples_100)) - assert n_color_near_100 > 90 - - # Of these, about half should have a depth outlier, and half should have - # a depth value close to 2.0. - def color_near_100_and_depth_near_2(rgbd): - return jnp.logical_and(color_near_100(rgbd), jnp.abs(rgbd[3] - 2.0) < 0.15) - - n_color_near_100_and_depth_near_2 = jnp.sum( - jax.vmap(color_near_100_and_depth_near_2)(samples_100) - ) - assert n_color_near_100_and_depth_near_2 > 40 - assert n_color_near_100_and_depth_near_2 < 60 - - -def test_pixel_distribution_logpdf_with_one_of_three_slots(): - def test_logpdf_for_value(value, args): - logpdf = kik.pixel_distribution.logpdf(value, *args) - ( - _, - all_rgbds, - color_outlier_probs, - depth_outlier_probs, - color_scale, - depth_scale, - near, - far, - ) = args - color_pdf_should_be = jnp.logaddexp( - jnp.log(1 - color_outlier_probs[0]) - + kik.truncated_color_laplace.logpdf( - value[:3], all_rgbds[0][:3], color_scale - ), - jnp.log(color_outlier_probs[0]) + jnp.log(1.0**3), - ) - depth_pdf_should_be = jnp.logaddexp( - jnp.log(1 - depth_outlier_probs[0]) - + kik.truncated_laplace.logpdf( - value[3], - all_rgbds[0][3], - depth_scale, - near, - far, - kik._FIXED_DEPTH_UNIFORM_WINDOW, - ), - jnp.log(depth_outlier_probs[0]) + jnp.log(1 / (far - near)), - ) - assert jnp.isclose(logpdf, color_pdf_should_be + depth_pdf_should_be, atol=1e-3) - - registered_point_indices = jnp.array([0, -1, -1]) - all_rgbds = jnp.array( - [[1.0, 0.0, 0.0, 2.0], [0.0, 1.0, 0.0, 3.0], [0.0, 0.0, 1.0, 4.0]] - ) - near, far = 0.001, 100.0 - color_outlier_probs = jnp.array([0.01, 0.5, 0.95]) - depth_outlier_probs = jnp.array([0.5, 0.01, 0.1]) - color_scale = 0.04 - depth_scale = 0.01 - - args = ( - registered_point_indices, - all_rgbds, - color_outlier_probs, - depth_outlier_probs, - color_scale, - depth_scale, - near, - far, - ) - - samples_10 = jax.vmap(lambda k: kik.pixel_distribution.sample(k, *args))( - jax.random.split(jax.random.PRNGKey(0), 10) - ) - for sample in samples_10: - test_logpdf_for_value(sample, args) - - ### 3 copies of the same idx shoudln't change this... - registered_point_indices = jnp.array([0, 0, 0]) - args = ( - registered_point_indices, - all_rgbds, - color_outlier_probs, - depth_outlier_probs, - color_scale, - depth_scale, - near, - far, - ) - samples_10 = jax.vmap(lambda k: kik.pixel_distribution.sample(k, *args))( - jax.random.split(jax.random.PRNGKey(0), 10) - ) - for sample in samples_10: - test_logpdf_for_value(sample, args) - - -def test_logpdf_with_no_slot(): - registered_point_indices = jnp.array([-1, -1, -1]) - all_rgbds = jnp.array( - [[1.0, 0.0, 0.0, 2.0], [0.0, 1.0, 0.0, 3.0], [0.0, 0.0, 1.0, 4.0]] - ) - near, far = 0.001, 100.0 - color_outlier_probs = jnp.array([0.01, 0.5, 0.95]) - depth_outlier_probs = jnp.array([0.5, 0.01, 0.1]) - color_scale = 0.04 - depth_scale = 0.01 - - args = ( - registered_point_indices, - all_rgbds, - color_outlier_probs, - depth_outlier_probs, - color_scale, - depth_scale, - near, - far, - ) - - samples_10 = jax.vmap(lambda k: kik.pixel_distribution.sample(k, *args))( - jax.random.split(jax.random.PRNGKey(0), 10) - ) - - def assert_is_correct_logpdf(value): - logpdf = kik.pixel_distribution.logpdf(value, *args) - assert jnp.isclose( - logpdf, jnp.log(1.0**3) + jnp.log(1 / (far - near)), atol=1e-3 - ) - - for sample in samples_10: - assert_is_correct_logpdf(sample) - - -def test_pixel_distribution_logpdf_with_two_of_three_slots(): - registered_point_indices = jnp.array([0, -1, 1]) - all_rgbds = jnp.array( - [[1.0, 0.0, 0.0, 2.0], [0.0, 1.0, 0.0, 3.0], [0.0, 0.0, 1.0, 4.0]] - ) - near, far = 0.001, 100.0 - color_outlier_probs = jnp.array([0.01, 0.5, 0.95]) - depth_outlier_probs = jnp.array([0.5, 0.01, 0.1]) - color_scale = 0.04 - depth_scale = 0.01 - - args = ( - registered_point_indices, - all_rgbds, - color_outlier_probs, - depth_outlier_probs, - color_scale, - depth_scale, - near, - far, - ) - - def expected_logpdf_given_idx(value, i): - color_pdf_should_be = jnp.logaddexp( - jnp.log(1 - color_outlier_probs[i]) - + kik.truncated_color_laplace.logpdf( - value[:3], all_rgbds[i][:3], color_scale - ), - jnp.log(color_outlier_probs[i]) + jnp.log(1.0**3), - ) - depth_pdf_should_be = jnp.logaddexp( - jnp.log(1 - depth_outlier_probs[i]) - + kik.truncated_laplace.logpdf( - value[3], - all_rgbds[i][3], - depth_scale, - near, - far, - kik._FIXED_DEPTH_UNIFORM_WINDOW, - ), - jnp.log(depth_outlier_probs[i]) + jnp.log(1 / (far - near)), - ) - return color_pdf_should_be + depth_pdf_should_be - - def expected_logpdf(value): - return jnp.logaddexp( - jnp.log(1 / 2) + expected_logpdf_given_idx(value, 0), - jnp.log(1 / 2) + expected_logpdf_given_idx(value, 1), - ) - - samples_10 = jax.vmap(lambda k: kik.pixel_distribution.sample(k, *args))( - jax.random.split(jax.random.PRNGKey(0), 10) - ) - for sample in samples_10: - logpdf = kik.pixel_distribution.logpdf(sample, *args) - assert jnp.isclose(logpdf, expected_logpdf(sample), atol=1e-3) diff --git a/tests/dynamic_object_model/test_raycast_nondeterministic.py b/tests/dynamic_object_model/test_raycast_nondeterministic.py deleted file mode 100644 index 52bccb4b..00000000 --- a/tests/dynamic_object_model/test_raycast_nondeterministic.py +++ /dev/null @@ -1,71 +0,0 @@ -import importlib - -import b3d -import b3d.chisight.dynamic_object_model.likelihoods.kfold_image_kernel as kfk -import jax.numpy as jnp -from jax.random import PRNGKey, split - -importlib.reload(kfk) - - -def run_test(): - intrinsics = ( - 5, - 5, - 200.0, - 200.0, - 50.0, - 50.0, - 0.01, - 10.0, - ) - image_width, image_height, fx, fy, cx, cy, _, _ = intrinsics - - depth_image = jnp.ones((image_height, image_width), dtype=jnp.float32) - points = b3d.camera.camera_from_depth(depth_image, intrinsics).reshape(-1, 3) - - result = kfk.raycast_to_image_nondeterministic( - PRNGKey(0), - { - "height": image_height, - "width": image_width, - "fx": fx, - "fy": fy, - "cx": cx, - "cy": cy, - }, - points, - 2, - ) - assert jnp.all( - jnp.max(result, axis=2) - == jnp.arange(points.shape[0]).reshape(image_height, image_width) - ) - - # With 3x points per pixel, most of the time we'll register two of them. - # The probability of not registering 1 is 0.25. - # (This is the probability of the second and third point writing to the same - # slot as the first, which is 1/4.) - # Test that this seems to work out. - points_replicated_3x = jnp.tile(points, (3, 1)) - n_tests = 10 - keys = split(PRNGKey(0), n_tests) - total_num_misses = 0 - for key in keys: - result_x3 = kfk.raycast_to_image_nondeterministic( - key, - { - "height": image_height, - "width": image_width, - "fx": fx, - "fy": fy, - "cx": cx, - "cy": cy, - }, - points_replicated_3x, - 2, - ) - total_num_misses += jnp.sum(result_x3 == -1) - mean_num_misses = total_num_misses / n_tests - estimated_p_miss = mean_num_misses / (image_width * image_height) - assert jnp.allclose(estimated_p_miss, 0.25, atol=0.05) diff --git a/tests/dynamic_object_model/test_truncated_laplace.py b/tests/dynamic_object_model/test_truncated_laplace.py deleted file mode 100644 index 3c152680..00000000 --- a/tests/dynamic_object_model/test_truncated_laplace.py +++ /dev/null @@ -1,114 +0,0 @@ -import b3d.chisight.dynamic_object_model.likelihoods.kfold_image_kernel as kik -import jax -import jax.numpy as jnp - -# importlib.reload(kik) -# loc, scale, low, high, uniform_window_size = 0.0, 0.01, 0.0, 1.0, 0.1 -# n_grid_steps = 1000 -# x = jnp.linspace(low, high, n_grid_steps) -# stepsize = (high - low) / n_grid_steps -# logpdfs = jax.vmap( -# lambda x: kik.truncated_laplace.logpdf(x, loc, scale, low, high, uniform_window_size) -# )(x) -# pdfs = jnp.exp(logpdfs) -# jnp.sum(pdfs * stepsize) - - -def confirm_logpdf_looks_valid( - loc, scale, low, high, uniform_window_size, n_grid_steps=100000 -): - """ - Test that the pdf value seems to integrate to 1. - """ - x = jnp.linspace(low, high, n_grid_steps) - stepsize = (high - low) / n_grid_steps - logpdfs = jax.vmap( - lambda x: kik.truncated_laplace.logpdf( - x, loc, scale, low, high, uniform_window_size - ) - )(x) - pdfs = jnp.exp(logpdfs) - total_pmass = jnp.sum(pdfs * stepsize) - assert jnp.isclose(total_pmass, 1.0, atol=1e-3) - - -def ensure_laplace_samples_have_sufficient_spread( - key, loc, scale, low, high, uniform_window_size, scale_mult=0.1 -): - samples = jax.vmap( - lambda k: kik.truncated_laplace.sample( - k, loc, scale, low, high, uniform_window_size - ) - )(jax.random.split(key, 3)) - assert ( - jnp.abs(samples[0] - samples[1]) > scale * scale_mult - or jnp.abs(samples[0] - samples[2]) > scale * scale_mult - or jnp.abs(samples[1] - samples[2]) > scale * scale_mult - ) - - -def test_truncated_laplace(): - confirm_logpdf_looks_valid(0.5, 1.0, 0.0, 1.0, 0.1) - confirm_logpdf_looks_valid(1.0, 1.0, 0.0, 1.0, 0.1) - confirm_logpdf_looks_valid(0.0, 1.0, 0.0, 1.0, 0.1) - confirm_logpdf_looks_valid(0.5, 0.01, 0.0, 1.0, 0.1) - confirm_logpdf_looks_valid(0.0, 0.01, 0.0, 1.0, 0.1) - confirm_logpdf_looks_valid(1.0, 0.01, 0.0, 1.0, 0.1) - confirm_logpdf_looks_valid(0.99, 0.1, 0.0, 1.0, 0.2) - confirm_logpdf_looks_valid(0.01, 0.1, 0.0, 1.0, 0.2) - confirm_logpdf_looks_valid(1.99, 0.1, -1.0, 2.0, 0.2) - confirm_logpdf_looks_valid(-0.99, 0.1, -1.0, 2.0, 0.2) - confirm_logpdf_looks_valid(0.0, 5.0, -1.0, 2.0, 0.2) - - ensure_laplace_samples_have_sufficient_spread( - jax.random.PRNGKey(0), 0.5, 0.1, 0.0, 1.0, 0.1 - ) - - # TODO: the code below ehre could be cleaner. - # I think the functionality is right, though. - - key = jax.random.PRNGKey(1) - for j in range(5): - key, _ = jax.random.split(key) - x = kik.truncated_laplace.sample(key, 0.01, 0.01, 0.0, 1.0, 0.001) - assert 0.0 < x < 0.05 - - # test that the logpdf function puts almost all mass to the left - x = jnp.linspace(0.0, 1.0, int(1e6)) - stepsize = 1e-6 - logpdfs = jax.vmap( - lambda x: kik.truncated_laplace.logpdf(x, 0.01, 0.01, 0.0, 1.0, 0.001) - )(x) - pdfs = jnp.exp(logpdfs) - assert jnp.sum(pdfs[: int(1e6 * 0.05)] * stepsize) > 0.98 - - for j in range(5): - key, _ = jax.random.split(key) - x = kik.truncated_laplace.sample(key, -0.04, 0.01, 0.0, 1.0, 0.001) - assert 0.0 < x < 0.001 - - # test that the logpdf function also puts almost all mass to the left of 0.001 - x = jnp.linspace(0.0, 1.0, int(1e6)) - stepsize = 1e-6 - logpdfs = jax.vmap( - lambda x: kik.truncated_laplace.logpdf(x, -0.04, 0.01, 0.0, 1.0, 0.001) - )(x) - pdfs = jnp.exp(logpdfs) - assert jnp.sum(pdfs[: int(1e6 * 0.001)] * stepsize) > 0.98 - - -def test_color_truncated_logpdf(): - s1 = kik.truncated_color_laplace.sample( - jax.random.PRNGKey(0), jnp.array([1.0, 0.0, 0.5]), 0.2 - ) - keys = jax.random.split(jax.random.PRNGKey(0), 3) - r = kik.truncated_laplace.sample(keys[0], 1.0, 0.2, 0.0, 1.0, 1 / 255) - g = kik.truncated_laplace.sample(keys[1], 0.0, 0.2, 0.0, 1.0, 1 / 255) - b = kik.truncated_laplace.sample(keys[2], 0.5, 0.2, 0.0, 1.0, 1 / 255) - assert jnp.allclose(s1, jnp.array([r, g, b])) - - logpdf = kik.truncated_color_laplace.logpdf(s1, jnp.array([1.0, 0.0, 0.5]), 0.2) - logpdf_r = kik.truncated_laplace.logpdf(r, 1.0, 0.2, 0.0, 1.0, 1 / 255) - logpdf_g = kik.truncated_laplace.logpdf(g, 0.0, 0.2, 0.0, 1.0, 1 / 255) - logpdf_b = kik.truncated_laplace.logpdf(b, 0.5, 0.2, 0.0, 1.0, 1 / 255) - assert jnp.allclose(logpdf, logpdf_r + logpdf_g + logpdf_b) diff --git a/tests/gen3d/inference/test_depth_nonreturn_prob_inference.py b/tests/gen3d/inference/test_depth_nonreturn_prob_inference.py new file mode 100644 index 00000000..1137e60e --- /dev/null +++ b/tests/gen3d/inference/test_depth_nonreturn_prob_inference.py @@ -0,0 +1,32 @@ +# import b3d.chisight.gen3d.inference_moves as im +# import b3d.chisight.gen3d.transition_kernels as transition_kernels +# import jax +# import jax.numpy as jnp +# import jax.random as r +# from b3d.chisight.gen3d.pixel_kernels.pixel_depth_kernels import ( +# FullPixelDepthDistribution, +# ) + +# near, far = 0.001, 1.0 + +# dnrp_transition_kernel = transition_kernels.DiscreteFlipKernel( +# p_change_to_different_value=0.05, support=jnp.array([0.01, 0.99]) +# ) + + +# def propose_val(k): +# return im._propose_vertex_depth_nonreturn_prob( +# k, +# observed_depth=0.8, +# latent_depth=1.0, +# visibility_prob=1.0, +# depth_scale=0.00001, +# previous_dnrp=0.01, +# dnrp_transition_kernel=dnrp_transition_kernel, +# obs_depth_kernel=FullPixelDepthDistribution(near, far), +# ) + + +# values, log_qs, _ = jax.vmap(propose_val)(r.split(r.PRNGKey(0), 1000)) +# n_01 = jnp.sum((values == 0.01).astype(jnp.int32)) +# assert n_01 >= 950 diff --git a/tests/gen3d/inference/test_full_inference_alg.py b/tests/gen3d/inference/test_full_inference_alg.py new file mode 100644 index 00000000..3f0d901e --- /dev/null +++ b/tests/gen3d/inference/test_full_inference_alg.py @@ -0,0 +1,103 @@ +import b3d +import b3d.chisight.gen3d.inference.inference as inference +import b3d.chisight.gen3d.model +import b3d.chisight.gen3d.settings +import b3d.chisight.gen3d.settings as settings +import b3d.io.data_loader +import jax +import jax.numpy as jnp +from b3d.chisight.gen3d.dataloading import ( + get_initial_state, + load_object_given_scene, + load_scene, +) +from b3d.chisight.gen3d.model import ( + get_new_state, +) +from tqdm import tqdm + + +def test_inference_alg_runs_and_looks_ok(): + scene_id = 49 + FRAME_RATE = 50 + OBJECT_INDEX = 1 + + hyperparams = settings.hyperparams + inference_hyperparams = settings.inference_hyperparams + + all_data, meshes, renderer, intrinsics, _ = load_scene(scene_id, FRAME_RATE) + template_pose, model_vertices, model_colors = load_object_given_scene( + all_data, meshes, renderer, OBJECT_INDEX + ) + hyperparams["intrinsics"] = intrinsics + hyperparams["vertices"] = model_vertices + + initial_state = get_initial_state( + template_pose, model_vertices, model_colors, hyperparams + ) + + ### Test we can generate a trace ### + key = jax.random.PRNGKey(0) + og_trace, weight = inference.get_initial_trace( + key, hyperparams, initial_state, all_data[0]["rgbd"], get_weight=True + ) + assert ( + weight == og_trace.get_score() + ) # Test that all addresses are constrained in this trace generation + + ### Test one inference step ### + def gt_pose(T): + return ( + all_data[T]["camera_pose"].inv() @ all_data[T]["object_poses"][OBJECT_INDEX] + ) + + trace, _ = inference.inference_step( + jax.random.PRNGKey(26), + og_trace, + all_data[0]["rgbd"], + inference_hyperparams, + use_gt_pose=True, + gt_pose=gt_pose(0), + ) + + assert ( + jnp.linalg.norm(get_new_state(trace)["pose"].position - gt_pose(0).position) + < 0.004 + ) + + ### Run inference, giving the ground truth pose as a option in the pose proposal grid ### + trace = og_trace + key = jax.random.PRNGKey(21) + for T in tqdm(range(2)): + key = b3d.split_key(key) + trace, _ = inference.inference_step( + jax.random.PRNGKey(26), + trace, + all_data[T]["rgbd"], + inference_hyperparams, + use_gt_pose=True, + gt_pose=gt_pose(T), + ) + + assert ( + jnp.linalg.norm(get_new_state(trace)["pose"].position - gt_pose(T).position) + < 0.007 + ) + + ### Real inference run ### + key = jax.random.PRNGKey(123) + trace = og_trace + for T in tqdm(range(2)): + key = b3d.split_key(key) + trace, _ = inference.inference_step( + jax.random.PRNGKey(26), + trace, + all_data[T]["rgbd"], + inference_hyperparams, + use_gt_pose=False, + ) + + assert ( + jnp.linalg.norm(get_new_state(trace)["pose"].position - gt_pose(T).position) + < 0.02 + ) diff --git a/tests/gen3d/inference/test_point_attribute_inferences.py b/tests/gen3d/inference/test_point_attribute_inferences.py new file mode 100644 index 00000000..f0c629d5 --- /dev/null +++ b/tests/gen3d/inference/test_point_attribute_inferences.py @@ -0,0 +1,210 @@ +import b3d.chisight.gen3d.inference.point_attribute_proposals as point_attribute_proposals +import b3d.chisight.gen3d.settings +import jax +import jax.numpy as jnp +import pytest +from genjax import Pytree + + +@pytest.fixture +def hyperparams_and_inference_hyperparams(): + near, far, image_height, image_width = 0.001, 5.0, 480, 640 + intrinsics = { + "image_height": Pytree.const(image_height), + "image_width": Pytree.const(image_width), + "near": near, + "far": far, + } + + hyperparams = b3d.chisight.gen3d.settings.hyperparams + inference_hyperparams = b3d.chisight.gen3d.settings.inference_hyperparams + hyperparams["intrinsics"] = intrinsics + return hyperparams, inference_hyperparams + + +def test_visibility_prob_inference(hyperparams_and_inference_hyperparams): + hyperparams, inference_hyperparams = hyperparams_and_inference_hyperparams + + color_scale = 0.01 + depth_scale = 0.001 + + depth_nonreturn_prob_kernel = hyperparams["depth_nonreturn_prob_kernel"] + visibility_prob_kernel = hyperparams["visibility_prob_kernel"] + + previous_color = jnp.array([0.1, 0.2, 0.3]) + previous_dnrp = depth_nonreturn_prob_kernel.support[0] + + def get_visibility_prob_sample( + key, observed_rgbd_for_point, previous_visibility_prob + ): + sample, _ = point_attribute_proposals._propose_a_points_attributes( + key, + observed_rgbd_for_point, + jnp.array(1.0), # point depth + previous_color, + previous_visibility_prob, + previous_dnrp, + color_scale, + depth_scale, + hyperparams, + inference_hyperparams, + ) + return sample["visibility_prob"] + + get_visibility_prob_samples = jax.vmap( + get_visibility_prob_sample, in_axes=(0, None, None) + ) + + keys = jax.random.split(jax.random.PRNGKey(0), 1000) + + # Verify that when the color matches exactly but the depth change drasticaly, the visibility prob switches to low. + previous_visibility_prob = visibility_prob_kernel.support[-1] + observed_rgbd_for_this_vertex = jnp.array([0.1, 0.2, 0.35, 4.0]) + visibility_prob_samples = get_visibility_prob_samples( + keys, observed_rgbd_for_this_vertex, previous_visibility_prob + ) + assert visibility_prob_samples.mean() < 0.15 + + # Verify that when the color matches exactly but the depth change drasticaly, the visibility prob stays low. + previous_visibility_prob = visibility_prob_kernel.support[0] + observed_rgbd_for_this_vertex = jnp.array([0.1, 0.2, 0.3, 4.0]) + visibility_prob_samples = get_visibility_prob_samples( + keys, observed_rgbd_for_this_vertex, previous_visibility_prob + ) + assert visibility_prob_samples.mean() < 0.03 + + # Verify that when the color matches exactly and the depth is close, the visibility prob switches to being high. + previous_visibility_prob = visibility_prob_kernel.support[0] + observed_rgbd_for_this_vertex = jnp.array([0.1, 0.2, 0.3, 1.0]) + visibility_prob_samples = get_visibility_prob_samples( + keys, observed_rgbd_for_this_vertex, previous_visibility_prob + ) + assert visibility_prob_samples.mean() > 0.85 + + # Verify that when the color matches exactly and the depth is close, the visibility prob stays high. + previous_visibility_prob = visibility_prob_kernel.support[-1] + observed_rgbd_for_this_vertex = jnp.array([0.1, 0.2, 0.3, 1.0]) + visibility_prob_samples = get_visibility_prob_samples( + keys, observed_rgbd_for_this_vertex, previous_visibility_prob + ) + assert visibility_prob_samples.mean() > 0.97 + + +def test_depth_nonreturn_prob_inference(hyperparams_and_inference_hyperparams): + hyperparams, inference_hyperparams = hyperparams_and_inference_hyperparams + + color_scale = 0.01 + depth_scale = 0.001 + + depth_nonreturn_prob_kernel = hyperparams["depth_nonreturn_prob_kernel"] + visibility_prob_kernel = hyperparams["visibility_prob_kernel"] + + previous_color = jnp.array([0.1, 0.2, 0.3]) + previous_visibility_prob = visibility_prob_kernel.support[-1] + + def get_dnr_prob_sample(key, observed_rgbd_for_point, previous_dnrp): + sample, _ = point_attribute_proposals._propose_a_points_attributes( + key, + observed_rgbd_for_point, + jnp.array(1.0), + previous_color, + previous_visibility_prob, + previous_dnrp, + color_scale, + depth_scale, + hyperparams, + inference_hyperparams, + ) + return sample["depth_nonreturn_prob"] + + get_dnr_prob_samples = jax.vmap(get_dnr_prob_sample, in_axes=(0, None, None)) + + keys = jax.random.split(jax.random.PRNGKey(0), 1000) + + # If depth is nonreturn, the depth nonreturn prob should stay high. + previous_dnrp = depth_nonreturn_prob_kernel.support[-1] + observed_rgbd_for_this_vertex = jnp.array([0.1, 0.2, 0.3, 0.0]) + dnr_prob_samples = get_dnr_prob_samples( + keys, observed_rgbd_for_this_vertex, previous_dnrp + ) + assert dnr_prob_samples.mean() > 0.95 + + # If depth is nonreturn, the depth nonreturn prob should become high. + previous_dnrp = depth_nonreturn_prob_kernel.support[0] + observed_rgbd_for_this_vertex = jnp.array([0.1, 0.2, 0.3, 0.0]) + dnr_prob_samples = get_dnr_prob_samples( + keys, observed_rgbd_for_this_vertex, previous_dnrp + ) + assert dnr_prob_samples.mean() > 0.90 + + # If depth is valid, the depth nonreturn prob should become low. + previous_dnrp = depth_nonreturn_prob_kernel.support[-1] + observed_rgbd_for_this_vertex = jnp.array([0.1, 0.2, 0.3, 1.0]) + dnr_prob_samples = get_dnr_prob_samples( + keys, observed_rgbd_for_this_vertex, previous_dnrp + ) + assert dnr_prob_samples.mean() < 0.10 + + # If depth is valid, the depth nonreturn prob should stay low. + previous_dnrp = depth_nonreturn_prob_kernel.support[0] + observed_rgbd_for_this_vertex = jnp.array([0.1, 0.2, 0.3, 1.0]) + dnr_prob_samples = get_dnr_prob_samples( + keys, observed_rgbd_for_this_vertex, previous_dnrp + ) + assert dnr_prob_samples.mean() < 0.1 + + +def test_color_prob_inference(hyperparams_and_inference_hyperparams): + hyperparams, inference_hyperparams = hyperparams_and_inference_hyperparams + + color_scale = 0.01 + depth_scale = 0.001 + + depth_nonreturn_prob_kernel = hyperparams["depth_nonreturn_prob_kernel"] + visibility_prob_kernel = hyperparams["visibility_prob_kernel"] + + previous_visibility_prob = visibility_prob_kernel.support[-1] + previous_dnrp = depth_nonreturn_prob_kernel.support[0] + latent_depth = 1.0 + + def get_color_sample(key, observed_rgbd_for_point, previous_color): + sample, _ = point_attribute_proposals._propose_a_points_attributes( + key, + observed_rgbd_for_point, + jnp.array(latent_depth), + previous_color, + previous_visibility_prob, + previous_dnrp, + color_scale, + depth_scale, + hyperparams, + inference_hyperparams, + ) + return sample["colors"] + + get_color_samples = jax.vmap(get_color_sample, in_axes=(0, None, None)) + + keys = jax.random.split(jax.random.PRNGKey(0), 1000) + + # If depth match and colors match, the color should stay the same. + previous_color = jnp.array([0.1, 0.2, 0.3]) + observed_rgbd_for_this_vertex = jnp.array([0.1, 0.2, 0.3, latent_depth]) + color_samples = get_color_samples( + keys, observed_rgbd_for_this_vertex, previous_color + ) + assert jnp.max(jnp.abs(color_samples - previous_color)) < 0.02 + + # # If depths match and colors slightly change, then the color should move. + previous_color = jnp.array([0.15, 0.25, 0.35]) + observed_rgbd_for_this_vertex = jnp.array([0.1, 0.2, 0.3, latent_depth]) + color_samples = get_color_samples( + keys, observed_rgbd_for_this_vertex, previous_color + ) + assert ( + jnp.max( + jnp.abs( + jnp.median(color_samples, axis=0) - observed_rgbd_for_this_vertex[:3] + ) + ) + < 0.03 + ) diff --git a/tests/gen3d/test_evaluation_script.py b/tests/gen3d/test_evaluation_script.py new file mode 100644 index 00000000..f4c32fc6 --- /dev/null +++ b/tests/gen3d/test_evaluation_script.py @@ -0,0 +1,5 @@ +from src.b3d.chisight.gen3d.run_ycbv_evaluation import run_tracking + + +def test_run_tracking(): + run_tracking(scene=49, object=1, max_n_frames=5, subdir="test") diff --git a/tests/gen3d/test_metrics.py b/tests/gen3d/test_metrics.py new file mode 100644 index 00000000..ce30d1ee --- /dev/null +++ b/tests/gen3d/test_metrics.py @@ -0,0 +1,85 @@ +import b3d +import numpy as np +import pytest +from b3d.chisight.gen3d.metrics import ( + FP_RESULTS_ROOT_DIR, + add_err, + adds_err, + compute_auc, + foundation_pose_ycbv_result, +) + +TEST_FP_YCBV_RESULT_DIR = ( + FP_RESULTS_ROOT_DIR / "ycbv/2024-07-11-every-50-frames-gt-init" +) +ycb_dir = b3d.get_assets_path() / "bop/ycbv/test" + + +@pytest.mark.skipif( + not TEST_FP_YCBV_RESULT_DIR.exists(), + reason="No foundation pose tracking results found.", +) +def test_loading_precomputed_ycbv_results(): + precomputed_poses = foundation_pose_ycbv_result.load(test_scene_id=48, object_id=1) + assert precomputed_poses.shape == (45, 4, 4) + + test_scenes = foundation_pose_ycbv_result.get_scene_ids() + assert len(test_scenes) == 12 + + obj_ids_scene_48 = foundation_pose_ycbv_result.get_object_ids(test_scene_id=48) + assert len(obj_ids_scene_48) == 5 + + +@pytest.mark.parametrize("error_fn", [add_err, adds_err]) +def test_ground_truth_pose(error_fn): + pred_poses = gt_poses = np.random.rand(100, 4, 4) + vertices = np.random.rand(100, 3) + + all_errors = [] + for pred_pose, gt_pose in zip(pred_poses, gt_poses): + all_errors.append(error_fn(pred_pose, gt_pose, vertices)) + auc_score = compute_auc(all_errors) + + # error should be zero if pred_pose == gt_pose, and AUC should be 1 (highest) + assert np.allclose(all_errors, 0.0) + assert np.isclose(auc_score, 1.0) + + +@pytest.mark.skipif( + not TEST_FP_YCBV_RESULT_DIR.exists() or not ycb_dir.exists(), + reason="FoundationPose tracking result and YCBV dataset not found.", +) +def test_compute_metric(): + # example showing how the metric can be computed + test_scene = 49 + obj_id = 0 + framerate = 50 + num_scenes = b3d.io.data_loader.get_ycbv_num_images(test_scene, subdir="test") + image_ids = range(1, num_scenes + 1, framerate) + all_data = b3d.io.data_loader.get_ycbv_data(test_scene, image_ids, subdir="test") + + # get the gt mesh + obj_id_str = str(all_data[0]["object_types"][obj_id] + 1).rjust(6, "0") + print(obj_id_str) + mesh = b3d.Mesh.from_obj_file(ycb_dir / f"../models/obj_{obj_id_str}.ply").scale( + 0.001 + ) + + # load the foundation pose tracking results + fp_result = foundation_pose_ycbv_result.load( + test_scene_id=test_scene, object_id=obj_id + ) + + # start computing the error + all_adds_err = [] + for frame_data, pred_pose in zip(all_data, fp_result): + camera_pose = frame_data["camera_pose"] + obj_pose = frame_data["object_poses"][obj_id] + gt_pose = (camera_pose.inv() @ obj_pose).as_matrix() + all_adds_err.append(adds_err(pred_pose, gt_pose, mesh.vertices)) + + # Note that in many of the paper, the results are aggregated per-object + # (rather than per-scene) + auc = compute_auc(all_adds_err) + + assert auc > 0.5 diff --git a/tests/gen3d/test_model.py b/tests/gen3d/test_model.py new file mode 100644 index 00000000..f511fc34 --- /dev/null +++ b/tests/gen3d/test_model.py @@ -0,0 +1,153 @@ +### IMPORTS ### +import os + +import b3d +import b3d.chisight.gen3d.model +import b3d.chisight.gen3d.settings +import b3d.io.data_loader +import jax +import jax.numpy as jnp +from b3d import Mesh, Pose +from b3d.chisight.gen3d.model import ( + make_colors_choicemap, + make_depth_nonreturn_prob_choicemap, + make_visibility_prob_choicemap, +) +from genjax import ChoiceMapBuilder as C +from genjax import Pytree + +b3d.rr_init("test_gen3d_model") + + +def test_model(): + importance = b3d.chisight.gen3d.model.dynamic_object_generative_model.importance + + # num_vertices = 100 + # vertices = jax.random.uniform( + # jax.random.PRNGKey(0), (num_vertices, 3), minval=-1, maxval=1 + # ) + # colors = jax.random.uniform( + # jax.random.PRNGKey(1), (num_vertices, 3), minval=0, maxval=1 + # ) + + ycb_dir = os.path.join(b3d.get_assets_path(), "bop/ycbv") + id = 0 + mesh = Mesh.from_obj_file( + os.path.join(ycb_dir, f'models/obj_{f"{id + 1}".rjust(6, "0")}.ply') + ).scale(0.001) + vertices = mesh.vertices + colors = mesh.vertex_attributes + num_vertices = vertices.shape[0] + + key = jax.random.PRNGKey(0) + + hyperparams = b3d.chisight.gen3d.settings.hyperparams + + hyperparams["vertices"] = vertices + hyperparams["intrinsics"] = { + "image_height": Pytree.const(480), + "image_width": Pytree.const(640), + "fx": 1066.778, + "fy": 1067.487, + "cx": 312.9869, + "cy": 241.3109, + "near": 0.1, + "far": 10.0, + } + + previous_state = { + "pose": Pose.identity(), + "colors": colors, + "visibility_prob": jnp.ones(num_vertices) + * hyperparams["visibility_prob_kernel"].support[-1], + "depth_nonreturn_prob": jnp.ones(num_vertices) + * hyperparams["depth_nonreturn_prob_kernel"].support[0], + "depth_scale": hyperparams["depth_scale_kernel"].support[0], + "color_scale": hyperparams["color_scale_kernel"].support[0], + } + + key = jax.random.PRNGKey(0) + trace = importance(key, C.n(), (hyperparams, previous_state))[0] + trace = importance(key, C.n(), (hyperparams, previous_state))[0] + + key = jax.random.PRNGKey(0) + hyperparams, previous_state = trace.get_args() + + traces = [trace] + for t in range(10): + key = b3d.split_key(key) + previous_state = trace.get_retval()["new_state"] + trace, _ = importance(key, C.n(), (hyperparams, previous_state)) + b3d.chisight.gen3d.model.viz_trace(trace, t) + traces.append(trace) + + colors_over_time = jnp.array( + [trace.get_choices()["colors", ...] for trace in traces] + ) + + import matplotlib.pyplot as plt + + fig, ax = plt.subplots(4, 1, sharex=True, figsize=(10, 20)) + point_index = 0 + + fig.suptitle( + f""" +pose_kernel max_shift: FILL IN, +color_kernel scale: FILL IN, +visibility_prob_kernel p_change_to_different_value: {hyperparams['visibility_prob_kernel'].p_change_to_different_value}, +depth_nonreturn_prob_kernel p_change_to_different_value: {hyperparams['depth_nonreturn_prob_kernel'].p_change_to_different_value}, +depth_scale_kernel p_change_to_different_value: {hyperparams['depth_scale_kernel'].p_change_to_different_value}, +color_scale_kernel p_change_to_different_value: {hyperparams['color_scale_kernel'].p_change_to_different_value}""" + ) + ax[0].set_title(f"Color of vertex {point_index}") + ax[0].plot(colors_over_time[..., point_index, 0], color="r") + ax[0].plot(colors_over_time[..., point_index, 1], color="g") + ax[0].plot(colors_over_time[..., point_index, 2], color="b") + ax[0].set_ylim(-0.01, 1.01) + + first_n = 10 + ax[1].set_title("Visibility") + ax[1].plot( + [trace.get_choices()["visibility_prob", ...][:first_n] for trace in traces], + alpha=0.5, + ) + + ax[2].set_title("Depth Non Return") + ax[2].plot( + [ + trace.get_choices()["depth_nonreturn_prob", ...][:first_n] + for trace in traces + ], + alpha=0.5, + ) + + ax[3].set_title("Inlier Scale") + ax[3].plot([trace.get_choices()["depth_scale"] for trace in traces], label="depth") + ax[3].plot([trace.get_choices()["color_scale"] for trace in traces], label="color") + ax[3].legend() + fig.supxlabel("Time") + fig.savefig("test_gen3d_model.png") + + colors = trace.get_choices()["colors", ...] + new_colors = colors + 0.01 + new_colors_choicemap = make_colors_choicemap(new_colors) + new_trace = trace.update(key, new_colors_choicemap)[0] + assert jnp.allclose(new_trace.get_choices()["colors", ...], new_colors) + + visibility_prob = trace.get_choices()["visibility_prob", ...] + new_visibility_prob = visibility_prob + 0.01 + new_visibility_prob_choicemap = make_visibility_prob_choicemap(new_visibility_prob) + new_trace = trace.update(key, new_visibility_prob_choicemap)[0] + assert jnp.allclose( + new_trace.get_choices()["visibility_prob", ...], new_visibility_prob + ) + + depth_nonreturn_prob = trace.get_choices()["depth_nonreturn_prob", ...] + new_depth_nonreturn_prob = depth_nonreturn_prob + 0.01 + new_depth_nonreturn_prob_choicemap = make_depth_nonreturn_prob_choicemap( + new_depth_nonreturn_prob + ) + new_trace = trace.update(key, new_depth_nonreturn_prob_choicemap)[0] + assert jnp.allclose( + new_trace.get_choices()["depth_nonreturn_prob", ...], new_depth_nonreturn_prob + ) diff --git a/tests/gen3d/test_pixel_color_kernels.py b/tests/gen3d/test_pixel_color_kernels.py new file mode 100644 index 00000000..282d8f91 --- /dev/null +++ b/tests/gen3d/test_pixel_color_kernels.py @@ -0,0 +1,102 @@ +from functools import partial + +import jax +import jax.numpy as jnp +import pytest +from b3d.chisight.gen3d.pixel_kernels.pixel_color_kernels import ( + COLOR_MAX_VAL, + COLOR_MIN_VAL, + RenormalizedGaussianPixelColorDistribution, + RenormalizedLaplacePixelColorDistribution, + TruncatedLaplacePixelColorDistribution, + UniformPixelColorDistribution, +) +from genjax.typing import FloatArray + + +@partial(jax.jit, static_argnums=(0,)) +def generate_color_grid(n_grid_steps: int): + """Generate a grid of colors in very small interval to test that our logpdfs + sum to 1. Since enumerating all color combination in 3 channels is infeasible, + we take advantage of the fact that the channels are independent and only + grid over the first channel. + + Args: + n_grid_steps (int): The number of grid steps to generate + + Returns: + FloatArray: A grid of colors with shape (n_grid_steps, 3), where the first + channel is swept from 0 to 1 and the other two channels are fixed at 1. + """ + sweep_color_vals = jnp.linspace(COLOR_MIN_VAL, COLOR_MAX_VAL, n_grid_steps) + fixed_color_vals = jnp.ones(n_grid_steps) + return jnp.stack([sweep_color_vals, fixed_color_vals, fixed_color_vals], axis=-1) + + +sample_kernels_to_test = [ + (UniformPixelColorDistribution(), ()), + (TruncatedLaplacePixelColorDistribution(), (0.1,)), + (RenormalizedLaplacePixelColorDistribution(), (0.1,)), + (RenormalizedGaussianPixelColorDistribution(), (0.1,)), +] + + +@pytest.mark.parametrize("latent_color", [jnp.array([0.2, 0.5, 0.3]), jnp.zeros(3)]) +@pytest.mark.parametrize("kernel_spec", sample_kernels_to_test) +def test_logpdf_sum_to_1(kernel_spec, latent_color: FloatArray): + kernel, additional_args = kernel_spec + n_grid_steps = 10000000 + color_grid = generate_color_grid(n_grid_steps) + logpdf_per_channels = jax.vmap( + lambda color: kernel.logpdf_per_channel(color, latent_color, *additional_args) + )(color_grid) + log_pmass = jax.scipy.special.logsumexp(logpdf_per_channels[..., 0]) - jnp.log( + n_grid_steps + ) + assert jnp.isclose(log_pmass, 0.0, atol=1e-3) + + +@pytest.mark.parametrize( + "latent_color", [jnp.array([0.25, 0.87, 0.31]), jnp.zeros(3), jnp.ones(3)] +) +@pytest.mark.parametrize("kernel_spec", sample_kernels_to_test) +def test_sample_in_valid_color_range(kernel_spec, latent_color): + kernel, additional_args = kernel_spec + num_samples = 1000 + keys = jax.random.split(jax.random.PRNGKey(0), num_samples) + colors = jax.vmap(lambda key: kernel.sample(key, latent_color, *additional_args))( + keys + ) + assert colors.shape == (num_samples, 3) + assert jnp.all(colors >= 0) + assert jnp.all(colors <= 1) + + +# def test_relative_logpdf(): +# kernel = FullPixelColorDistribution() +# scale = 0.01 +# obs_color = jnp.array([0.0, 0.0, 1.0]) # a blue pixel + +# # case 1: no color hit the pixel +# latent_color = -jnp.ones(3) # use -1 to denote invalid pixel +# logpdf_1 = kernel.logpdf(obs_color, latent_color, scale, 0.8) +# logpdf_2 = kernel.logpdf(obs_color, latent_color, scale, 0.2) +# # the logpdf should be the same because the occluded probability is not used +# # in the case when no color hit the pixel +# assert jnp.allclose(logpdf_1, logpdf_2) + +# # case 2: a color hit the pixel, but the color is not close to the observed color +# latent_color = jnp.array([1.0, 0.5, 0.0]) +# logpdf_3 = kernel.logpdf(obs_color, latent_color, scale, 0.8) +# logpdf_4 = kernel.logpdf(obs_color, latent_color, scale, 0.2) +# # the pixel should be more likely to be an occluded +# assert logpdf_3 < logpdf_4 + +# # case 3: a color hit the pixel, and the color is close to the observed color +# latent_color = jnp.array([0.0, 0.0, 0.9]) +# logpdf_5 = kernel.logpdf(obs_color, latent_color, 0.01, 0.8) +# logpdf_6 = kernel.logpdf(obs_color, latent_color, scale, 0.2) +# # the pixel should be more likely to be an inlier +# assert logpdf_5 > logpdf_6 +# # the score of the pixel should be higher when the color is closer +# assert logpdf_5 > logpdf_3 diff --git a/tests/gen3d/test_pixel_depth_kernels.py b/tests/gen3d/test_pixel_depth_kernels.py new file mode 100644 index 00000000..ebf30144 --- /dev/null +++ b/tests/gen3d/test_pixel_depth_kernels.py @@ -0,0 +1,85 @@ +import jax +import jax.numpy as jnp +import pytest +from b3d.chisight.gen3d.pixel_kernels.pixel_depth_kernels import ( + RenormalizedGaussianPixelDepthDistribution, + RenormalizedLaplacePixelDepthDistribution, + TruncatedLaplacePixelDepthDistribution, + UniformPixelDepthDistribution, +) + +near = 0.01 +far = 20.0 + +# each kernel specs is a tuple of (kernel, additional_args) +sample_kernels_to_test = [ + (UniformPixelDepthDistribution(), (0.25, near, far)), + (TruncatedLaplacePixelDepthDistribution(), (0.25, near, far)), + (RenormalizedLaplacePixelDepthDistribution(), (0.25, near, far)), + (RenormalizedGaussianPixelDepthDistribution(), (0.25, near, far)), +] + + +@pytest.mark.parametrize("latent_depth", [0.2, 10.0]) +@pytest.mark.parametrize("kernel_spec", sample_kernels_to_test) +def test_logpdf_sum_to_1(kernel_spec, latent_depth: float): + kernel, additional_args = kernel_spec + # compute the mass in [near, far] + n_grid_steps = 10000000 + depth_grid = jnp.linspace(near, far, n_grid_steps) + logpdfs = jax.vmap( + lambda depth: kernel.logpdf(depth, latent_depth, *additional_args) + )(depth_grid) + log_pmass = ( + jax.scipy.special.logsumexp(logpdfs) + + jnp.log(far - near) + - jnp.log(n_grid_steps) + ) + assert jnp.isclose(log_pmass, 0.0, atol=1e-3) + + +@pytest.mark.parametrize("latent_depth", [0.2, 10.0, 19.9]) +@pytest.mark.parametrize("kernel_spec", sample_kernels_to_test) +def test_sample_in_valid_depth_range(kernel_spec, latent_depth): + kernel, additional_args = kernel_spec + num_samples = 1000 + keys = jax.random.split(jax.random.PRNGKey(0), num_samples) + depths = jax.vmap(lambda key: kernel.sample(key, latent_depth, *additional_args))( + keys + ) + assert depths.shape == (num_samples,) + assert jnp.all((depths >= near)) + assert jnp.all((depths <= far)) + + +# def test_relative_logpdf(): +# kernel = FullPixelDepthDistribution(near, far) +# scale = 0.1 + +# # case 1: depth is missing in observation (nonreturn) +# obs_depth = DEPTH_NONRETURN_VAL +# latent_depth = DEPTH_NONRETURN_VAL +# depth_nonreturn_prob = 0.2 +# logpdf_1 = kernel.logpdf(obs_depth, latent_depth, scale, 0.8, depth_nonreturn_prob) +# assert logpdf_1 == jnp.log(depth_nonreturn_prob) + +# latent_depth = -1.0 # no depth information from latent +# logpdf_2 = kernel.logpdf(obs_depth, latent_depth, scale, 0.8, depth_nonreturn_prob) +# # nonreturn obs cannot be generates from latent that is not nonreturn +# assert logpdf_2 == jnp.log(UNEXPLAINED_DEPTH_NONRETURN_PROB) + +# # case 2: valid depth is observed, but latent depth is far from the observed depth +# obs_depth = 10.0 +# latent_depth = 0.01 +# logpdf_3 = kernel.logpdf(obs_depth, latent_depth, scale, 0.1, depth_nonreturn_prob) +# logpdf_4 = kernel.logpdf(obs_depth, latent_depth, scale, 0.9, depth_nonreturn_prob) +# # the pixel should be more likely to be an occluded +# assert logpdf_3 > logpdf_4 + +# # case 3: valid depth is observed, but latent depth is close from the observed depth +# obs_depth = 6.0 +# latent_depth = 6.01 +# logpdf_5 = kernel.logpdf(obs_depth, latent_depth, scale, 0.1, depth_nonreturn_prob) +# logpdf_6 = kernel.logpdf(obs_depth, latent_depth, scale, 0.9, depth_nonreturn_prob) +# # the pixel should be more likely to be an inliner +# assert logpdf_5 < logpdf_6 diff --git a/tests/gen3d/test_pixel_rgbd_kernels.py b/tests/gen3d/test_pixel_rgbd_kernels.py new file mode 100644 index 00000000..4ee30e15 --- /dev/null +++ b/tests/gen3d/test_pixel_rgbd_kernels.py @@ -0,0 +1,318 @@ +import jax +import jax.numpy as jnp +import pytest +from b3d.chisight.gen3d.pixel_kernels.pixel_color_kernels import ( + TruncatedLaplacePixelColorDistribution, + UniformPixelColorDistribution, +) +from b3d.chisight.gen3d.pixel_kernels.pixel_depth_kernels import ( + DEPTH_NONRETURN_VAL, + TruncatedLaplacePixelDepthDistribution, + UniformPixelDepthDistribution, +) +from b3d.chisight.gen3d.pixel_kernels.pixel_rgbd_kernels import ( + FullPixelRGBDDistribution, +) +from genjax import Pytree + +near = 0.01 +far = 20.0 + +intrinsics = { + "image_height": Pytree.const(480), + "image_width": Pytree.const(640), + "fx": 1066.778, + "fy": 1067.487, + "cx": 312.9869, + "cy": 241.3109, + "near": near, + "far": far, +} + +sample_kernels_to_test = [ + ( + FullPixelRGBDDistribution( + TruncatedLaplacePixelColorDistribution(), + UniformPixelColorDistribution(), + TruncatedLaplacePixelDepthDistribution(), + UniformPixelDepthDistribution(), + ), + ( + 0.01, # color_scale + 0.01, # depth_scale + 1 - 0.3, # visibility_prob + 0.1, # depth_nonreturn_prob + intrinsics, + 0.02, # depth nonreturn prob for non-registered point + ), + ) +] + + +@pytest.mark.parametrize( + "latent_rgbd", + [ + jnp.array([0.25, 0.87, 0.31, 10.0]), + jnp.array([0.0, 0.0, 0.0, 0.02]), + jnp.array([1.0, 1.0, 1.0, 19.9]), + ], +) +@pytest.mark.parametrize("kernel_spec", sample_kernels_to_test) +def test_sample_in_valid_rgbd_range(kernel_spec, latent_rgbd): + kernel, additional_args = kernel_spec + num_samples = 1000 + keys = jax.random.split(jax.random.PRNGKey(0), num_samples) + rgbds = jax.vmap(lambda key: kernel.sample(key, latent_rgbd, *additional_args))( + keys + ) + assert rgbds.shape == (num_samples, 4) + assert jnp.all(rgbds[..., :3] > 0) + assert jnp.all(rgbds[..., :3] < 1) + assert jnp.all((rgbds[..., 3] > near) | (rgbds[..., 3] == DEPTH_NONRETURN_VAL)) + assert jnp.all((rgbds[..., 3] < far) | (rgbds[..., 3] == DEPTH_NONRETURN_VAL)) + + +@pytest.mark.parametrize("kernel_spec", sample_kernels_to_test) +def test_relative_logpdf(kernel_spec): + kernel, _ = kernel_spec + obs_rgbd = jnp.array([0.0, 0.0, 1.0, 0.02]) # a blue pixel + + # case 1: no vertex hit the pixel + latent_rgbd = -jnp.ones(4) # use -1 to denote invalid pixel + logpdf_1 = kernel.logpdf( + obs_rgbd, + latent_rgbd, + 0.01, + 0.01, + visibility_prob=0.8, + depth_nonreturn_prob=0.1, + intrinsics=intrinsics, + invisible_depth_nonreturn_prob=0.02, + ) + logpdf_2 = kernel.logpdf( + obs_rgbd, + latent_rgbd, + 0.01, + 0.01, + visibility_prob=0.2, + depth_nonreturn_prob=0.1, + intrinsics=intrinsics, + invisible_depth_nonreturn_prob=0.02, + ) + # the logpdf should be the same because the occluded probability is not used + # in the case when no vertex hit the pixel + assert jnp.allclose(logpdf_1, logpdf_2) + + # case 2: a vertex hit the pixel, but the rgbd is not close to the observed rgbd + latent_rgbd = jnp.array([1.0, 0.5, 0.0, 12.0]) + logpdf_3 = kernel.logpdf( + obs_rgbd, + latent_rgbd, + 0.01, + 0.01, + visibility_prob=0.8, + depth_nonreturn_prob=0.1, + intrinsics=intrinsics, + invisible_depth_nonreturn_prob=0.02, + ) + logpdf_4 = kernel.logpdf( + obs_rgbd, + latent_rgbd, + 0.01, + 0.01, + visibility_prob=0.2, + depth_nonreturn_prob=0.1, + intrinsics=intrinsics, + invisible_depth_nonreturn_prob=0.02, + ) + # the pixel should be more likely to be an occluded + assert logpdf_3 < logpdf_4 + + # case 3: a vertex hit the pixel, and the rgbd is close to the observed rgbd + latent_rgbd = jnp.array([0.0, 0.0, 0.95, 0.022]) + logpdf_5 = kernel.logpdf( + obs_rgbd, + latent_rgbd, + 0.01, + 0.01, + visibility_prob=0.8, + depth_nonreturn_prob=0.1, + intrinsics=intrinsics, + invisible_depth_nonreturn_prob=0.02, + ) + logpdf_6 = kernel.logpdf( + obs_rgbd, + latent_rgbd, + 0.01, + 0.01, + visibility_prob=0.2, + depth_nonreturn_prob=0.1, + intrinsics=intrinsics, + invisible_depth_nonreturn_prob=0.02, + ) + # the pixel should be more likely to be an inlier + assert logpdf_5 > logpdf_6 + # the score of the pixel should be higher when the rgbd is closer + assert logpdf_5 > logpdf_3 + + +@pytest.mark.parametrize("kernel_spec", sample_kernels_to_test) +def test_invalid_pixel(kernel_spec): + kernel, additional_args = kernel_spec + + # Latent value of [-1, -1, -1, -1] indicates no point hits here. + latent_rgbd = -jnp.ones(4) + logpdf_1 = kernel.logpdf( + jnp.array([1.0, 0.5, 0.2, 4.0]), latent_rgbd, *additional_args + ) + logpdf_2 = kernel.logpdf( + jnp.array([0.0, 0.0, 0.0, 0.02]), latent_rgbd, *additional_args + ) + # the observation does not affect the logpdf + assert logpdf_1 == logpdf_2 + + logpdf_3 = kernel.logpdf( + jnp.array([1.0, 0.5, 0.2, 4.0]), + latent_rgbd, + 0.1, + 0.4, + 0.2, + 0.1, + intrinsics, + 0.02, + ) + logpdf_4 = kernel.logpdf( + jnp.array([0.0, 0.0, 0.0, 0.02]), + latent_rgbd, + 0.3, + 0.5, + 0.4, + 0.2, + intrinsics, + 0.02, + ) + # and the values of the parameters doesn't matter either + assert logpdf_2 == logpdf_3 + assert logpdf_3 == logpdf_4 + + # IMPORTANT: note that, by designed, every pixel should have a valid color, + # and an observation of [-1, -1, -1, -1] is actually not within the support + # of the pixel distribution. + logpdf_5 = kernel.logpdf( + jnp.array([-1.0, -1.0, -1.0, -1.0]), latent_rgbd, *additional_args + ) + assert logpdf_5 == -jnp.inf + + +def test_nonreturn_prob_works(): + kernel = FullPixelRGBDDistribution( + TruncatedLaplacePixelColorDistribution(), + UniformPixelColorDistribution(), + TruncatedLaplacePixelDepthDistribution(), + UniformPixelDepthDistribution(), + ) + + # visible, DNRprob = 1.0 + assert ( + kernel.logpdf( + jnp.array([1.0, 0.5, 0.2, 4.0]), + jnp.array([1.0, 0.5, 0.5, 4.0]), + 0.1, + 0.4, + 1.0, # visibility prob + 1.0, # depth nonreturn prob for visible + intrinsics, + 0.02, # depth nonreturn prob for invisible + ) + == -jnp.inf + ) + assert not jnp.isinf( + kernel.logpdf( + jnp.array([1.0, 0.5, 0.2, 0.0]), + jnp.array([1.0, 0.5, 0.5, 4.0]), + 0.1, + 0.4, + 1.0, # visibility prob + 1.0, # depth nonreturn prob for visible + intrinsics, + 0.02, # depth nonreturn prob for invisible + ) + ) + assert not jnp.isinf( + kernel.logpdf( + jnp.array([1.0, 0.5, 0.2, 4.0]), + jnp.array([1.0, 0.5, 0.5, 4.0]), + 0.1, + 0.4, + 0.5, # visibility prob + 1.0, # depth nonreturn prob for visible + intrinsics, + 0.02, # depth nonreturn prob for invisible + ) + ) + + # invisible, DNRprobVisible = 1.0, DNRprobInvisible < 1 + assert not jnp.isinf( + kernel.logpdf( + jnp.array([1.0, 0.5, 0.2, 4.0]), + jnp.array([1.0, 0.5, 0.5, 4.0]), + 0.1, + 0.4, + 0.0, # visibility prob + 1.0, # depth nonreturn prob for visible + intrinsics, + 0.02, # depth nonreturn prob for invisible + ) + ) + assert not jnp.isinf( + kernel.logpdf( + jnp.array([1.0, 0.5, 0.2, 0.0]), + jnp.array([1.0, 0.5, 0.5, 4.0]), + 0.1, + 0.4, + 0.0, # visibility prob + 1.0, # depth nonreturn prob for visible + intrinsics, + 0.02, # depth nonreturn prob for invisible + ) + ) + + # invisible, DNRprobVisible < 1.0, DNRprobInvisible = 1.0 + assert jnp.isinf( + kernel.logpdf( + jnp.array([1.0, 0.5, 0.2, 4.0]), + jnp.array([1.0, 0.5, 0.5, 4.0]), + 0.1, + 0.4, + 0.0, # visibility prob + 0.0, # depth nonreturn prob for visible + intrinsics, + 1.0, # depth nonreturn prob for invisible + ) + ) + + # invalid point + assert jnp.isinf( + kernel.logpdf( + jnp.array([1.0, 0.5, 0.2, 4.0]), + -jnp.ones(4), + 0.1, + 0.4, + 0.5, # visibility prob + 0.5, # depth nonreturn prob for visible + intrinsics, + 1.0, # depth nonreturn prob for invisible + ) + ) + assert not jnp.isinf( + kernel.logpdf( + jnp.array([1.0, 0.5, 0.2, 4.0]), + -jnp.ones(4), + 0.1, + 0.4, + 0.5, # visibility prob + 0.0, # depth nonreturn prob for visible + intrinsics, + 0.05, # depth nonreturn prob for invisible + ) + ) diff --git a/tests/gen3d/test_posegrid_util.py b/tests/gen3d/test_posegrid_util.py new file mode 100644 index 00000000..6fd4f181 --- /dev/null +++ b/tests/gen3d/test_posegrid_util.py @@ -0,0 +1,129 @@ +import jax +import jax.numpy as jnp +from b3d import Pose +from b3d.pose.grid import pose_grid, viz_from_grid + + +def test_pose_gridding(): + ################################# + # Setup test + ################################# + VIZ_TEST = False # toggle to visualize all grid on rerun + + # center pose + xyz0 = jnp.array([0.0, 0.0, 0.0]) + rot0 = jnp.array([0.0, 0.0, 0.0, 1.0]) + pose0 = Pose(xyz0, rot0) + + # translation grid + half_nx = half_ny = half_nz = 2 + ntr = (2 * half_nx + 1) * (2 * half_ny + 1) * (2 * half_nz + 1) + print(f"Generating {ntr} translations") + half_dx, half_dy, half_dz = 1, 1, 0.001 + + # rotation grid + half_n_alpha = half_n_beta = half_n_gamma = 2 + half_d_euler = jnp.pi / 3 + nrot = (2 * half_n_alpha + 1) * (2 * half_n_beta + 1) * (2 * half_n_gamma + 1) + print(f"Generating {nrot} rotations") + + ################################## + # Generate pose grid + ################################## + + pose_grid_jit = jax.jit( + pose_grid, + static_argnames=( + "half_nx", + "half_ny", + "half_nz", + "half_n_xrot", + "half_n_yrot", + "half_n_zrot", + ), + ) + grid = pose_grid_jit( + pose0, + half_dx=half_dx, + half_dy=half_dy, + half_dz=half_dz, + half_nx=half_nx, + half_ny=half_ny, + half_nz=half_nz, + half_dangle=half_d_euler, + half_n_xrot=half_n_alpha, + half_n_yrot=half_n_beta, + half_n_zrot=half_n_gamma, + ) + + ################################## + # Test correctness + ################################## + # 1a. sanity check sizes + assert isinstance( + grid, Pose + ), f"Wrong return type; expected b3d.Pose, got {type(grid)}" + assert grid.pos.shape == ( + ntr * nrot, + 3, + ), f"Wrong shape for pos; expected {(ntr * nrot, 3)}, got {grid.pos.shape}" + assert grid.quaternion.shape == ( + ntr * nrot, + 4, + ), f"Wrong shape for quat; expected {(ntr * nrot, 4)}, got {grid.quaternion.shape}" + + # 1b. check that original pose is in grid + assert ( + grid.pos.tolist().index(pose0.pos.tolist()) + == grid.quat.tolist().index(pose0.quat.tolist()) + != -1 + ), "Center pose not in grid" + print("Size checks and center-pose checks passed") + + # 2. visualize grid + if VIZ_TEST: + print(f"Visualizing {ntr*nrot} poses in rerun...") + viz_from_grid(grid, rerun_session_name=f"GRID_{ntr}_{nrot}", ycb_obj_id=13) + else: + print("Skipping visualization...") + + # 3. Test that a 1-pose grid is just the starting point + pose_from_grid = pose_grid_jit( + pose0, + half_dx=half_dx, + half_dy=half_dy, + half_dz=half_dz, + half_nx=0, + half_ny=0, + half_nz=0, + half_dangle=half_d_euler, + half_n_xrot=0, + half_n_yrot=0, + half_n_zrot=0, + )[0] + assert jnp.allclose(pose_from_grid.position, pose0.position) and jnp.allclose( + pose_from_grid.quaternion, pose0.quaternion + ), "Single-pose grid not equal to original pose" + + # ################################## + # # Test time + # ################################## + import time + + print("Testing jitted runtime...") + start = time.time() + _ = pose_grid_jit( + pose0, + half_dx=half_dx, + half_dy=half_dy, + half_dz=half_dz, + half_nx=half_nx, + half_ny=half_ny, + half_nz=half_nz, + half_dangle=half_d_euler, + half_n_xrot=half_n_alpha, + half_n_yrot=half_n_beta, + half_n_zrot=half_n_gamma, + ) + end = time.time() + print(f"Time taken: {(end-start)*1000} milliseconds for {ntr*nrot} poses") diff --git a/tests/gen3d/test_transition_kernels.py b/tests/gen3d/test_transition_kernels.py new file mode 100644 index 00000000..5bed2c69 --- /dev/null +++ b/tests/gen3d/test_transition_kernels.py @@ -0,0 +1,41 @@ +### IMPORTS ### + +import b3d.chisight.gen3d.transition_kernels as transition_kernels +import jax.numpy as jnp +import jax.random as r + + +def test_discrete_flip_kernel(): + num_values = 10 + possible_values = jnp.linspace(0, 1, num_values) + flip_probability = 0.1 + kernel = transition_kernels.DiscreteFlipKernel( + p_change_to_different_value=flip_probability, support=possible_values + ) + + assert jnp.isclose( + kernel.logpdf(possible_values[0], possible_values[0]), + jnp.log(1 - flip_probability), + ) + assert jnp.isclose( + kernel.logpdf(possible_values[0], possible_values[-1]), + jnp.log(flip_probability / (num_values - 1)), + ) + + possible_values = jnp.array([0.01]) + flip_probability = 0.1 + kernel = transition_kernels.DiscreteFlipKernel( + p_change_to_different_value=flip_probability, support=possible_values + ) + assert jnp.isclose( + kernel.logpdf(possible_values[0], possible_values[0]), jnp.log(1.0) + ) + assert kernel.sample(r.PRNGKey(0), 0.01) == 0.01 + + possible_values = jnp.array([0.01, 1.0]) + flip_probability = 0.1 + kernel = transition_kernels.DiscreteFlipKernel( + p_change_to_different_value=flip_probability, support=possible_values + ) + assert jnp.isclose(kernel.logpdf(0.01, 0.01), jnp.log(0.9)) + assert jnp.isclose(kernel.logpdf(1.0, 0.01), jnp.log(0.1)) diff --git a/tests/gen3d/test_uniform_posteriors.py b/tests/gen3d/test_uniform_posteriors.py new file mode 100644 index 00000000..9d214e88 --- /dev/null +++ b/tests/gen3d/test_uniform_posteriors.py @@ -0,0 +1,66 @@ +import b3d.chisight.gen3d.uniform_distributions as ud +import jax +import jax.numpy as jnp + + +def get_grid_posterior_approximation(prior, obsmodel, obs): + tight_grid_latent = jnp.linspace(0.0, 1.0, 1000001) + enum_posterior_pdf_tight = ud._get_enum_posterior_pdf( + prior, obsmodel, obs, tight_grid_latent + ) + subsampled_values = tight_grid_latent[::1000] + subsampled_pdfs = enum_posterior_pdf_tight[::1000] + return subsampled_values, subsampled_pdfs + + +def test_uniform_posteriors_are_computed_correctly(): + prior = ud.Uniform(0.3, 0.7) + obsmodel = ud.NiceTruncatedCenteredUniform(0.05, 0.0, 1.0) + for obs in [0.29, 0.3, 0.35, 0.67, 0.9]: + obs = 0.29 + values, grid_pdfs = get_grid_posterior_approximation(prior, obsmodel, obs) + exact_pdfs = jax.vmap( + lambda lat: jnp.exp( + ud.get_posterior_for_uniform_prior_ntcu_obs( + prior, obsmodel, obs + ).logpdf(lat) + ) + )(values) + + # Due to floating point error, it's hard to get the pdf exactly + # at the boundaries of the uniform distribution right. + # Hence, we may have a few points where the pdfs are off by a bit. + # But at all points not near the boundary, the pdfs should be very close. + # TODO: does this indicate that we should actually be using distributions + # that do something more stochastic when very close to the boundaries? + n_fail = jnp.sum(jnp.abs(grid_pdfs - exact_pdfs) > 1e-3) + assert n_fail < 4 + + prior = ud.MixtureOfUniforms( + jnp.array([0.7, 0.25, 0.05]), + ud.Uniform(jnp.array([0.1, 0.4, 0.49]), jnp.array([0.9, 0.6, 0.51])), + ) + obsmodel = ud.MixtureOfNiceTruncatedCenteredUniforms( + jnp.array([0.3, 0.7]), + ud.NiceTruncatedCenteredUniform( + jnp.array([0.1, 0.02]), jnp.zeros(2), jnp.ones(2) + ), + ) + for obs in [0.29, 0.3, 0.35, 0.67, 0.9]: + obs = 0.3 + values, grid_pdfs = get_grid_posterior_approximation(prior, obsmodel, obs) + exact_pdfs = jax.vmap( + lambda lat: jnp.exp( + ud.get_posterior_from_mix_of_uniform_prior_and_mix_of_nctus_obs( + prior, obsmodel, obs + ).logpdf(lat) + ) + )(values) + # Due to floating point error, it's hard to get the pdf exactly + # at the boundaries of the uniform distribution right. + # Hence, we may have a few points where the pdfs are off by a bit. + # But at all points not near the boundary, the pdfs should be very close. + # TODO: does this indicate that we should actually be using distributions + # that do something more stochastic when very close to the boundaries? + n_fail = jnp.sum(jnp.abs(grid_pdfs - exact_pdfs) > 1e-3) + assert n_fail < 4 diff --git a/tests/test_chisight_dense_gps.py b/tests/test_chisight_dense_gps.py index 1274442c..418404b5 100644 --- a/tests/test_chisight_dense_gps.py +++ b/tests/test_chisight_dense_gps.py @@ -53,8 +53,8 @@ def cube_mesh_with_size_and_color(size, color): return mesh meshes = jax.vmap(cube_mesh_with_size_and_color)( - jnp.ones((num_particles.const, 3)) * jnp.array([[0.1, 0.1, 0.01]]), - jax.random.uniform(key, (num_particles.const, 3)), + jnp.ones((num_particles.unwrap(), 3)) * jnp.array([[0.1, 0.1, 0.01]]), + jax.random.uniform(key, (num_particles.unwrap(), 3)), ) likelihood = make_krays_image_observation_model(renderer) diff --git a/tests/test_modeling_utils.py b/tests/test_modeling_utils.py new file mode 100644 index 00000000..1dfb3387 --- /dev/null +++ b/tests/test_modeling_utils.py @@ -0,0 +1,186 @@ +import genjax +import jax +import jax.numpy as jnp +from b3d.modeling_utils import ( + PythonMixtureDistribution, + renormalized_laplace, + truncated_color_laplace, + truncated_laplace, +) + +### Truncated Laplace tests ### + + +def confirm_logpdf_looks_valid( + loc, scale, low, high, uniform_window_size, n_grid_steps=100000 +): + """ + Test that the pdf value seems to integrate to 1. + """ + x = jnp.linspace(low, high, n_grid_steps) + stepsize = (high - low) / n_grid_steps + logpdfs = jax.vmap( + lambda x: truncated_laplace.logpdf( + x, loc, scale, low, high, uniform_window_size + ) + )(x) + pdfs = jnp.exp(logpdfs) + total_pmass = jnp.sum(pdfs * stepsize) + assert jnp.isclose(total_pmass, 1.0, atol=1e-3) + + logpdfs = jax.vmap(lambda x: renormalized_laplace.logpdf(x, loc, scale, low, high))( + x + ) + pdfs = jnp.exp(logpdfs) + total_pmass = jnp.sum(pdfs * stepsize) + assert jnp.isclose(total_pmass, 1.0, atol=1e-3) + + +def ensure_laplace_samples_have_sufficient_spread( + key, loc, scale, low, high, uniform_window_size, scale_mult=0.1 +): + samples = jax.vmap( + lambda k: truncated_laplace.sample( + k, loc, scale, low, high, uniform_window_size + ) + )(jax.random.split(key, 3)) + assert ( + jnp.abs(samples[0] - samples[1]) > scale * scale_mult + or jnp.abs(samples[0] - samples[2]) > scale * scale_mult + or jnp.abs(samples[1] - samples[2]) > scale * scale_mult + ) + + samples = jax.vmap(lambda k: renormalized_laplace.sample(k, loc, scale, low, high))( + jax.random.split(key, 3) + ) + assert ( + jnp.abs(samples[0] - samples[1]) > scale * scale_mult + or jnp.abs(samples[0] - samples[2]) > scale * scale_mult + or jnp.abs(samples[1] - samples[2]) > scale * scale_mult + ) + + +def test_truncated_laplace_and_renormalized_laplace(): + confirm_logpdf_looks_valid(0.5, 1.0, 0.0, 1.0, 0.1) + confirm_logpdf_looks_valid(1.0, 1.0, 0.0, 1.0, 0.1) + confirm_logpdf_looks_valid(0.0, 1.0, 0.0, 1.0, 0.1) + confirm_logpdf_looks_valid(0.5, 0.01, 0.0, 1.0, 0.1) + confirm_logpdf_looks_valid(0.0, 0.01, 0.0, 1.0, 0.1) + confirm_logpdf_looks_valid(1.0, 0.01, 0.0, 1.0, 0.1) + confirm_logpdf_looks_valid(0.99, 0.1, 0.0, 1.0, 0.2) + confirm_logpdf_looks_valid(0.01, 0.1, 0.0, 1.0, 0.2) + confirm_logpdf_looks_valid(1.99, 0.1, -1.0, 2.0, 0.2) + confirm_logpdf_looks_valid(-0.99, 0.1, -1.0, 2.0, 0.2) + confirm_logpdf_looks_valid(0.0, 5.0, -1.0, 2.0, 0.2) + + ensure_laplace_samples_have_sufficient_spread( + jax.random.PRNGKey(0), 0.5, 0.1, 0.0, 1.0, 0.1 + ) + + # TODO: the code below ehre could be cleaner. + # I think the functionality is right, though. + + key = jax.random.PRNGKey(1) + for j in range(5): + key, _ = jax.random.split(key) + x = truncated_laplace.sample(key, 0.01, 0.01, 0.0, 1.0, 0.001) + assert 0.0 < x < 0.05 + + # test that the logpdf function puts almost all mass to the left + x = jnp.linspace(0.0, 1.0, int(1e6)) + stepsize = 1e-6 + logpdfs = jax.vmap( + lambda x: truncated_laplace.logpdf(x, 0.01, 0.01, 0.0, 1.0, 0.001) + )(x) + pdfs = jnp.exp(logpdfs) + assert jnp.sum(pdfs[: int(1e6 * 0.05)] * stepsize) > 0.98 + + for j in range(5): + key, _ = jax.random.split(key) + x = truncated_laplace.sample(key, -0.04, 0.01, 0.0, 1.0, 0.001) + assert 0.0 < x < 0.001 + + # test that the logpdf function also puts almost all mass to the left of 0.001 + x = jnp.linspace(0.0, 1.0, int(1e6)) + stepsize = 1e-6 + logpdfs = jax.vmap( + lambda x: truncated_laplace.logpdf(x, -0.04, 0.01, 0.0, 1.0, 0.001) + )(x) + pdfs = jnp.exp(logpdfs) + assert jnp.sum(pdfs[: int(1e6 * 0.001)] * stepsize) > 0.98 + + +def test_color_truncated_logpdf(): + s1 = truncated_color_laplace.sample( + jax.random.PRNGKey(0), jnp.array([1.0, 0.0, 0.5]), 0.2 + ) + keys = jax.random.split(jax.random.PRNGKey(0), 3) + r = truncated_laplace.sample(keys[0], 1.0, 0.2, 0.0, 1.0, 1 / 255) + g = truncated_laplace.sample(keys[1], 0.0, 0.2, 0.0, 1.0, 1 / 255) + b = truncated_laplace.sample(keys[2], 0.5, 0.2, 0.0, 1.0, 1 / 255) + assert jnp.allclose(s1, jnp.array([r, g, b])) + + logpdf = truncated_color_laplace.logpdf(s1, jnp.array([1.0, 0.0, 0.5]), 0.2) + logpdf_r = truncated_laplace.logpdf(r, 1.0, 0.2, 0.0, 1.0, 1 / 255) + logpdf_g = truncated_laplace.logpdf(g, 0.0, 0.2, 0.0, 1.0, 1 / 255) + logpdf_b = truncated_laplace.logpdf(b, 0.5, 0.2, 0.0, 1.0, 1 / 255) + assert jnp.allclose(logpdf, logpdf_r + logpdf_g + logpdf_b) + + +### Test Python mixture distribtion ### + + +def test_python_mixture_distribution(): + dist = PythonMixtureDistribution([genjax.uniform, genjax.normal]) + unif_args = (0.0, 1.0) + normal_args = (1000.0, 10.0) + + # Test sampling # + key = jax.random.PRNGKey(0) + + dist.sample(key, jnp.array([0.1, 0.9]), [unif_args, normal_args]) + + def sample_val(key, p_unif): + return dist.sample( + key, jnp.array([p_unif, 1 - p_unif]), [unif_args, normal_args] + ) + + vals_near_0 = jax.vmap(sample_val, in_axes=(0, None))( + jax.random.split(key, 1000), 0.9999 + ) + n_above_400 = jnp.sum(vals_near_0 > 400) + assert n_above_400 < 10 + + vals_near_1000 = jax.vmap(sample_val, in_axes=(0, None))( + jax.random.split(key, 1000), 0.0001 + ) + n_above_700 = jnp.sum(vals_near_1000 > 700) + assert n_above_700 > 990 + + mixed_vals = jax.vmap(sample_val, in_axes=(0, None))( + jax.random.split(key, 1000), 0.5 + ) + n_above_500 = jnp.sum(mixed_vals > 500) + n_below_500 = jnp.sum(mixed_vals < 500) + assert n_above_500 > 300 + assert n_below_500 > 300 + + # Test logpdf # + assert ( + jnp.abs(dist.logpdf(0.5, jnp.array([1.0, 0.0]), [unif_args, normal_args]) - 0.0) + < 1e-3 + ) + assert ( + jnp.abs( + dist.logpdf(1000.0, jnp.array([0.0, 1.0]), [unif_args, normal_args]) + - genjax.normal.logpdf(1000.0, 1000.0, 10.0) + ) + < 1e-3 + ) + assert ( + jnp.abs( + dist.logpdf(1000.0, jnp.array([0.5, 0.5]), [unif_args, normal_args]) + - (jnp.log(0.5) + genjax.normal.logpdf(1000.0, 1000.0, 10.0)) + ) + < 1e-3 + )