Commit c10f614f authored by Nianchen Deng's avatar Nianchen Deng
Browse files

sync

parent dcba5844
......@@ -27,7 +27,7 @@ class SphericalViewSynDataset(object):
def __init__(self, dataset_desc_path: str, load_images: bool = True,
load_depths: bool = False, load_bins: bool = False, c: int = color.RGB,
calculate_rays: bool = True, res: Tuple[int, int] = None):
calculate_rays: bool = True, res: Tuple[int, int] = None, load_views=None):
"""
Initialize data loader for spherical view synthesis task
......@@ -52,7 +52,7 @@ class SphericalViewSynDataset(object):
self.load_bins = load_bins
# Load dataset description file
self._load_desc(dataset_desc_path, res)
self._load_desc(dataset_desc_path, res, load_views)
# Load view images
if self.load_images:
......@@ -98,7 +98,7 @@ class SphericalViewSynDataset(object):
disp_val = (1 - input[..., 0, :, :]) * (disp_range[1] - disp_range[0]) + disp_range[0]
return torch.reciprocal(disp_val)
def _load_desc(self, path, res=None):
def _load_desc(self, path, res=None, load_views=None):
with open(path, 'r', encoding='utf-8') as file:
data_desc = json.loads(file.read())
if not data_desc.get('view_file_pattern'):
......@@ -127,11 +127,17 @@ class SphericalViewSynDataset(object):
[view.euler_to_matrix([rot[1], rot[0], 0]) for rot in data_desc['view_rots']]
if len(data_desc['view_rots'][0]) == 2 else data_desc['view_rots'],
device=device.default()).view(-1, 3, 3) # (N, 3, 3)
#self.view_centers = self.view_centers[:6]
#self.view_rots = self.view_rots[:6]
self.view_idxs = torch.tensor(
data_desc['views'] if 'views' in data_desc else list(range(self.view_centers.size(0))),
device=device.default())
if load_views is not None:
self.view_centers = self.view_centers[load_views]
self.view_rots = self.view_rots[load_views]
self.view_idxs = self.view_idxs[load_views]
self.n_views = self.view_centers.size(0)
self.n_pixels = self.n_views * self.view_res[0] * self.view_res[1]
self.view_idxs = data_desc['views'][:self.n_views] if 'views' in data_desc else range(self.n_views)
if 'gl_coord' in data_desc and data_desc['gl_coord'] == True:
print('Convert from OGL coordinate to DX coordinate (i. e. flip z axis)')
......
......@@ -70,6 +70,10 @@
" plt.subplot(133)\n",
" img.plot(images['layers_img'][2])\n",
" plt.figure(figsize=(12, 12))\n",
" img.plot(images['overlaid'])\n",
" plt.figure(figsize=(12, 12))\n",
" img.plot(images['blended_raw'])\n",
" plt.figure(figsize=(12, 12))\n",
" img.plot(images['blended'])\n",
"\n",
"\n",
......@@ -87,7 +91,7 @@
},
{
"cell_type": "code",
"execution_count": 5,
"execution_count": 12,
"metadata": {},
"outputs": [
{
......@@ -108,12 +112,12 @@
"fovea_net = load_net(find_file('fovea'))\n",
"periph_net = load_net(find_file('periph'))\n",
"renderer = FoveatedNeuralRenderer(fov_list, res_list, nn.ModuleList([fovea_net, periph_net, periph_net]),\n",
" res_full, using_mask=False, device=device.default())\n"
" res_full, device=device.default())"
]
},
{
"cell_type": "code",
"execution_count": null,
"execution_count": 15,
"metadata": {},
"outputs": [],
"source": [
......@@ -129,13 +133,14 @@
" ],\n",
" 'barbershop': [\n",
" [0, 0, 0, 0, 0, 0, 0],\n",
" #[0, 0, 0, 20, 0, -300, 50],\n",
" #[0, 0, 0, -140, -30, 150, -250],\n",
" #[0, 0, 0, -60, -30, 75, -125],\n",
" [0, 0, 0, 20, 0, -300, 50],\n",
" [0, 0, 0, -140, -30, 150, -250],\n",
" [0, 0, 0, -60, -30, 75, -125],\n",
" [0, 0, 0, -10, -5, 0, 0]\n",
" ],\n",
" 'lobby': [\n",
" #[0, 0, 0, 0, 0, 75, 0],\n",
" #[0, 0, 0, 0, 0, 5, 150],\n",
" [0, 0, 0, 0, 0, 75, 0],\n",
" [0, 0, 0, 0, 0, 5, 150],\n",
" [0, 0, 0, -120, 0, 75, 50],\n",
" ]\n",
"}\n",
......@@ -143,14 +148,17 @@
"for i, param in enumerate(params[scene]):\n",
" view = Trans(torch.tensor(param[:3], device=device.default()),\n",
" torch.tensor(euler_to_matrix([-param[4], param[3], 0]), device=device.default()).view(3, 3))\n",
" images = renderer(view, param[-2:])\n",
" if False:\n",
" images = renderer(view, param[-2:], using_mask=False, ret_raw=True)\n",
" images['overlaid'] = renderer.foveation.synthesis(images['layers_raw'], param[-2:], do_blend=False)\n",
" if True:\n",
" outputdir = '../__demo/mono/'\n",
" misc.create_dir(outputdir)\n",
" img.save(images['layers_img'][0], f'{outputdir}{scene}_{i}_fovea.png')\n",
" img.save(images['layers_img'][1], f'{outputdir}{scene}_{i}_mid.png')\n",
" img.save(images['layers_img'][2], f'{outputdir}{scene}_{i}_periph.png')\n",
" img.save(images['blended'], f'{outputdir}{scene}_{i}_blended.png')\n",
" img.save(images['overlaid'], f'{outputdir}{scene}_{i}_overlaid.png')\n",
" img.save(images['blended_raw'], f'{outputdir}{scene}_{i}_blended_raw.png')\n",
" else:\n",
" images = plot_images(images)\n"
]
......@@ -212,8 +220,9 @@
],
"metadata": {
"kernelspec": {
"display_name": "Python 3.8.5 64-bit ('base': conda)",
"name": "python385jvsc74a57bd082066b63b621a9e3d15e3b7c11ca76da6238eff3834294910d715044bd0561e5"
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
......@@ -231,9 +240,8 @@
"interpreter": {
"hash": "82066b63b621a9e3d15e3b7c11ca76da6238eff3834294910d715044bd0561e5"
}
},
"orig_nbformat": 2
}
},
"nbformat": 4,
"nbformat_minor": 2
}
\ No newline at end of file
}
......@@ -2,37 +2,44 @@
"cells": [
{
"cell_type": "code",
"execution_count": null,
"execution_count": 5,
"metadata": {},
"outputs": [],
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Set CUDA:0 as current device.\n"
]
}
],
"source": [
"import sys\n",
"import os\n",
"import torch\n",
"import torch.nn as nn\n",
"import matplotlib.pyplot as plt\n",
"\n",
"rootdir = os.path.abspath(sys.path[0] + '/../')\n",
"sys.path.append(rootdir)\n",
"\n",
"torch.cuda.set_device(2)\n",
"torch.cuda.set_device(0)\n",
"print(\"Set CUDA:%d as current device.\" % torch.cuda.current_device())\n",
"torch.autograd.set_grad_enabled(False)\n",
"\n",
"from data.spherical_view_syn import *\n",
"from configs.spherical_view_syn import SphericalViewSynConfig\n",
"from utils import netio\n",
"from utils import misc\n",
"from utils import img\n",
"from utils import device\n",
"from utils import view\n",
"from utils.view import *\n",
"from components.fnr import FoveatedNeuralRenderer\n",
"\n",
"\n",
"def load_net(path):\n",
" config = SphericalViewSynConfig()\n",
" config.from_id(path[:-4])\n",
" config.from_id(os.path.splitext(path)[0])\n",
" config.SAMPLE_PARAMS['perturb_sample'] = False\n",
" # config.print()\n",
" net = config.create_net().to(device.default())\n",
" netio.load(path, net)\n",
" return net\n",
......@@ -45,14 +52,14 @@
" return None\n",
"\n",
"\n",
"def load_views(data_desc_file) -> view.Trans:\n",
"def load_views(data_desc_file) -> Trans:\n",
" with open(data_desc_file, 'r', encoding='utf-8') as file:\n",
" data_desc = json.loads(file.read())\n",
" view_centers = torch.tensor(\n",
" data_desc['view_centers'], device=device.default()).view(-1, 3)\n",
" view_rots = torch.tensor(\n",
" data_desc['view_rots'], device=device.default()).view(-1, 3, 3)\n",
" return view.Trans(view_centers, view_rots)\n",
" return Trans(view_centers, view_rots)\n",
"\n",
"\n",
"def plot_cross(center, res):\n",
......@@ -78,115 +85,120 @@
" color=[0, 1, 0])\n",
"\n",
"\n",
"def plot_fovea(left_images, right_images, left_center, right_center):\n",
" plt.figure(figsize=(8, 4))\n",
"def plot_figures(left_images, right_images, left_center, right_center):\n",
" # Plot Fovea\n",
" plt.figure(figsize=(12, 6))\n",
" plt.subplot(121)\n",
" img.plot(left_images['fovea'])\n",
" fovea_res = left_images['fovea'].size()[-2:]\n",
" img.plot(left_images['layers_img'][0])\n",
" fovea_res = left_images['layers_img'][0].size()[-2:]\n",
" plot_cross((0, 0), fovea_res)\n",
" plt.subplot(122)\n",
" img.plot(right_images['fovea'])\n",
" img.plot(right_images['layers_img'][0])\n",
" plot_cross((0, 0), fovea_res)\n",
"\n",
" # Plot Mid\n",
" plt.figure(figsize=(12, 6))\n",
" plt.subplot(121)\n",
" img.plot(left_images['layers_img'][1])\n",
" plt.subplot(122)\n",
" img.plot(right_images['layers_img'][1])\n",
"\n",
" # Plot Periph\n",
" plt.figure(figsize=(12, 6))\n",
" plt.subplot(121)\n",
" img.plot(left_images['layers_img'][2])\n",
" plt.subplot(122)\n",
" img.plot(right_images['layers_img'][2])\n",
"\n",
" # Plot Blended\n",
" plt.figure(figsize=(12, 6))\n",
" plt.subplot(121)\n",
" img.plot(left_images['blended'])\n",
" full_res = left_images['blended'].size()[-2:]\n",
" plot_cross(left_center, full_res)\n",
" plt.subplot(122)\n",
" img.plot(right_images['blended'])\n",
" plot_cross(right_center, full_res)\n",
"\n",
"\n",
"scenes = {\n",
" 'gas': '__0_user_study/us_gas_all_in_one',\n",
" 'mc': '__0_user_study/us_mc_all_in_one',\n",
" 'bedroom': 'bedroom_all_in_one',\n",
" 'gallery': 'gallery_all_in_one',\n",
" 'lobby': 'lobby_all_in_one'\n",
" 'classroom': 'classroom_all',\n",
" 'stones': 'stones_all',\n",
" 'barbershop': 'barbershop_all',\n",
" 'lobby': 'lobby_all'\n",
"}\n",
"\n",
"\n",
"fov_list = [20, 45, 110]\n",
"res_list = [(128, 128), (256, 256), (256, 230)]\n",
"res_list = [(256, 256), (256, 256), (256, 230)]\n",
"res_full = (1600, 1440)\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"execution_count": 26,
"metadata": {},
"outputs": [],
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Change working directory to /home/dengnc/dvs/data/__new/classroom_all\n",
"Load net from fovea@snerffast4-rgb_e6_fc256x8_d1.00-7.00_s64_~p.pth ...\n",
"Load net from periph@snerffast4-rgb_e6_fc128x4_d1.00-7.00_s64_~p.pth ...\n"
]
}
],
"source": [
"centers = {\n",
" 'gas': [\n",
" [(3.5, 0), (-3.5, 0)],\n",
" [(1.5, 0), (-1.5, 0)]\n",
" ],\n",
" 'mc': [\n",
" [(2, 0), (-2, 0)],\n",
" [(2, 0), (-2, 0)]\n",
"params = {\n",
" 'classroom': [\n",
" [(0, 0, 0, 0, 0), (1, -83), (-5, -83)],\n",
" [(0, 0, 0, 0, 0), (-171, 55), (-178, 55)],\n",
" [(0, 0, 0, 0, 0), (60, 55), (55, 55)],\n",
" [(0, 0, 0, 0, 0), (138, 160), (130, 160)]\n",
" ],\n",
" 'bedroom': [\n",
" [(5, 0), (-5, 0)],\n",
" [(6, 0), (-6, 0)],\n",
" [(5, 0), (-5, 0)]\n",
" ],\n",
" 'gallery': [\n",
" [(2.5, 0), (-2.5, 0)],\n",
" [(11.5, 0), (-11.5, 0)]\n",
" ]\n",
"}\n",
"scene = 'bedroom'\n",
"os.chdir(os.path.join(rootdir, f'data/{scenes[scene]}'))\n",
"scene = 'classroom'\n",
"os.chdir(f'{rootdir}/data/__new/{scenes[scene]}')\n",
"print('Change working directory to ', os.getcwd())\n",
"\n",
"fovea_net = load_net(find_file('fovea'))\n",
"periph_net = load_net(find_file('periph'))\n",
"\n",
"# Load Dataset\n",
"views = load_views('demo.json')\n",
"print('Dataset loaded.')\n",
"print('views:', views.size())\n",
"gen = GenFinal(fov_list, res_list, res_full, fovea_net, periph_net,\n",
" device=device.default())\n",
"\n",
"for view_idx in range(views.size()[0]):\n",
" test_view = views.get(view_idx)\n",
" left_images = gen(centers[scene][view_idx][0], view.Trans(\n",
" test_view.trans_point(\n",
" torch.tensor([-0.03, 0, 0], device=device.default())\n",
" ), test_view.r), mono_trans=test_view)\n",
" right_images = gen(centers[scene][view_idx][1], view.Trans(\n",
" test_view.trans_point(\n",
" torch.tensor([0.03, 0, 0], device=device.default())\n",
" ), test_view.r), mono_trans=test_view)\n",
" #plot_fovea(left_images, right_images, centers[scene][view_idx][0],\n",
" # centers[scene][view_idx][1])\n",
" outputdir = '../__2_demo/mono_periph/stereo/'\n",
" misc.create_dir(outputdir)\n",
" # for key in images:\n",
" key = 'blended'\n",
" img.save(left_images[key], '%s%s_view%04d_%s_l.png' % (outputdir, scene, view_idx, key))\n",
" img.save(right_images[key], '%s%s_view%04d_%s_r.png' % (outputdir, scene, view_idx, key))\n",
" stereo_overlap = torch.cat([left_images['blended'][:, 0:1], right_images['blended'][:, 1:3]], dim=1)\n",
" img.save(stereo_overlap, '%s%s_view%04d_%s_stereo.png' % (outputdir, scene, view_idx, key))\n",
"\n",
" left_images = gen(centers[scene][view_idx][0], view.Trans(\n",
" test_view.trans_point(\n",
" torch.tensor([-0.03, 0, 0], device=device.default())\n",
" ), test_view.r))\n",
" right_images = gen(centers[scene][view_idx][1], view.Trans(\n",
" test_view.trans_point(\n",
" torch.tensor([0.03, 0, 0], device=device.default())\n",
" ), test_view.r))\n",
" #plot_fovea(left_images, right_images, centers[scene][view_idx][0],\n",
" # centers[scene][view_idx][1])\n",
" outputdir = '../__2_demo/stereo/'\n",
" misc.create_dir(outputdir)\n",
" # for key in images:\n",
" key = 'blended'\n",
" img.save(left_images[key], '%s%s_view%04d_%s_l.png' % (outputdir, scene, view_idx, key))\n",
" img.save(right_images[key], '%s%s_view%04d_%s_r.png' % (outputdir, scene, view_idx, key))\n",
" stereo_overlap = torch.cat([left_images['blended'][:, 0:1], right_images['blended'][:, 1:3]], dim=1)\n",
" img.save(stereo_overlap, '%s%s_view%04d_%s_stereo.png' % (outputdir, scene, view_idx, key))\n"
"renderer = FoveatedNeuralRenderer(fov_list, res_list,\n",
" nn.ModuleList([fovea_net, periph_net, periph_net]),\n",
" res_full, device=device.default())\n",
"\n",
"for i, param in enumerate(params[scene]):\n",
" view = Trans(torch.tensor(param[0][:3], device=device.default()),\n",
" torch.tensor(euler_to_matrix([-param[0][4], param[0][3], 0]),\n",
" device=device.default()).view(3, 3))\n",
" eye_offset = torch.tensor([0.03, 0, 0], device=device.default())\n",
" left_view = Trans(view.trans_point(-eye_offset), view.r)\n",
" right_view = Trans(view.trans_point(eye_offset), view.r)\n",
" left_images, right_images = renderer(view, param[1], param[2],\n",
" stereo_disparity=0.06, using_mask=False, ret_raw=False)\n",
" if True:\n",
" outputdir = '../__demo/stereo/'\n",
" misc.create_dir(outputdir)\n",
" img.save(left_images['blended'], '%s%s_%d_l.png' % (outputdir, scene, i))\n",
" img.save(right_images['blended'], '%s%s_%d_r.png' % (outputdir, scene, i))\n",
" stereo_overlap = torch.cat([\n",
" left_images['blended'][:, 0:1],\n",
" right_images['blended'][:, 1:3]\n",
" ], dim=1)\n",
" img.save(stereo_overlap, '%s%s_%d_stereo.png' % (outputdir, scene, i))\n",
" else:\n",
" plot_figures(left_images, right_images, param[1], param[2])\n"
]
}
],
"metadata": {
"interpreter": {
"hash": "82066b63b621a9e3d15e3b7c11ca76da6238eff3834294910d715044bd0561e5"
},
"kernelspec": {
"display_name": "Python 3.7.9 64-bit ('pytorch': conda)",
"name": "python379jvsc74a57bd0660ca2a75467d3af74a68fcc6f40bc78ab96b99ff17d2f100b5ca821fbb183f2"
"display_name": "Python 3.8.5 64-bit ('base': conda)",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
......@@ -198,7 +210,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.9"
"version": "3.8.5"
},
"orig_nbformat": 2
},
......
......@@ -2,7 +2,7 @@
"cells": [
{
"cell_type": "code",
"execution_count": 12,
"execution_count": 5,
"metadata": {},
"outputs": [
{
......@@ -10,14 +10,15 @@
"output_type": "stream",
"text": [
"Set CUDA:0 as current device.\n",
"14496(22.12%) pixels in layer 0 are masked as skipped\n",
"15980(24.38%) pixels in layer 1 are masked as skipped\n"
"Layer 0: 14106(21.52%) pixels are masked as skipped, 51430 pixels need to be inferred\n",
"Layer 1: 15586(23.78%) pixels are masked as skipped, 49950 pixels need to be inferred\n",
"Layer 2: 700(1.19%) pixels are masked as skipped, 58180 pixels need to be inferred\n"
]
},
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAC7CAYAAACend6FAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABGuUlEQVR4nO2de7QsRXX/PzVzHveCyFMMor8EEzQRdBmD4JtrjM8kKAoKKiCgiG9N8lOURNAskBhjRBPFiwIX5RnFaBKfIQoSRUR/ykNEL2IiQiA8Lly4954z01O/P6qLU1NTr+6Zc6ZnTu21anVPTz+qqr/723vv2l0tpJRkyZIlS5bpkta4K5AlS5YsWUYvmdyzZMmSZQolk3uWLFmyTKFkcs+SJUuWKZRM7lmyZMkyhZLJPUuWLFmmUJaN3IUQLxBC3CiE2CiEOGG5rpMly0pKxnWWSRGxHHnuQog28DPgucAtwPeBw6WUPxn5xbJkWSHJuM4ySbJclvv+wEYp5S+klIvAhcCLl+laWbKslGRcZ5kYWS5y3xP4lfH7lnJbliyTLBnXWSZGZpbpvMKxrS/+I4Q4Djiu/PkHy1SPhso80C7XdwO2K9cFsNbYr07IzOz6rcY5tgB3lutdYLHGuSda7pRSPmzIc0RxDRnbGdsrK1JKFy6XjdxvAR5l/H4kcKtVofXAegAhxBRPcDOPAvhhKD2XwDOBvYBe+VsvfUWLq5uEte4rLWP5C+CK8vfVwEUoBVkYsq2Nlv8awTmiuIaM7YztZshyDajOoAaengP8GjXw9Eop5fWe/adQAQ4FdgWeAhwEzKIsmp5RbPDbioBj6RLhWNrAt5VAlwLoAF8EvoeygD5Xq8UNlx9IKfcb5gRVcV0ek7Gdsb2s4rPcl4XcAYQQLwI+grrrZ0kpTwnsOyUK8HiUN/5U4HdQlk1BP+h9CuCzcMBv4diWjV6GLBtbAczSRlk4G4HvAGcC19bqiQbK0OQO1XBd7p+xnbG9rLLi5F5FJlsBHgocDhwAvBDYCQV6DfyQAozLdQ0pgF62gXuArwJXohJD7qvWNc2SkZB7VcnYzthebsnkPnJZB+wDHA/8FktuoFnqKIBeB7+FY4tt2ej1mNsaUwBdesDNwCeB64DLEvqncZLJPVnWkbE9OZLJfSTSAp4MvAvlnu7IIOhjClCwBPQUCwfH0pRQTDIEfsES4GMKYJZ7UW7tB1Eh515SzzVAMrkHJWN7UrGdyX0omQceiwL+n6KSjLooMOulD/ymApjr0rEecl2rWDcxBTDX29Z6SAlmjGUX+BfgA8DPmYBshEzuTsnYnnRsZ3KvLQcCRwKHoG68CfqQEsQUwKUEpvsKg0qAsd2+nybgod9t9YG/igLMOJYzqGyEfwLOBS6P9OVYJZP7gGRsTwO2M7lXloeh4nDaRe0apbDWCwYVIUUBUrIKcCxNibmusWyCmALMMKgIthLMsOTSHg/8b6BfxyaZ3B+UjO1pwnYm92TZGWXJvBo1lUg3UEKuq23p1FWAYV3XOgrgKy7g2+Uq4DOofOJNgTqvuGRyz9gOlMnFdib3JHks6sY9GgW4Lso18wE/VQlimQWxuKTZPeb6KFLFUhXABr9LEWbLpUDlEx+KeuenEbLKyT1je1qxnck9KGuB01AT/O3OEuhd4PdZNyElSE0bcykCjqUpIdfVThcLpYmlDjbFrJtZY3k78M/Ae1BzgYxVVim5Z2xPO7ZXem6ZCZLdUZkCr0cBfoF0Bagy+DSMhQNu8GupmirmSxHzDTZ1rWWqJfcw4A3lcR+kifHK6ZaM7dWM7VVuuT8bOA/1Jp4GcAe3AqS4sC4lcA0+6W1VU8aw1lNc15gCDDvYZFo0tnUzaxxzL/Aq4FuDt2FlZJVZ7hnbqwXbOSzTJw9Dzf30YRT4bdDbClDFhTUVocegMthWjitlzFzHsTTF57q63FZzfdSDTbOO5az1+z7gHcClLE3RumKySsg9Y3u1YTuT+4OyE2rE+7ksgd1VqihA1dikbelUSRlzSZ1UsZjLWgX8MQWwy9dR+dWbAm0auawCct+JjO3Vh+1M7oBKBTsf9fJGFzWpf0wBYu5r6uBTLD6Z4rrGrJsqrmuKAqQMNrmAH1KAufL/b6Jc2U2ONi2LTDm5Z2yvVmyv8gFVgfqIwF8Az6If+D4lqKIAoxh88lk4WOu+9vlc17oKkDrYZLrns4522W65bt864BxU+ODbkfZl8UvGdsa2W1aB5d4GXosa0Z4hDfwhN9ZWBnvgyacEKZkFqa6rZHDASS9TU8VCCuCzavS6b5Ap5rJq68ZcdoD/C5xV9suyyRRa7hnbGdur2nJ/LfD3KGAtsgR6ezmsC+vKLnANPtVRgLquayibIOSydukHftdYNy0Z26rxtctl4egyi/r2hQQ+5WhfFr9kbGds+2XKyf2NwKksgV8D3gX+VBe2TnaBz8oJgUSvQ78SuMR2XWOWTepgkwv4ZtFKoOseUuyQUs8BHyrP94lAO7MsScZ2xnZYppTctbt6KkvuakgBbPDr313cyuCycnwubB0FsEGDYwn+VLGUHODYYJMZi9TrpkXja4sP7CE3HJQSnFpea9lDNBMsGdsZ22kyheQucLurVZUgFp/0WTl1B58kYRBBP3DM9uqly3X15QBXGWwyrRtTEVLc1VB77DbNseTGftrT3tUsGdsZ2+kyheT+DNQAkwv8tgJUcWFTFcCOTVYZfArFJVNc15S4ZGywyY5Jxiy0FDccxxLP7zng74CfAlcE2rwaJWM7Yztdpozcd0alhLkyB1zgD1k4tiKE4pMhF9ZUgh5uELkUIAVAPtc19QWP0GCT6bLabmudGGRIkW3FnUPdx+to0tSq45WM7YztajIUuQshfglspuwtKeV+QohdgItQX9b9JfByKeU9w1UzRXZCvcTxLNwgd4E/NhA1Khe2SnzSZ+GAHzx6WfUFj6qDTSGX1axrlfq7RKDesjwPeCVq7o6VlYztjO1Jx/ZQee6lAuwnpbzT2PZB4G4p5WlCiBOAnaWU74qcZ8gA1MOAs4E/pB/cC7hBH1OCVBc2xX2tM/gUswokg7nAo1CA0Nt6ppWT8qaebxkr89bvfweOYQTzdVTKc8/YztieFGyvZJ77i4F15foG4FuoeUeXUf4Q+CP8AK6qADFFcCmArQxVBp98CqDXcSzB7bpWecEjJYvA5baGLLMqA2am+JT4eagZDv8pcvyKSMZ2xjaTgu1hyV0CXy+tk09KKdcDD5dS3gYgpbxNCLH7sJUMy7NR2QOu+GKK61rFhV2kH/xV3NfQ4JMDSDM9aNVwXXsCulVf8IhlEdjx1JQYpF1fnwKYgLd/6/IR1HzZ3/KcY1kkY3ulsa1XH7RDM7aHkWHJ/elSyltLkH9DCPHT1AOFEMcBxw13+d1RscgdiA8g2SBPVYBYnLJudoGtAAUcIGHPEkDHSHhC2cxUbgf4MXB2CZxbBFwlWAK9CXy9nppFYL/Ukepya7ErHwO+qcQ7ou7zE1jB6VQztkeJ7f1LbEsJR0vYFzdsHuxE+qHQAq4BNggQAn6dsR2TochdSnlrubxDCPEF1Fd3bxdC7FFaNnsAd3iOXQ+sh7pxybUoj3gHwgD1WToxxUhxYV0KYK67sguM8psF7NaD90uFv31ROl3V8zMx9FzgeRKEVD1/HdDtwnsF3NWG/7ItmypZBFWA73sSpVgztvstUHOTvwt4LyvxWbOM7RFge9cenCzV7fs9YFcGnwEmhKA/5G4b6E8FniFhRsJdwA1ArwsnC7g7Y9uW2uQuhNgeaEkpN5frzwPeD3wJOAr14cajgC+OoqKD8gHgeJY+HRYDv8t9Dbm0oeNt8Ce6sO0CZgp4WQFPkKp3di6bozGzyCCp+4wE17iTXm8Bu6BmgBXAH0m4uwvnAj8WcEkbum0oqmQR2BZZ3Rikr9Iuy8Ysb0Ep658lnr+eZGwPge2XFrCvVDPePtQ6zV2Eyd1ludtRF9MIfxIKnpdKuK+rElCuFfCFjG2gfraMEOLRwBfKnzPA+VLKU4QQuwIXA/8H+G/gUCnl3ZFzVazEY4GvAruhALlglUXHurm012Pu7Ahc2P0LOKIHB0tlkM0zmB1WF1MphoK5XEAl+X1ewGdb8P1QFkHKjHhVMwfmHevm0l43yx3AC6jx5fnkbJmM7YrYfnIBr+7Bn0rldGiMuZ4XoyR3E3669FDG7xcFnL86sD1FH+vYGbgc+G0GgR9SgDpK4HJ5U1zYctnqwu8UcGKhkh52x+/5hRIJUmPutuUeMxZaKDxdCpzaho1t6LmA71OAOQY1LKQALuD7QO9TgHng56ic73sdHeKVCZjydwKxfUKhbsVOnqrapzEJvg65uzIXNeRsmGwCLgNOa8NN04vtKZry9xDg0cStjBhgY66rSwFClo4B/HYHHt2FtxYqjVV7gx3Cob3lttxdZVfgcOCQAs4q4KMF3FxAYbqpKZkEWmLxSFdFdWVCFTXLb6Nw8OlAp0yiTBC231TAESg4bAPuKZc2ubssd9t619i3RUPCHiP1We4mR64py0HASwr4TAH/sLqwPWHk/jAUoiT+0fuQe+kCcmp8MtGFne3C33Th1VINhGtStzFUsARqG1fLYbmHSg+lOK8HDivg3B68uwedUAzSl+ZgV9KsmPnb9eRxVdb3tuERqJD3imXPLLNMCLY/0IXDpCLOLagQyFYUsfvIXZ/WR+4plrsrJDPDoPFskvtaY/lqlAFzfg9OXB3YnjByPwN4MuGBppi141MMG9g2+BMsnGd34X2FqiIsWeo2kF3GQsh6h0GM2ZjSy1R8mRlkuh4t1HjAGyXs34G/6sFloQwCu2JmhXwWjT0IUNW60QpwAAoPhziuP4nScGyv68J7C5Wxt4AKebjI3SR4+/QmwY+C3O0oiW21b0URu67TWlSK8X4dOLkHl083tieI3A8EnkZ4cMcGfgj8LiD7rJqIEsx14IAufFaqcTAzpmgOzvvIPRaWqWK5p4Zleta6tt718gDgvAIO68H3etBJcVtdUrViPmtGl46x39NQ8cnLI3VoujQY27Mlts+S8BDUQPwWo5jkvhVFoppMdehfn05X2UyLr0LuegYB02qfpT+MvaZcaqvdfuBsh0o5PruAI3tw1fRie0LIfR6VebYj6g7FQJ9i0YQUIlaM/XfpwFlddR/WsgReV/ERe2rcHQYVwFyvEm/X5K4J3SR4fc1dgS9JuKyjLJ57qgwEuCqV4qrGrBozh3kn4EjgStT9mERpMLZ37sCnuupBL1DW+gP0k3uq9W5WZxhyj8XbfVa73cTtgYskXNmB100ntieE3B8LvAx/LDI1Nun7L2bpeBRg5w6cWcALib7T4QzP1LHeXVLVgDDJ3Vy66rMGeBGwvquUYJNrMGAUFYpZOB0GFaANHIp6hfu6QAc1WRqK7Z06cEYB64D7UaSul1voJ/mY9R6Kuw9D7nZIZo1VfGMA+vrbo2Z4+HgX3jB92J4Acm+h3t6aYdCy8QE/VTF8A0gRRWh14PBF5datYwmoJrHbJJ9C7lXi7lpS4+12KViy2m1ydz1YDgJ2KOBcCRcCvZR4ZN2BpY7nv65jfQ3wTuA1uFMumiwNxfZhi/DKnnon914UqWtiN0uK9R6Lu5u4g/7xJBsioXi7DsdoYjetdjst04x+Fah52T5TwPlSTeg8JdieAHLfD8Uspmk8rJXjsnZcMUePO3tMBz7SU71nu5k+yz0l9r4SlruZVuYKxYQSBtYBz+jB/CKc7TKzQgMAqe6qy0UNrXeBg4GPAd8PdFITpYHYProDf9tTf92HirHfT5jgtxpL23q34+4hcrchFSJ3M95uFjPWHgoN2dffH3h6ie1zpgPbE0DuJ6Aauo1BFo2Bv66C2NZNud7qLIF/hn6Q2iGZWHim6sAqjMZyTw3HuK4tUe3+cA9ER01QJl3AbzmWMdc05qKa6/ZMf2tQFvCkZc40DNuv6cApPbV5s1V8BB+y3h0vNP1uB+YLEF04ScKusoRWiTPTcBdCrd8p4P0C5AwstOGnvheXNKmvcVw75cGyA3Baie1zJh/bDSf3dajZglJB7wN/zMqJKUKJjsMX4XSL2G2CTw3P1MmagUHrRi9HQe6ha5rXXYvqh62LcIFZmbpxyBQX1bZobCWYtMyZdTQK24ctwodKYtcWu4/g7fi7TfBGaGZ2AeYX4FVd2LeAV5RJNyGjXYuQJTqkmg+vXahqXCzg2jacPwML89BxDaT6wjEucjfx/lBUP2ybfGw3nNz3YTCLwMWiVa2cmBvrUIKdO3CUh9hd1rvPck/JnPGFRVIt9xDuTFJPDce4rjuL6o+vdGBTaiwoZNnEQG8D3laCnVB4mRRybxC2d+qoGHuHJSK/z1rezyDBuyx4w3o/cAGO6sILpTKsW2VNNuMn9z7LHTdFHiGh14X3deHLC7BhBi43X1zyTYEQstqlcdGHovpjwrHdYHJ/KGpmPJ8pHAJ/SCl8Lm3Aytmlo7JiDgwc7iL41PCMXpekWdFaUsOAJv7qhmNsEahMgzMLOK4D96TEHkMDSqbL6gO9uSys9QJ4A/BZFH00WRqE7Z07KitmfwYt9vusbSGCL8l9Zivsuw3+sqs+T/DQ8kr2I6wuuc8Yy1ngEAnP68CVXThlAa5dgKIKsZti6s9TgE8U8MbJxXaDyf1w1HeIXSwZMpWrWDoJ7utcBz7dVemAdhVSrXcXwfvCMz6Ch2qWu4lDnRkTInff4G0ocQDUh+faXXiFgE6KAvhAr8Ftu6g+V9WlCHsBhwFnOirdJGkItmc7cGZXPaTvxU/sCQQ/twV+bwu8raMIt2DJEXBFRGyCt2FnQ9lEjZ00Mw88tyT5z3Xh9AX46SIsutIvQwO49kWfh0oBfuVkYrvB5H4AqtMWcZu+MYsnphQhE9xQjqd0lcVuk7qL5H2/7Wr26Ee3y4wJWe+mpIYD7XBMyENwkbt9DXPbgah++nZsYKnj2GaD3WfRuKwb28KZRZmgTSf3BmH7KfQPltpxdhfBW+Q+fz98bBu8tKfugE6Ssccx9XIU5G7O52hmRB4i4cWLiuTf1oGFFGJ3XVBf9CnA/l34z8nDdkPJfV+W3gzygb6OS5sAeLM8u6umFFhr7OYi8BRr3qXDPnIPxd2h33eF6gOpdrzddx37/K5tAvVK9wVSjZpdFrNqUiwan6vqwoP93x+j4pPXOxrSBGkIttd11ZQCgqUBUpPgTaK3wzMGwe/zALxhUc0ltlgeprMf7QRMl9pUJXfXe0yLLCXOdMrl4T1Y3AJndOEnKcRu642+2I6odzuO7sLlk4XthpL761GDCDpFLFR8SjCkpTPbhfcXaq6YjuM0qTrmqkIKuQ9rucfI3aVVrvOnXE+gJjV8XwHP7UInZtXELJoUS8ZXdkZ9vvRtCY0ZhzQE2+8tVNrKJvozYHwEb1nvYjO84AE4q6Oe7TpJxjVnmG29205sKrnreLvLatePrfnyvPPAURIOWYCje/D1HkjfhVyBfdM92AnVXy+cLGw3lNyfQhz4dRQi0cppd+C0rnrHxGd1Vzl1iOBdsffUuHss3t7GT+6xcIxLQuEfgYo2nNqFE1pQ2FaNDfaYJZMC/h7um/PUSEPGKQ3A9qldNbvjZgazXhIJ/vn3wzmFItYHWCL21EkhtTFtQt5H7qF4uz0Dga1ma4ENHTjqfvianRUTInY79vNE4JQuvHtysN1Acj8U2JvBhpppJXWUINXS6aqPERxRosBH6K5TpxK8q/gGVqta7qGB1LZ1rlg4xneN0DWPlPDJrvqq04NAD1k0Pksmtbiw8RjUfC2fDzRqHNIQbB8uFfua+ek+krdDMZvhT+5XCTYzOFPbnd+GshMz7R6oQu6uDzCFzrsGNf/Z8ffDv9knDxG7fZHDpRpgnRBsN5Dcd0X15Daqgb6OxeNQhlZXfUFpRxRifJe3dShG8L6Hgo/cXQQPYcs9NpBaJxwTs9bNaxUoF/YtBbyjq5KRa6V9VbFkXMqwBoWjpkkDsP3mQnXPJsLE7rDixWZ4QUnsa1lKabfJvc6U7ink7rLazXCMfU7zvNuh6v3aB+DrAqSJ2xnCxK7JfSfUF6j+fDKw3TBynyfdbY1ZPDaDJrq0v1OoT+NV1b0UKz5E8KGB1aqWe4zc68byUwduXwt8rICNtkWTAv7Uex67OU8FzqE5UwE3BNuvZvCtUh/JWwT//AdUKGaG/ulkzCllQh9kMq13s6YhcteOpxlvd/FuijewHbChC0c9AF9zEbvrE6n2J0+PRH2u76bmY7th5L4daiIl1+hilcb7noYJLu2JJXo7CZfw6ZOP4O19Uu5xVcvdRbZ2OCZmtbvSHUPWun3NWeA9BRxTF/CpT9UQPg4C3k5zyL0B2D6hUIeaJnci0e9TDp7O0U/qdnFZ76FvZeuWmLA0IWeSuy9aEvIEbHXZDji7A895AG7wWeu+eWt0OaGA1zUf263gv4AQ4iwhxB1CiOuMbbsIIb4hhPh5udzZ+O/dQoiNQogbhRDPj52/Xw5H9Wwd8FdVEIcSPLmA50ROXeO0D5aOte4rLlPHzClzTdEdO9Y1ouXLTws9fHx9Y+P2ucB+IdIZBtwpZQ710odfVh22n8WSiW0Xc3ZHi9zny3TH7QOHpjgCsbFaX7nfUUKzD/ummdfr26PaMx+aQiE0lfE6Go9tSCB3lP3/AmvbCcClUsq9gUvL3wghHldedZ/ymI8LIdoJ1yjlSfS/YeMDcx1rx/fULG9Ku4Ajeiqlbxhd8lnovlBNjORNwg7M1Oole5vYXe+32HV0tSe1a3Wf7Y7qz1Yd8FctLjy0UXgKyjmsFmy/qreUgWmWCEvPbYGPbVXj5PahrudELLpjEnYKqbt++whe87P9vDK5Wa+/RsLpW2HW9USwXRP76bALau6ZZmM7Tu5SysuBu63NLwY2lOsbgJcY2y+UUi5IKW8GNqJeq0oUMwfQNglHUQKdOFPAwTJ+aMrpfIRpk3yKJW8TtmuEykfsrmvESL0O1nzlYKn6dWQnDN0c1/ZwbueqwvafyqVcRZvpXCRfLn9vCxzcU/Ay0x19xB6y3lPT6X2W+2brPDGr3eZke6D3ZT3Vvqi17hoxPqjZ2Ib6MfeHSylvA5BS3iaE2L3cvifqo39abim3DYgQ4jhURn4pjwaeibsRQwA71eI5pFCzHPlOG7uU679Q/N1Fsj5cmFkzAx2JP0umx2C83Sehl6EK3PF818t6Zr13BF5WwAW+DhrV08SHkQNRc3LcHGj4gEwftl9WLL1ppNnNZGoXyW+BmXKumDkUodrPhpAFb5JraGp1s6Z2zN3OlDHHO03VcdGdDWP71aM26h2ut3bg+K3Q1bF1/QUne/DAHkTYDnhpARc2F9ujHlC1X1IHD6VIKdcD6wGEEFKl9+yFgkMVJRj2CVl29OPlUsLsEKfxEnyI5O39XE3yjRCFsmRCx7rOEcuCSekDk+DnUf16wTCWzDDHPhrlQ1cid59MLrb3keoeLljFJi+L5PddUHO16LliXIeGDH/zlK7BVRdBa/G9MOoaRPWRu2uCAPNBsQC8XMJHt8E1ZkN8BG+W7VH9OhQ+lxfbdcn9diHEHqVlswdwR7n9FuBRxn6PBG5NP63JRKlKMALr5zcL9QH6YUg8VmJWvE3wpm5XsdzNl5bqELuP3FMsdVc5GvhED341rAXjKz6s6O2VZfqw/SoG2TlE8mX5y646i/kyku/QmAWvi2tKghRyN/PabWI34W1b6748+QXjnCd24RU2qbusddv9OAJY31xspwyouuRLKDqkXH7R2H6YEGJeCLEX6nW8q9JOeQzu9+59DauqBIGyW09N2xA7TZV7VdWKd2WyuOLprpi7L88sZQB1lHh03a6dUf1bu2ND9zyGD4nCVSWZLmzv2lPhRnsAXhebqcvlgQtqPnbX2H2qFW/H3rfgznxxDZCm7OeKsYcMbl8XPFXCM11k7jtAlx1Q/dtQbEctdyHEBajkn92EELcAJwGnARcLIY4F/hv1XjVSyuuFEBcDP0FRx5uklEXsGkqeFGiEq6EjVIL3l899+zQpl/UReR0rPhae0eaJDkyCP9Zudp0pda31FCvd1Vdt4H09OKjOvRkG+Pq3P6tgVWD7ZKlq68qychHYgvo03lFd9UzY7Dg0ZMXbA5kuC14fr+Htk6K8roafjppq1fBZ7HY4x7bW9SyS2hbaEdXeKxeg4/NuXOReACf11Ihzw7ANCeQupTzc89dzPPufApwSO6/jSPorXvW3r3NiylG4p79N1asUS9dH7CkEHyJrV7zd3tdGf+iN1mGwad8Wc32GGidLBXkKPtyyKrAtSE+zLYlsfgFeIP1JWj4L3mXJ2zF4HZoJkbotphp1rZaDO75uE/uisXQ5vy+UMGeSe2qasTBr2BxsQ/2wzIhFv4MWa0zK0yy1A8uyv4THW5fykVSI1HxknmLBh2LxVV5iisXzXTH9OmEZX1e7HooSNQPhk30ninVolXvtws0sKrVhXDJmbD+O9PcoyvVXddWLmKFM3RjJ+1IlF6hG7Kb0WJrvzOUVxIxtl6ro32tR7a78zsi+jBnbfgpvCLnvguoliR/8sf9qKsKecunFJd8lXITl2p5aQiRvAsfWJB/B+5BbN7bu8hhS1123anfgESkgTrFUqmBCop7c8bf5lk/GiO1HSHV5n8HgMR72LRQxpL6OEQnfP0j0i2XthhFZnseVux6bz8bVbN2uFrCP1r8q74zsCuwxTmw/+AL1gDSE3LX4Glal4SkdaG2repkqpOcjdBfB21Z2zFzygTAljz5E8KkEHuore5/gPRgG9LECzYD5GLAtZfj9Cgdr/24HXuE5zPU8cDkBmlzN8ExnRL2opYN/0DRkbLtyDLTKHSbhMS72d+mWqadynNh2ZegqaQLqS0lpSN1O8HTkTA+OlXEij50uleBTrfhUjUoJx8SIvKqVXhePx0poxyzSYUGPZ13/HpeMCdtHyzC2HNvmu+rlnpQcgJDtsWAtR30HpONaKSEY17CWXt8BmCtwE7mv/wrgmHFi2y8NmhUyRUGHBLz9X0suxduJLKtcblhr3gcifZwW1yCqFt8LSXbWi6uOw2DQh8knoPq7SD1plY6PnWfcMiZs70uat2gUUaQ7lz5bxCZ7E7KjlB7uDBiXdR6KUpqq2Ar1ka9j9qWR2G6Q5Q5xJRhmPdBBo+jnkP6lWvM+YPl84FCcPWVw1FW3GG/UxaDE+lHnBL51AutxJVgZGQO2UzBmlZNkeHdzWyzi0yn3W07RhnYoIhkic1tNTurh1qWYB95AbDfMcg+tL5Ny2P3kWo6quKziKmGawjjetMh1XV1vq7rI3FWfYUpK/zk7096hznrqvuOUMWI7JTRolF1lNfvDJnsbsstltWsxuThE5nbdfe3bRVoH2AcHyb1Z2G4QuWvxgT/0v71vxY6JEVTKPnVIPmTN+/xhTfD6SwZ60tmUl5mqWuZV2h3rvwelCrBT1lP2bYqsMLZ93lqA9Ks+DwrH0iwrISFnNYXQbZWo1G99VNIsbDeM3EcB/tR97XXPqVIJfhTkHyN77edqctdmUVUyj9WzSpt8fYP1n/QdkHKiYfdtAtGPAds+jLke7prcPYfVhe1KSOjhU7X+0qUvoX5rMLYbRO4R0h35vtK/W+gU9raU/0L3JPQQcJkg2oLXFrsZfhkAXOD8sXr66uuSSset9H1ugjQA29Kxiw8rgd1SybLnPt2yiI+PU0rwpLF+w/qvYdhuELnHpApUKuxblbSW41wxcjWL6e+6vo3qOl+IfOvWtep/UVmm+zsRsgxtr3rv5eBhKVeqRJjLLHXq4dzXtdG3Dcd251VSZXQ9OEHk7k/WH2rf0K5VLjnMuURgH3suGG2xtx3/2eeJnXeYulb9LyrLdH8nQpah7VXvvRg8LOVKPgiOQ+rUw7mva6NvG47tzqukyuh6sEHkLjzry7Wv8O8WOoW9LeU/12VDS9ekXjr0AkvErgdUzZkdU4i+zkNgZP2z0ve5CdIAbNvkFMJKYLeUYsJxJURfs05dgyeN9RvWfw3DdoPIHcIsmLJeZV973XOqVGKuQtohrbBJ3SR3WEp9NMm9be3rOl8K6ddpk69vsP4TvgNSTjTsvk0g+zFgO8a8ju1CgJD1yNxVViJjJnT9qmonXPoS6rcGY7th5A6j6Ywq647L1CW6KtpgL0Pzp+swnN4ujeNcH4c0P0OTQvZewI6ob/ok9f4QWK+yb5NkhbEdYjsPG8bI2oaobVfYUBz1nDIuccHfVZ/QA8Dsmkr91kclzcJ2g8h91KSduF6VxIYpPqJ1kbqZAqCvb5K9sI6ZIY7kUB2GaVdKvzk70d6hrnKkHDdOGSO2XfgKMPadAloyTOa2DWHOoW7Ppd5ieVMiW9b1QqqQQvR32nqVemADsd0K/rviMmqQJzLTMMQWKjaBu5QtpD3m1wZ0mTOKud1EdwoYl5PsfTivdX9SlIbAelgBVk7GgO1UnBl4e7/w75pC5jZkdTRxuaRNvwqYqhAie5+avL/FoC6luDENxHaDyL0mgIdh3p6AHzPYV3WrESJzcz1ByZzEbhK8a7uNal/IZhxk/yNUfyefDM96HYUZt4wJ29fix4GLldsgZ8K7+4jdJFfTBpln+UimVZ7ftHfs+jiaGCR7GeojX8dcQyOx3UByH7YTQh1s/ddtwdmi+mnsfVLI3EesMYUz0Wpa7Oa675gqxB5qg6u9VfAnUP1c2Ae6Tl7lBlTByzhlTNg+R0TJ3N620FbfTY2RucvumLOKSbyjvgPCuIa+jq0WLpvHRfB6/T5gse04KNZ/54wT235pELnrQPIIgB3tWGtbKnGlkrm5nmKpx3xbG62h3ykkX4XwXe2qglG9T/AexMA/jOug3/wap4wJ20L4H/y2eVvi56ezcLHwk7nPmTShOG+UNWWZHU1HPiiz5XnnreIid1s1fKGbiwT8zG6kve56QohxYtv/0lOU3IUQZwkh7hBCXGdsO1kI8WshxI/K8iLjv3cLITYKIW4UQjw/dn4ldwHXOypfF/QuJXB1egtuEXBH5BIhcqtipfsI3mUd+EIxvmUo/h4baapD8LG+McvtwK99wK9zH6soyrXAhbhk6rH9a6Eu7yFy53jOLFzbVoOggWeA02K3iXaNUdYyGgtelOdZa53fRfA+onfxdYFqd/Qgu1PuBG4dJ7bv9vZViuV+DvACx/a/l1I+sSxfBhBCPA71wcp9ymM+LoRIGFORqElT6nRAym/fthZ8vwXXWZfy9bGLyB2nDFrp5n8B99ipTTFiD4VnQoHGYa352IPwWuDq2Il82+oQnvm7i/riplPOYdqxfQN+k9sVy5iD82fU5+t8zwBfCMZF7GuNsh3DxeBb5fHbWed1EbyL5F0Orv69DbjAblzIRdEHX8+YsT2E5S6lvJzQ46FfXgxcKKVckFLeDGwE9k87tGrjUoEfYuCydB2XSjw0iQxdVrrPWg+ZR6mWu8vSGJUVH8KpD68dKpwolcCq4MUtqwLbPeJ4shh6YR6+LPxEnkLqJrlv5yizpJN8q9x/O2B76zy2BR+y4l1t0W38NwGL9kCBa2db33q6hs3Ctq5VXXmzEOKa0rXdudy2J/ArY59bym0JcjXpoPZtq8pQZXlv2Ul1TxOKaYfCMHUCminE7iN4H7GnlLrkD3BS1SfFqJSjBfyAGjI92D5ZqPvtI3MHU3fmYcOMGmD0hV9SrXVN7tuX5SHGcjuW4vE2xPS45ppyv4cY59BlO+P8thXvInlfTP5e4NwZ1e6BRoWeEG3gfc3Fdl1y/wTw28ATgduAvyu3ux4lTr9BCHGcEOJqIcTVass51HY/hwE/Lbirrey3EepUcmw9MsA1QOIus8Mme9/Ikc+KHwWZu/pLoGK+d6V0VuikVRTB/n02FWW6sH13W7FXzPRe07/+7Xn4rkiz2G3L2WexmwTvKttX2Me23l3EHiN4Xb4j4ArXASErfg719Lu7udieCf7rESnl7XpdCHEm8K/lz1uARxm7PhK41XOO9cD68hylkiwXyCNm6X+14Fzg7YmnSvlEjT2xdWguUmGVVnlc23MO13GhJvvi+j6CT+iy5AfABuBXsRMOQV5RkqwmU4nt84HX4rZKTVKz2PnUBXh+Z4kUO+XS9d12vTQharbWjj7OWecxj/Udp20Xu+qa2H2xeJOz56x1AZwyEzggRPjn0Ghs1yJ3IcQeUsrbyp8Ho4YkAb4EnC+E+DDwCGBv4Kq0s94F/ALl6Y4S/InK8WMBC1L1SN3ThL7dlULs5vlc54JBcsfTRSmhoFFb8fa+C8A1oubJ7IbUUYybSA+pl106jdi+VkAh4wFyzZRb1fq1a+BzXThE9hO777N2NjTNWpjErr/vbj8gfOSuQzSa4G2Hww4HuWLw5rp5/MUCfmLHkkIH61IA1zUb21FyF0JcAKwDdhNC3AKcBKwTQjwRdS9+CbweQEp5vRDiYuAnqHv3JillYpLxL4ArgMNrNLZqANlhpl7Shg92YTfrtFU+KKn3r/IFg1Rytz/GISLHm82LhYNsK36Gge6pZcnfi+rXvj/r3J8UsLu2Xw7c7O/61YLtL7ThlK7bIvUR/AIUC/CRBThocYnPXMRuw9OGo4aUJvZFBj+i7SN3DV/TevcRvMuCN7fbPL0AnD4LhT1IYB7ki/NsQfVrQ7ENCeQupTzcsfnTgf1PAU6Jndcty2nFRDq/24ZLCjjeM2uS73Q+a33g47kMkrwdjimMc7vOaZ/DJHgbBy5ijqVdurpmmKyazwvVr0HXYFT31acYfllV2P5iAUdKr5XOWlQ+4EJ/uXFRWe+v7PVb7j67w7Y1TLjpcEyHfss9Ru7mw8EcZrKfUyYv+zha7zsDXNSCG+3AvW2927mWev3CZmMbaoZllk+uBl5BGnB9DFa1zABdKNrwmRa8tIBdHZevGle3v1dmIhfCFrvroVE1rOPrOpvg29bvYTJqzNtxO/DZFvSGuTfDWEAFNTNllknGjO3zW3BQ4Sd1B7GzCIuL8LYOdLbAUdJNxlpc4RRXOEYTu4vczXPZ5G4SfCw847LgzXK2gHeuhY452mum39h5luaJ7kb1Z8Ox3TByvwg4lbTAt60EFSwZG/x6/eouXFoo79kmchfJ2+QeC8lo9JvrdrV9D5CqlnusG3xEXpXgfbflG8APXCcfBtRVyiIKT02RBmD7sgIOIonUTSZe7MIZXThkQR0Wg7fL4rZOORBvj5G7eS5Per4z/u6y5u8HzpiDRTuv0k7B8T0dvsJEYLth5L4F+CJwKGkKMAKrpm99Bk4t4JBikMjtuLqP0CFsZeulK0PGR+5VM218PGHj0CZyH1ZDXqdrewf4gH2hKkqQen9DuPgnAm+mjkEagO3TCnhJ4Sd2m4ENE/snXXhND87tKH4LJW2ZtbAJ2bTadby9wP+g0Hd5xnO+WHjGtuC3Aa+ZhZ/aifchojdP0AL+ZjKw3TByXwC+h3rLu0rjhwA8Myh4lcuNXTirUMNoIWvdZaFXIWFXOMYmd1fs3me5+6x3H55cg6iu0ExosNV3S9YDv3CdtK5C+AAf2ud7KKZqijQA2zd14TMFvJp+QjeJ3RU7KVn46z046n74VFfxnRYXseua+Kx2MySTQu6+h0XIerct+AeAY2bgG9sDO9D/RlWM2PX6BuDmycB2w8gd1Ew8C6yIJTOwLKA3Ax8t4LBCASBkradY1pAejjHJvU4qZerAqt01IYKvitFNwEfbqh+DT4dQ/Md1wRQc6EZvQ+GoadIAbH+sgJcViqgi1vpAOksPvibh9ffDJ8tTuEIxJrEvoMh30XFqV8aNlpAnoM9t5r1rgrfHPTWx3w+8vm0Ru4/gfUT/APAPk4PtBpL754B3Ab/HYMOGBbwF9oFluX5zARt68CapTlHXWtfiio27wjFtlsyYWNaNOVgestx9JO8ib5cxUsWKl6i5rX+p1c93wqouQQrozcbdCFziuRnjlAZg+5cFnN+DY6UirJC1bgbEDRx+GTj2ATi3tOBdLTAt7EUGQzK+dEotIW/AZb3bBG+WbcCxpsWuy0OMdV+YRg+2zgHnCvivycF2A8kd4DvAvqQ94Uywp1gyGuwuRSiAWSh68J4eHNCBA6hnrWtxhWNsUjct9jYDyjRUuGfY8EwVK/67wIkzUITA77uo74mTcmG7fMd/P8YuDcD2iT14ckdVw2Wp+4hdi4CvCzjqATi7o7hPx8VNYrcjPd1yqWvYI53czfOb0ya5psoxrff7UTH2PmJ/KP0E/xBr3UXwPwL+crKw3VByPxM18PQQqj3pfJaMw0W1QW+/ntEp4K96cF6ZGlnVWtdSNRyTGm8PnT91YNVlEoUIPmTF3wH8VRu6roNilo7r6WKvpyrB3Sj8NFUagO1uASf34OxCkZdm3RRihwfx9bUWPOcBOH4Rjpb9xL7AEvkuei6RmlbpG6SdoX9aJfMF0hlUuuMZc+XgqW2pmwRv/uey4O8DTp48bDeU3K8DvorKCx6FJeMCvbmulcBi2Mt6cFgPviSXUgRcIZLUHPS6A6mpA6pVBlZNU8jGl89i9+FxC3CYgP/UYHdNT+lSBt+TpKo1Y5YvoybZbqo0BNuX9+DIHlwklwjeZtsAsetywwy88wGY3wov66lTmZZ7h0Fyt0MyVcjdfIDY5K4JfgH1gtI71xrpjqZ1bhK8bcXbcfgecKSA70wethtK7qB8/EMZ3pIJWTQ9BqwaG3bf68E3O/AnuNMdXWSr130hk4K0gdRhLXffwGqV8IyNRRdOvwlcZYM/xcpx7VelMvbvHnClo5OaJg3B9lU9+G4H/rB/8wDu7DEjXcrqLczAW2bhH7fAWzvwCtk/iOrKknGRO/QPJ4XI3UabngTsIgEfnVVvnnZ0vNwMtZhEblvvLoL/d+D7k4ntBpP7RcBbgL1It2RiA0oOF9Vl1Zjs2unBayWs76oXQMBtqZsZMebvlHCMvncu5apjufvi7rHwTAx3LpL/AvD6GejY4I9ZOVWLr2Lm9puAi2m+NAjbr5PwiS78EW7smeIgdn2rO3Nw7RwcvxU+tg1O7MJTJezI4ItLrnh7r7yESe6mfWI7mybC7gX+Q6jZHX+yppwrxjXPsCs84yr6/68Ab55cbDeY3O8DPgn8LemWjAa7qQg26F1WTUAB6ME9UinBDgWsI2xB6/UY0fpi7b6wDJHrxsIyqbH3GLmb2/4DOK4N95qJab7isreqgt7lRpjrnwQ2OzqpadIgbG+S8Aap8t/3ZxBzLgy7zOcyJlLMwzXb4BVb4ZkLcFQXXiiXUhJd8XZX9Edf2pUvolu/DbhEqA9tXKHfXjKLme0SCs+4yneBN002thtM7qA+vrkJdSdi1o1pydignyFu1bjgZjDsJgkbJDyjN9hrrjx2V9pjKEsmFm9PSYVMIfhQeMaFLR/Bd4BzWhXAX8WlrWLd6OU9LM3OOwnSMGyfL+FpPUVsNrHbqSs2j9lvEW0F1sK3t8GVCzC3AId3Yd8CDpfqEq54uyvmbodm7gM+K9THrC+cVZ/G67gS213We8yC12GaGeC8ycd2w8n9clTqz4uoPpBkrvvc04rMehGwZhE+3FPg0ZJCtC5SDw2kjspyDw2sVgnPmLjbAryjBRfHPgkVcmOHdWntil0BfNvRQU2VBmJ7fhFO6ymS87GrzVs2uW9jKbl8ATpl+VQZgP94B+YKaBVwUg92kWUtHNgWQl3+LqG+ZifbsNiGn5kQi325w5wUzBV/twkepgbbDSd3gA8CzyNu0aTEIO0SUgDHaGZPwtkSRAdO76lL+Kz2lHCMayDVp38uYtcSGrytOrAaC890UODfYILeVoRhAF/H0umicDJp0jBsn1Ni+0MGwQfi7E6C3YZ7+uAybeZnRrL7y3TwXZeyKn1Bd/PabZbgkTJzWOg7f64QzQwK2+dOB7YngNyvBv4F9VGcKhZNilUTY1Qcv1EJtFsW4aieyjSAcDim6kCqqzowSPCxOH+VgVU7qOki+EuBDdqqcbmspiL49olZO1WVYQb15ucPmTxpILbPEbB1UU3g/lTicXbzrSE9lXBsQjJXyowvLuMKHdrXT7HefeEZTezfQU3jO0XYngBy7wEfQOUiplg0Zpwx1ZpJDXaXIgVcCHy1A2cW8GLClnOBm9yreM51LfeUgdWU8MwXsAZP7Qxjlwtb19qp4tJ2gNNYMv0mSRqM7a904IxCORa+OLtNrKbVvo3+ScnsnMhRkLsdEqpivZsE/xWswdPpwPYEkDvAz1HTXL6SdBc1ZtnUZVMjDrNJwHEdaHfhQJZmUqoSjqlqtdsKYC9HSe5tVHz9W6h0x3t9VoxdfJaOD/wprq1v+3nARiZXGortewW8saNSgJ+Cymm0QzJ2SGQb/VMJu8i9axTXqKpdldR4vz3vgDnvr4/geyhv9M3Tie0JIfcF4Fzgj1nKLqgK9ioWTUhMJm3BPQJeIWD/rnrb72FUH0hN1cXUAdVhs2Z0uQPVtu/PlLm+vgEmnxL43NtUNzbm0m5CzcHapKl9q0rDsf1KAU/uwmck7ISf2HVIZoF+co9MI5xsubti/jb8fHP+ugZX7wOOEHD19GJ7QsgdVHbBf6KUQAM+NqgUG1iqEvsAL4N2WvCfLXhVF95XqMnGQuGYNv2grhpvNwedwE/wNrHbyuIjeYnK8/2rtue1a1fssaoiuLaluKrmfleUZdKl4dj+TguO7sJ7C3gi/WEQM9ZuD6Smzhymqw2DA6qCfnI3B1V95B6y3udQk4Cd3IbvTje2J4jcAY4HPg/8AdXdUxP0IQYNKYPNopY5fFkLntuFU7vqY8Q7sUTqmuh1VezB1JW23G0rXivQJtSg2okz5URJIYsjFJt0ba8arwxZOVcCb3R0yKRKw7F9eQte2IVTuipZfSf6wzFG+mPKl50efDZVIXfXoK7Pk7A/ybQdKsT4KaFmd1wF2I6SuxDiUSi/8TdQt2C9lPJ0IcQuqOzY3wJ+CbxcSnlPecy7gWNRt+6tUsqvDV1TQE1Sfy6wH4Pu6zADS+AGvS8dJZAO02nDCS310cm3FPBa1H0zrXWfnqZa7rbELPeUrJkO6iW4j7bVfOw927W0fWGfEtjrvt9V3VWzgMLBnYFOiUvGtrmeiO13t+CTXXhTAUexROqu9Edz5rDEueIHqmRj1TZ0Tcj5BlYFcA7wj6sH2wBCut4eMHcQYg9gDynlD4UQO6A+u/0S4DXA3VLK04QQJwA7SynfJYR4HHAB6mXmR6Cm3nmMlLIIXCPmMxqyE3AZsDeDX/a1vx3mWre/K2b7j7Yv6VvapTu4bHXh0QW8p1BzdzycemNfdkjmwY6z1utY77ejPmb9gbb6NF7Pdg9t8MdcWNuqsf1me921tNft8jPUCPa9VJAfSCn3MzdkbA+J7b0KOKGAdcAuhEMyy0XuNtxMcr8blQxwWlt9Gm9KsS2lFK7tUctdSnkbcFu5vlkIcQOwJyoBcF252wZUN76r3H6hlHIBuFkIsRGlDN9Nrm1QNqFm1PsaavSy7sBSSizSl44SSz9pA13oddU3WY/pwn4FHNGDg6XKPJh3VM9XTSpUM0TsermAws7nBXy2ZXzJPRQHrOLC+pSgqnXjKv+Duv+ViN0pGdv2siK2b+rC67rwBwW8qgcHyaVBy1i8fRhyD8XdC1T45UKh8tZXKbahYsxdCPFbwO+jvtD68FI5kFLeJoTYvdxtT/rnpryl3DZC+Rkq8foNqCakxCJHMcAUinNEEsav7sIPC/i/Bby0B4/vwdEoi0cPYpqhGTxVTbHcsaqqt92Fck+vacEXWtBtQ8/1KmpVBahi4fjc3phi6PpcgkofHK1kbA+B7R904f+VVvzBPdinB0egHJEC97SQLnKH/ph7iNxNSLZR2S9nA9e14J8ztqECuQshHoIa8Xm7lPI+IZyeAPRTjpYBtAkhjgOOS73+oJyIQohLCWIWTUxMRvQpgm9UskMf8B/0Q2egV8BiAReW5Ywe7NqD9/fUrk8AdndUNWS9+wwwgQq5XFtW6aQW3NWCXwWUdEARbBfWpwy+GGRICaoORLWB04GTHJ0wnGRsjxDbF5XjA2f2YJcenNxTp90X9UUz17SQruq7qmRy9Z2orJceauKZuzO2bUkidyHELAr850kpLyk33y6E2KO0bPZAZUWDsmYeZRz+SOBW+5xSyvXA+vL8FeKSWrai5lx4JSrOYYM+FuMIKURohDKWclK6rQ8WDSjbZCngVwX8qgcHlSh/cg8eUdbpWKnI3me121XV6z9CTY+AgF8LuDqUGjODWwlG4cLaCuDaN9XSmUG5qn+LCuyOTjK2lxnbB5fY3q/EtpTqm3yPxx2SsS13s2rXoDK5hIBbM7ZjEiV3ocyYTwM3SCk/bPz1JdR4+Wnl8ovG9vOFEB9GDTrtDVw1ykovyf+iFOB81ExHqVkDNuhjI5MpwDetGtu60eDXiqBzwCzf9PsG2v+1B62UwLulCT0BRWgE1VQAs54hF3bWsayqBD6FSLF0NqHu8/AZBKZkbK8gtq82sP1lB7Z900Ka9c7YriQplvvTURG0a4UQPyq3vQcF/IuFEMcC/40aCUBKeb0Q4mLgJ6i7/qZQNsHwchnwDlT6UIo14xJbAfTSV0wwmcDX65bL2gd+E/i+3EgJhYTCDr5DfxvsukI8/9EXP7XBbwY2fRaOuW6Dd5iBKFsh3o560WfkkrGdsc2UYjueCrkSUs91NWU34CxUvqE5TB9KBaubFuZJDXMW01115SxXfcvQJ6EBsoqDY0EXNtXK8bmhsTjlHP0pZXPA11Fp5XcF2p8kA6mQKyEZ2xnby43t2qmQkyF3ogyw84F15bZRDDCF3NUUMLmsmroKAO72hOpeVQF8g0/DuLApFo5vIOpS4EhUKsRqlYztjO16MiXkDmpQ4lWofKjnkQZ+iAPIpQw2iFwuawj8PgWQjqUNfp/rarah5VhWUQBbEUz31acAM/gHl6paOLOoXO+jWd3EriVjO2O7ukwRuYManPgw8GxUJ6ZkDsRKamzPziDwua49x3LYNLdY3e1Yqq8NscGnlPhkSpzRFZc09+0Af8eoXuaYDtlExnbGdhWZMnIH9a3Bv0Dljc5Z/9mhqWFcVnvAyeWypgw2FSwBfzldV2HUP3XwKeS+1nVhXQpg/gb4M9QsiVn6JWM7YztdppDcQbmvAB+iXwmEtZ5qzYRA08Htsvpc11AmgS+XGfrBLx1tMdvUoroyVxl8qqIAMQvHXO+gyGsDWXySsZ2xnSZTSu4F8ClU8z7AkhKEQJOiED7QdOkHT53BJlsBRuG61lWAVCWo6sKGFKCDmr7l04F2ZsnYzthOlSkldy1noMB4OioNyQX6mCVgu3sxl7XOYFNqqlgV19XlvtZVgBQXNmbphFxYgD9HpfxlSZOM7YztsEw5ucOgGzuMFWAC35X7aw42mQNOPeIK4MsmCIFfS0ixfUpgK4Ben8GtBCkWTooba7uwHRT4cyimumRsZ2z7ZRWQe4Fyh36Kink9t9zusm5i7mrMGrCVwLRyQpkELuD3ynpWtW6w2pSiAK52xaybmALYyuDKHvgaKnMgD57Wk4ztjG2/rAJyBwWcK4DrUF8UfzaDwE+xbnxAqTrY5EsTS0kVc+UC6/WQ1VZHsW3w24pgu68pVs5c+f+lqFzfe8kyjGRsZ2y7ZZWQu5ZNqEl6zgWeTz3gu1xW27pJiUfq9WFSxbT4YpM28PW6HWuNKUDMfa3qwn4VNR9XJvbRySYytjO2TZmSuWWqym4oC+cjqClVzbk06s6x4Ztno6oChFLFUl1X32BaVQWwwV/HhTVd2XuBtwHfZARzxVSVCZ1bpqpkbK82bE/53DJV5U7gn1DTqp6HUoLYoEzKSx11BptSsgmGdV1TrbjUwadUF3bW2H8TyrK83L4ZWUYqGdsZ20pWqeVuym6oHNS30G/hxKwa3+x4VV7JHjZVTEvMda0bdw0pQYqVo9dPR32M4M5AG5ZdVonlbkrG9mrAdrbcvXIn8F7UzX0J8BvErZqQdWPHJVMUIDVVLOa66qXLsvEpQdXBpxT3Va//D+p7oCcx6q/MZEmRjO3VjO1suffJ3sDngN8uf/ssHDsWGYpJVlWAFOtGMui26mVV9zVFAaq6r6A+9HsosNHZ02OQVWi5m5KxPa3Y9lnumdwHZEfgEODVwFNIc1mHUYCQZTOs65pi4dRRgJCFcyUqY+MSmpAxYMgqJ3fI2J5ObGdyryy7oV7xfhqwE2ngdw02ubIIQpbNcriuKQoQyyqIKcEmVL71GxlzbN0nmdwflIztacJ2Jvfa8kzUF1MORb2kUHWwKaQArlSxUVs3MQvHpQBVBp8WgYtRFs0Vkb4cq2RyH5CM7WnAdib3oWQOeAzwTtTAlC89LKYAepskbOGMyroJWTaCfvCHFMClBF3gn1Hfkt6IUoRGSyZ3p2RsTzq2M7mPRFrAk4ATWHJpY/HIUIqYbdm4lAD6gW+upww8paSMpSiABv49KCvmg8APyzpPhGRyD0rG9qRiuza5CyEehfJLfgPV2vVSytOFECcDr0O9LQHwHinll8tj3o36rHcBvFVK+bXINSZEAUx5FvA44A3Ao1GgCQ04hcDvUgLwK4EtNvj1ekpc0jcAZZYecBMqTns96otAEycD5J6x7ZOM7UmSYch9D2APKeUPhRA7AD9A+W8vB+6XUn7I2v9xwAXA/sAjgH8HHiOlLALXmEAF0LIDcBiquX8M7MxwCrAcrqsJ/FjamKkAdwNfBr4HXARsrtg3jRIXuWdsByVjexKk9ktMUsrbgNvK9c1CiBuAPQOHvBi4UEq5ANwshNiIQsd3K9d6ImQzcGZZ9gGOA56KimOuIawA0rEcteuakjJmKsA24EbgO2Wbrq/eJRMiGdsxydieZKn0hqoQ4reA30c97p4OvFkIcSRwNfDnUsp7UMpxpXHYLYQVZorketTkQQAvBXZFKcNBqK/lzBHOJjDXcaz7xOe6+uKS5noBLKAGkL6HmvTokmrNngLJ2I5JxvakSTK5CyEeAnweeLuU8j4hxCeAv0bdmb9GzUx/DP2PXC0Dd08IcRzKFJhS0SDaALwD5d4+CdUVB6JimSvtuurlTahJjgQqEnERsJWmZwUsl2RsV5WM7UmQJHIXQsyiwH+elPISACnl7cb/ZwL/Wv68BXiUcfgjgVvtc0op1wPry+MnOC4Zk8WyfNLYthewS7l+DEuKMQs8vtzusnBCYls2ErgWldalgX52+f/dwM0V2zGdkrE9jGRsN1lSBlQF6hF9t5Ty7cb2PcqYJUKIdwAHSCkPE0LsA5zP0qDTpcDe0zvoNEpZi7KCWuVvV7f44pJY2wuWrJYsuAdUM7ZXTDK2l0uGyZZ5Bio/6FqWEj/fAxwOPBF1R34JvN5QiBNRj+0uytX9SuQa/ws8QBPf7V0e2Y3V01ZoRnt/U0r5MHPDCmF7M2oUb7VIE+71SkkT2jqAay2NeIkJQAhx9TheMhmHrKa2wuprrymrre2rqb1Nb2srvkuWLFmyZJk0yeSeJUuWLFMoTSL39eOuwArKamorrL72mrLa2r6a2tvotjYm5p4lS5YsWUYnTbLcs2TJkiXLiGTs5C6EeIEQ4kYhxEYhxAnjrs8oRAhxlhDiDiHEdca2XYQQ3xBC/Lxc7mz89+6y/TcKIZ4/nlrXEyHEo4QQ3xRC3CCEuF4I8bZy+1S2t4pMG7YzriesvVLKsRXUjD43od5XngN+DDxunHUaUbuehXo17zpj2weBE8r1E4C/KdcfV7Z7HvV6301Ae9xtqNDWPYAnles7AD8r2zSV7a3QL1OH7YzrycL1uC33/YGNUspfSCkXgQtRM+9NtEgpL0e9B23Ki1FvQ1IuX2Jsv1BKuSClvBn16Zf9V6KeoxAp5W1Syh+W65sBPbPiVLa3gkwdtjOuJwvX4yb3PYFfGb+neZa9h8vyLcdyuXu5fWr6wJpZcerbG5HV0s6pv8+Tiutxk3vSLHtTLlPRB/bMiqFdHdsmrr0Jslra6ZOpaP8k43rc5J40y96UyO3ll3/0F4DuKLdPfB+4ZlZkitubKKulnVN7nycd1+Mm9+8Dewsh9hJCzKGmjfvSmOu0XPIl4Khy/Sjgi8b2w4QQ80KIvYC9gavGUL9aUs6s+GngBinlh42/prK9FWS1YHsq7/NU4LoBo9IvQo1E3wScOO76jKhNF6A+39ZBPdGPRX265lLg5+VyF2P/E8v23wi8cNz1r9jWZ6Dcz2uAH5XlRdPa3op9M1XYzrieLFznN1SzZMmSZQpl3GGZLFmyZMmyDJLJPUuWLFmmUDK5Z8mSJcsUSib3LFmyZJlCyeSeJUuWLFMomdyzZMmSZQolk3uWLFmyTKFkcs+SJUuWKZT/DyqdxbWVTkUQAAAAAElFTkSuQmCC\n",
"text/plain": "<Figure size 432x288 with 2 Axes>"
"image/png": "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\n",
"text/plain": "<Figure size 864x288 with 3 Axes>"
},
"metadata": {
"needs_background": "light"
......@@ -45,20 +46,27 @@
"\n",
"\n",
"foveation = Foveation([20, 45, 110], [(256, 256), (256, 256), (256, 230)], (1600, 1440))\n",
"layers_mask = foveation.get_layers_mask()\n",
"plt.figure()\n",
"layers_mask = foveation.get_layers_mask((0, 0))\n",
"plt.figure(figsize=(12, 4))\n",
"for i, mask in enumerate(layers_mask):\n",
" colored_mask = torch.zeros(mask.size(0), mask.size(1), 3, device=mask.device)\n",
" c = torch.tensor([[1, 0, 0], [0, 1, 0], [0, 0, 1]], device=mask.device)\n",
" c = torch.tensor([[1, 0, 0], [0, 1, 0], [0, 0, 1], [1, 1, 1]], device=mask.device)\n",
" for bi in range(3):\n",
" region = torch.logical_and(mask > bi, mask < bi + 1)\n",
" colored_mask[region] = c[bi] * (mask[region][..., None] - bi)\n",
" colored_mask[region] = c[bi] + (c[-1] - c[bi]) * (mask[region][..., None] - bi)\n",
" plt.subplot(1, len(layers_mask), i + 1)\n",
" img.plot(colored_mask)\n",
" n_skipped = torch.sum(mask < 0)\n",
" n_tot = len(mask.flatten())\n",
" print (f\"{n_skipped}({n_skipped / n_tot * 100:.2f}%) pixels in layer {i} are masked as skipped\")"
" print (f\"Layer {i}: {n_skipped}({n_skipped / n_tot * 100:.2f}%) pixels are masked as skipped, {n_tot - n_skipped} pixels need to be inferred\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
......
......@@ -2,17 +2,9 @@
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"execution_count": null,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Set CUDA:0 as current device.\n"
]
}
],
"outputs": [],
"source": [
"import sys\n",
"import os\n",
......@@ -129,27 +121,9 @@
},
{
"cell_type": "code",
"execution_count": 3,
"execution_count": null,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0 torch.Size([4, 3, 400, 400]) torch.Size([4, 400, 400, 3]) torch.Size([4, 400, 400, 3])\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": "<Figure size 864x468 with 4 Axes>"
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"outputs": [],
"source": [
"from data.spherical_view_syn import SphericalViewSynDataset\n",
"from data.loader import FastDataLoader\n",
......@@ -194,22 +168,23 @@
"#DATA_DESC_FILE = f'{rootdir}/data/lobby_fovea_2021.01.18/train.json'\n",
"#DATA_DESC_FILE = f'{rootdir}/data/__new/street_fovea_r360x80_t1.0/train1.json'\n",
"#DATA_DESC_FILE = f'{rootdir}/data/__new/stones_fovea_r360x80_t1.0/train1.json'\n",
"DATA_DESC_FILE = f'{rootdir}/data/__new/lobby_periph_r360x180_t1.0/train1.json'\n",
"#DATA_DESC_FILE = f'{rootdir}/data/__new/lobby_periph_r360x180_t1.0/train1.json'\n",
"DATA_DESC_FILE = f'{rootdir}/data/__new/classroom_all/nerf_cvt.json'\n",
"\n",
"\n",
"dataset = SphericalViewSynDataset(DATA_DESC_FILE)\n",
"dataset = SphericalViewSynDataset(DATA_DESC_FILE, load_views=range(12))\n",
"dataset.set_patch_size(1)\n",
"res = dataset.view_res\n",
"data_loader = FastDataLoader(dataset, res[0] * res[1], shuffle=False)\n",
"\n",
"selector = torch.arange(res[0] * res[1]).reshape(res[0], res[1])[::5, ::5].flatten()\n",
"\n",
"for ri in range(0, 9):\n",
"for ri in range(0, 4):\n",
" r = ri * 2 + 1\n",
" p = None\n",
" centers = None\n",
" pixels = None\n",
" idx_range = list(range(6, 12)) #+ list(range(24, 30)) + list(range(42, 48))\n",
" idx_range = list(range(12)) #+ list(range(24, 30)) + list(range(42, 48))\n",
" idx = 0\n",
" for indices, patches, rays_o, rays_d in data_loader:\n",
" if idx not in idx_range:\n",
......@@ -225,9 +200,9 @@
" pixels = pixels_ if pixels is None else np.concatenate((pixels, pixels_), axis=0)\n",
" idx += 1\n",
"\n",
" if ri % 2 == 0:\n",
" plt.figure(facecolor='white', figsize=(20, 10))\n",
" ax = plt.subplot(1, 2, ri % 2 + 1, projection='3d')\n",
" plt.figure(facecolor='white', figsize=(20, 20))\n",
" ax = plt.axes(projection='3d')\n",
" #ax = plt.subplot(1, 2, ri % 2 + 1, projection='3d')\n",
" plt.xlabel('x')\n",
" plt.ylabel('z')\n",
" plt.title('r = %f' % r)\n",
......@@ -235,19 +210,13 @@
" ax.scatter(p[:, 0], p[:, 2], p[:, 1], color=pixels, s=0.5)\n",
" ax.view_init(elev=0, azim=-90)\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3.8.5 64-bit ('base': conda)",
"name": "python385jvsc74a57bd082066b63b621a9e3d15e3b7c11ca76da6238eff3834294910d715044bd0561e5"
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
......@@ -263,5 +232,5 @@
}
},
"nbformat": 4,
"nbformat_minor": 2
}
\ No newline at end of file
"nbformat_minor": 4
}
#/usr/bin/bash
datadir='data/__new/lobby_fovea_r360x80_t1.0'
trainset='data/__new/lobby_fovea_r360x80_t1.0/train1.json'
testset='data/__new/lobby_fovea_r360x80_t1.0/test1.json'
epochs=50
n_nets=$1
nf=$2
n_layers=$3
configid="eval@snerffast${n_nets}-rgb_e6_fc${nf}x${n_layers}_d1.20-6.00_s64_~p"
if [ ! -f "$datadir/$configid/model-epoch_$epochs.pth" ]; then
cont_epoch=0
for ((i=$epochs-1;i>0;i--)) do
if [ -f "$datadir/$configid/model-epoch_$i.pth" ]; then
cont_epoch=$i
break
fi
done
if [ ${cont_epoch} -gt 0 ]; then
python run_spherical_view_syn.py $trainset -e $epochs -m $configid/model-epoch_${cont_epoch}.pth
else
python run_spherical_view_syn.py $trainset -i $configid -e $epochs
fi
fi
if ! ls $datadir/$configid/output_$epochs/perf_* >/dev/null 2>&1; then
python run_spherical_view_syn.py $trainset -t -m $configid/model-epoch_$epochs.pth -o perf
python run_spherical_view_syn.py $testset -t -m $configid/model-epoch_$epochs.pth -o perf
fi
\ No newline at end of file
......@@ -23,7 +23,7 @@ with open(data_desc_path, 'r') as fp:
dataset_desc['cam_params'] = view.CameraParam.convert_camera_params(
dataset_desc['cam_params'],
(dataset_desc['view_res']['x'], dataset_desc['view_res']['x']))
(dataset_desc['view_res']['y'], dataset_desc['view_res']['x']))
dataset_desc['view_rots'] = [
view.euler_to_matrix([rot[1], rot[0], 0])
......
......@@ -9,12 +9,10 @@ from typing import Mapping, List
sys.path.append(os.path.abspath(sys.path[0] + '/../'))
parser = argparse.ArgumentParser()
parser.add_argument('--device', type=int, default=0,
help='Which CUDA device to use.')
parser.add_argument('--batch-size', type=str,
help='Resolution')
parser.add_argument('model', type=str,
help='Path of model to export')
parser.add_argument('-b', '--batch-size', type=str, help='Resolution')
parser.add_argument('-o', '--output', type=str)
parser.add_argument('--device', type=int, default=0, help='Which CUDA device to use.')
parser.add_argument('model', type=str, help='Path of model to export')
opt = parser.parse_args()
# Select device
......@@ -28,30 +26,34 @@ from utils import device
from configs.spherical_view_syn import SphericalViewSynConfig
dir_path, model_file = os.path.split(opt.model)
config_id = os.path.split(dir_path)[-1]
batch_size = eval(opt.batch_size)
batch_size_str = opt.batch_size.replace('*', 'x')
outdir = f"output_{int(os.path.splitext(model_file)[0][12:])}"
os.chdir(dir_path)
misc.create_dir(outdir)
if not opt.output:
epochs = os.path.splitext(model_file)[0][12:]
outdir = f"{dir_path}/output_{epochs}"
output = os.path.join(outdir, f"net@{batch_size_str}.onnx")
misc.create_dir(outdir)
else:
output = opt.output
config = SphericalViewSynConfig()
def load_net(path):
id=os.path.split(dir_path)[-1]#os.path.splitext(os.path.basename(path))[0]
config.from_id(id)
def load_net():
config = SphericalViewSynConfig()
config.from_id(config_id)
config.SAMPLE_PARAMS['perturb_sample'] = False
config.name += batch_size_str
config.print()
net = config.create_net().to(device.default())
netio.load(path, net)
return net, id
netio.load(opt.model, net)
return net
def export_net(net: torch.nn.Module, name: str,
input: Mapping[str, List[int]], output_names: List[str]):
outpath = os.path.join(outdir, f"{name}@{batch_size_str}.onnx")
def export_net(net: torch.nn.Module, path: str, input: Mapping[str, List[int]],
output_names: List[str]):
input_tensors = tuple([
torch.empty(size, device=device.default())
for size in input.values()
......@@ -59,21 +61,25 @@ def export_net(net: torch.nn.Module, name: str,
onnx.export(
net,
input_tensors,
outpath,
path,
export_params=True, # store the trained parameter weights inside the model file
verbose=True,
opset_version=9, # the ONNX version to export the model to
do_constant_folding=True, # whether to execute constant folding
input_names=input.keys(), # the model's input names
output_names=output_names # the model's output names
do_constant_folding=True, # whether to execute constant folding
input_names=list(input.keys()), # the model's input names
output_names=output_names # the model's output names
)
print('Model exported to ' + outpath)
print('Model exported to ' + path)
if __name__ == "__main__":
with torch.no_grad():
net: SnerfFast = load_net(model_file)[0]
export_net(SnerfFastExport(net), 'net', {
'Encoded': [batch_size, net.n_samples, net.coord_encoder.out_dim],
'Depths': [batch_size, net.n_samples]
}, ['Colors'])
\ No newline at end of file
net: SnerfFast = load_net()
export_net(
SnerfFastExport(net),
output,
{
'Encoded': [batch_size, net.n_samples, net.coord_encoder.out_dim],
'Depths': [batch_size, net.n_samples]
},
['Colors'])
import sys
import os
import json
rootdir = os.path.abspath(sys.path[0] + '/../')
datadir = f"{rootdir}/data/__new/classroom_fovea_r360x80_t0.6"
n_nets_arr = [ 1, 2, 4, 8 ]
nf_arr = [ 64, 128, 256, 512, 1024 ]
n_layers_arr = [ 2, 4, 8 ]
head = "Nets,Layers," + ",".join([f"{val}" for val in nf_arr])
perf_train_table = []
perf_test_table = []
perf_time_table = []
for n_nets in n_nets_arr:
for n_layers in n_layers_arr:
perf_train_row = []
perf_test_row = []
perf_time_row = []
for nf in nf_arr:
configid = f"eval@snerffast{n_nets}-rgb_e6_fc{nf}x{n_layers}_d1.00-7.00_s64_~p"
outputdir = f"{datadir}/{configid}/output_50"
if not os.path.exists(outputdir):
perf_train_row.append("-")
perf_test_row.append("-")
perf_time_row.append("-")
continue
perf_test_found=False
perf_train_found=False
for file in os.listdir(outputdir):
if file.startswith("perf_r120x80_test"):
if perf_test_found:
os.remove(f"{outputdir}/{file}")
else:
perf_test_row.append(os.path.splitext(file)[0].split("_")[-1])
perf_test_found=True
elif file.startswith("perf_r120x80"):
if perf_train_found:
os.remove(f"{outputdir}/{file}")
else:
perf_train_row.append(os.path.splitext(file)[0].split("_")[-1])
perf_train_found=True
if perf_train_found == False:
perf_train_row.append("-")
if perf_test_found == False:
perf_test_row.append("-")
# Collect time values
time_file = f"{datadir}/eval_trt/time/eval_{n_nets}x{nf}x{n_layers}.json"
if not os.path.exists(time_file):
perf_time_row.append("-")
else:
with open(time_file) as fp:
time_data = json.load(fp)
time = 0
for item in time_data:
time += item['computeMs']
time /= len(time_data)
perf_time_row.append(f"{time:.1f}")
perf_train_table.append(perf_train_row)
perf_test_table.append(perf_test_row)
perf_time_table.append(perf_time_row)
perf_train_content = head + "\n"
for i, row in enumerate(perf_train_table):
if i % len(n_layers_arr) == 0:
perf_train_content += f"{n_nets_arr[i // len(n_layers_arr)]}"
perf_train_content += f",{n_layers_arr[i % len(n_layers_arr)]},"
perf_train_content += ",".join(row) + "\n"
perf_test_content = head + "\n"
for i, row in enumerate(perf_test_table):
if i % len(n_layers_arr) == 0:
perf_test_content += f"{n_nets_arr[i // len(n_layers_arr)]}"
perf_test_content += f",{n_layers_arr[i % len(n_layers_arr)]},"
perf_test_content += ",".join(row) + "\n"
perf_time_content = head + "\n"
for i, row in enumerate(perf_time_table):
if i % len(n_layers_arr) == 0:
perf_time_content += f"{n_nets_arr[i // len(n_layers_arr)]}"
perf_time_content += f",{n_layers_arr[i % len(n_layers_arr)]},"
perf_time_content += ",".join(row) + "\n"
with open(f"{datadir}/eval_perf.csv", "w") as fp:
fp.write("Train:\n")
fp.write(perf_train_content)
fp.write("Test:\n")
fp.write(perf_test_content)
fp.write("Time:\n")
fp.write(perf_time_content)
\ No newline at end of file
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment