diff --git a/.gitignore b/.gitignore index d93792c2..6ba389ad 100644 --- a/.gitignore +++ b/.gitignore @@ -1,8 +1,12 @@ __MACOSX __pycache__ +.DS_Store +.ipynb_checkpoints yolov4-deepsort yolov5-deepsort .mypy_cache .idea -.ipynb_checkpoints +output +.apperception_cache +env diff --git a/amber_videos/traffic-scene-mini.mp4 b/amber_videos/traffic-scene-mini.mp4 new file mode 100644 index 00000000..cb985f70 Binary files /dev/null and b/amber_videos/traffic-scene-mini.mp4 differ diff --git a/apperception/camera.py b/apperception/camera.py new file mode 100644 index 00000000..f6670a5e --- /dev/null +++ b/apperception/camera.py @@ -0,0 +1,15 @@ +import uuid +from dataclasses import dataclass +from typing import List, Optional + +from camera_config import CameraConfig + + +@dataclass +class Camera: + id: str + configs: List[CameraConfig] + + def __init__(self, config: List[CameraConfig], id: Optional[str] = None): + self.id = str(uuid.uuid4()) if id is None else id + self.configs = config diff --git a/apperception/camera_config.py b/apperception/camera_config.py new file mode 100644 index 00000000..c3b50d05 --- /dev/null +++ b/apperception/camera_config.py @@ -0,0 +1,40 @@ +from dataclasses import dataclass +from typing import List, Tuple + +Float3 = Tuple[float, float, float] +Float4 = Tuple[float, float, float, float] + + +@dataclass(frozen=True) +class CameraConfig: + frame_id: str + frame_num: int + filename: str + camera_translation: List[float] # float[3] + camera_rotation: List[float] # float[4] + camera_intrinsic: List[List[float]] # float[3][3] + ego_translation: List[float] # float[3] + ego_rotation: List[float] # float[4] + timestamp: str + + +def fetch_camera_config(scene_name: str, sample_data): + all_frames = sample_data[ + (sample_data["scene_name"] == scene_name) + & (sample_data["filename"].str.contains("/CAM_FRONT/", regex=False)) + ].sort_values(by="frame_order") + + return [ + CameraConfig( + frame_id=frame.sample_token, + frame_num=frame.frame_order, + filename=frame.filename, + camera_translation=frame.camera_translation, + camera_rotation=frame.camera_rotation, + camera_intrinsic=frame.camera_intrinsic, + ego_translation=frame.ego_translation, + ego_rotation=frame.ego_rotation, + timestamp=frame.timestamp, + ) + for frame in all_frames.itertuples(index=False) + ] diff --git a/apperception/lens.py b/apperception/lens.py index ea68cf61..59df6775 100644 --- a/apperception/lens.py +++ b/apperception/lens.py @@ -1,3 +1,5 @@ +from __future__ import annotations + from math import radians import numpy as np @@ -36,6 +38,9 @@ def world_to_pixel(self, world_coord, depth): """ return None + def __eq__(self, other): + return self.__dict__ == other.__dict__ + class VRLens(Lens): def __init__(self, resolution, cam_origin, yaw, roll, pitch): @@ -219,6 +224,18 @@ def __init__(self, resolution, cam_origin, field_of_view, skew_factor): [[self.focal_x, self.alpha, cam_x, 0], [0, self.focal_y, cam_y, 0], [0, 0, 1, 0]] ) + def __eq__(self, other): + return ( + isinstance(other, PinholeLens) + and self.fov == other.fov + and self.focal_x == other.focal_x + and self.focal_y == other.focal_y + and self.cam_origin == other.cam_origin + and self.alpha == other.alpha + and (self.inv_transform == other.inv_transform).all() + and (self.transform == other.transform).all() + ) + def pixel_to_world(self, pixel_coord, depth): """ Translate pixel coordinates to world coordinates. diff --git a/apperception/new_compute_lib.py b/apperception/new_compute_lib.py new file mode 100644 index 00000000..c6bef7d4 --- /dev/null +++ b/apperception/new_compute_lib.py @@ -0,0 +1,18 @@ +import numpy as np + + +def compute_heading(trajectories): + headings = [] + for traj in trajectories: + traj = traj[0] + heading = [None] + for j in range(1, len(traj)): + prev_pos = traj[j - 1] + current_pos = traj[j] + heading.append(0) + if current_pos[1] != prev_pos[1]: + heading[j] = np.arctan2(current_pos[1] - prev_pos[1], current_pos[0] - prev_pos[0]) + heading[j] *= 180 / np.pi # convert to degrees from radian + heading[j] = (heading[j] + 360) % 360 # converting such that all headings are positive + headings.append(heading) + return headings diff --git a/apperception/new_db.py b/apperception/new_db.py new file mode 100644 index 00000000..34cfa8c3 --- /dev/null +++ b/apperception/new_db.py @@ -0,0 +1,385 @@ +import datetime +from typing import Tuple + +import psycopg2 +from camera import Camera +from new_util import (add_recognized_objs, get_video, recognize, + video_fetch_reformat) +from pypika import Column, CustomFunction, Table +# https://github.com/kayak/pypika/issues/553 +# workaround. because the normal Query will fail due to mobility db +from pypika.dialects import Query, SnowflakeQuery + +CAMERA_TABLE = "Cameras" +TRAJ_TABLE = "Item_General_Trajectory" +BBOX_TABLE = "General_Bbox" + + +class Database: + def __init__(self): + # should setup a postgres in docker first + self.con = psycopg2.connect( + dbname="mobilitydb", user="docker", host="localhost", port="25432", password="docker" + ) + self.cur = self.con.cursor() + + # The start time of the database access object + self.start_time = datetime.datetime(2021, 6, 8, 7, 10, 28) + + def reset(self): + self._create_camera_table() + self._create_item_general_trajectory_table() + self._create_general_bbox_table() + self._create_index() + + def _create_camera_table(self): + # drop old + q1 = SnowflakeQuery.drop_table(CAMERA_TABLE).if_exists() + + # create new + q2 = SnowflakeQuery.create_table(CAMERA_TABLE).columns( + Column("cameraId", "TEXT"), + Column("frameId", "TEXT"), + Column("frameNum", "Int"), + Column("fileName", "TEXT"), + Column("cameraTranslation", "geometry"), + Column("cameraRotation", "real[4]"), + Column("cameraIntrinsic", "real[3][3]"), + Column("egoTranslation", "geometry"), + Column("egoRotation", "real[4]"), + Column("timestamp", "TEXT"), + ) + + self.cur.execute(q1.get_sql()) + self.cur.execute(q2.get_sql()) + self.con.commit() + + def _create_general_bbox_table(self): + # drop old + q1 = SnowflakeQuery.drop_table(BBOX_TABLE).if_exists() + + # create new + q2 = """ + CREATE TABLE General_Bbox( + itemId TEXT, + cameraId TEXT, + trajBbox stbox, + FOREIGN KEY(itemId) + REFERENCES Item_General_Trajectory(itemId) + ); + """ + + self.cur.execute(q1.get_sql()) + self.cur.execute(q2) + self.con.commit() + + def _create_item_general_trajectory_table(self): + # drop old + q1 = "DROP TABLE IF EXISTS Item_General_Trajectory CASCADE;" + + # create new + q2 = """ + CREATE TABLE Item_General_Trajectory( + itemId TEXT, + cameraId TEXT, + objectType TEXT, + frameId TEXT, + color TEXT, + trajCentroids tgeompoint, + largestBbox stbox, + PRIMARY KEY (itemId) + ); + """ + + self.cur.execute(q1) + self.cur.execute(q2) + self.con.commit() + + def _create_index(self): + self.cur.execute( + """ + CREATE INDEX IF NOT EXISTS traj_idx + ON Item_General_Trajectory + USING GiST(trajCentroids); + """ + ) + self.cur.execute( + """ + CREATE INDEX IF NOT EXISTS item_idx + ON General_Bbox(itemId); + """ + ) + self.cur.execute( + """ + CREATE INDEX IF NOT EXISTS traj_bbox_idx + ON General_Bbox + USING GiST(trajBbox); + """ + ) + self.con.commit() + + def insert_cam(self, camera: Camera): + values = [ + f"""( + '{camera.id}', + '{config.frame_id}', + {config.frame_num}, + '{config.filename}', + 'POINT Z ({' '.join(map(str, config.camera_translation))})', + ARRAY{config.camera_rotation}, + ARRAY{config.camera_intrinsic}, + 'POINT Z ({' '.join(map(str, config.ego_translation))})', + ARRAY{config.ego_rotation}, + '{config.timestamp}' + )""" + for config in camera.configs + ] + + self.cur.execute( + f""" + INSERT INTO Cameras ( + cameraId, + frameId, + frameNum, + fileName, + cameraTranslation, + cameraRotation, + cameraIntrinsic, + egoTranslation, + egoRotation, + timestamp + ) + VALUES {','.join(values)}; + """ + ) + + print("New camera inserted successfully.........") + self.conn.commit() + + def retrieve_cam(self, query: Query = None, camera_id: str = ""): + """ + Called when executing update commands (add_camera, add_objs ...etc) + """ + + return ( + query + self._select_cam_with_camera_id(camera_id) + if query + else self._select_cam_with_camera_id(camera_id) + ) # UNION + + def _select_cam_with_camera_id(self, camera_id: str): + """ + Select cams with certain world id + """ + cam = Table(CAMERA_TABLE) + q = SnowflakeQuery.from_(cam).select("*").where(cam.id == camera_id) + return q + + def filter_cam(self, query: Query, condition: str): + """ + Called when executing filter commands (predicate, interval ...etc) + """ + return SnowflakeQuery.from_(query).select("*").where(eval(condition)) + + def get_cam(self, query: Query): + """ + Execute sql command rapidly + """ + + # hack + q = ( + "SELECT cameraId, ratio, ST_X(origin), ST_Y(origin), ST_Z(origin), ST_X(focalpoints), ST_Y(focalpoints), fov, skev_factor" + + f" FROM ({query.get_sql()}) AS final" + ) + + # print(q) + + self.cur.execute(q) + return self.cur.fetchall() + + def get_len(self, query: Query): + """ + Execute sql command rapidly + """ + + # hack + q = ( + "SELECT ratio, ST_X(origin), ST_Y(origin), ST_Z(origin), fov, skev_factor" + + f" FROM ({query.get_sql()}) AS final" + ) + + self.cur.execute(q) + return self.cur.fetchall() + + def insert_bbox_traj(self, camera: Camera, annotation): + tracking_results = recognize(camera.configs, annotation) + add_recognized_objs(self.con, tracking_results, self.start_time, camera.id) + + def retrieve_bbox(self, query: Query = None, camera_id: str = ""): + bbox = Table(BBOX_TABLE) + q = SnowflakeQuery.from_(bbox).select("*").where(bbox.cameraId == camera_id) + return query + q if query else q # UNION + + def retrieve_traj(self, query: Query = None, camera_id: str = ""): + traj = Table(TRAJ_TABLE) + q = SnowflakeQuery.from_(traj).select("*").where(traj.cameraId == camera_id) + return query + q if query else q # UNION + + def get_bbox(self, query: Query): + self.cur.execute(query.get_sql()) + return self.cur.fetchall() + + def get_traj(self, query: Query): + # hack + query = ( + "SELECT asMFJSON(trajCentroids)::json->'coordinates'" + + f" FROM ({query.get_sql()}) as final" + ) + + print("get_traj", query) + self.cur.execute(query) + return self.cur.fetchall() + + def get_traj_key(self, query: Query): + q = SnowflakeQuery.from_(query).select("itemid") + print("get_traj_key", q.get_sql()) + self.cur.execute(q.get_sql()) + return self.cur.fetchall() + + def get_bbox_geo(self, query: Query): + Xmin = CustomFunction("Xmin", ["stbox"]) + Ymin = CustomFunction("Ymin", ["stbox"]) + Zmin = CustomFunction("Zmin", ["stbox"]) + Xmax = CustomFunction("Xmax", ["stbox"]) + Ymax = CustomFunction("Ymax", ["stbox"]) + Zmax = CustomFunction("Zmax", ["stbox"]) + + q = SnowflakeQuery.from_(query).select( + Xmin(query.trajBbox), + Ymin(query.trajBbox), + Zmin(query.trajBbox), + Xmax(query.trajBbox), + Ymax(query.trajBbox), + Zmax(query.trajBbox), + ) + self.cur.execute(q.get_sql()) + return self.cur.fetchall() + + def get_time(self, query: Query): + Tmin = CustomFunction("Tmin", ["stbox"]) + q = SnowflakeQuery.from_(query).select(Tmin(query.trajBbox)) + self.cur.execute(q.get_sql()) + return self.cur.fetchall() + + def get_distance(self, query: Query, start: str, end: str): + atPeriodSet = CustomFunction("atPeriodSet", ["centroids", "param"]) + cumulativeLength = CustomFunction("cumulativeLength", ["input"]) + q = SnowflakeQuery.from_(query).select( + cumulativeLength(atPeriodSet(query.trajCentroids, "{[%s, %s)}" % (start, end))) + ) + + self.cur.execute(q.get_sql()) + return self.cur.fetchall() + + def get_speed(self, query, start, end): + atPeriodSet = CustomFunction("atPeriodSet", ["centroids", "param"]) + speed = CustomFunction("speed", ["input"]) + + q = SnowflakeQuery.from_(query).select( + speed(atPeriodSet(query.trajCentroids, "{[%s, %s)}" % (start, end))) + ) + + self.cur.execute(q.get_sql()) + return self.cur.fetchall() + + def filter_traj_type(self, query: Query, object_type: str): + return SnowflakeQuery.from_(query).select("*").where(query.objecttype == object_type) + + def filter_traj_heading(self, query: Query, lessThan=float("inf"), greaterThan=float("-inf")): + return ( + SnowflakeQuery.from_(query) + .select("*") + .where(query.heading <= lessThan) + .where(query.heading >= greaterThan) + ) + + def filter_relative_to_type( + self, + query: Query, + x_range: Tuple[float, float], + y_range: Tuple[float, float], + z_range: Tuple[float, float], + type: str, + ): + # TODO: Make also work with objects of other types + cameras = Table(CAMERA_TABLE) + getX = CustomFunction("getX", ["tgeompoint"]) + getY = CustomFunction("getX", ["tgeompoint"]) + getZ = CustomFunction("getX", ["tgeompoint"]) + + ST_X = CustomFunction("ST_X", ["geometry"]) + ST_Y = CustomFunction("ST_Y", ["geometry"]) + ST_Z = CustomFunction("ST_Z", ["geometry"]) + q = ( + SnowflakeQuery.from_(query) + .join(cameras) + .cross() + .select(query.star) + .distinct() + .where(x_range[0] <= (ST_X(cameras.origin) - getX(query.trajCentroids))) + .where((ST_X(cameras.origin) - getX(query.trajCentroids)) <= x_range[1]) + .where(y_range[0] <= (ST_Y(cameras.origin) - getY(query.trajCentroids))) + .where((ST_Y(cameras.origin) - getY(query.trajCentroids)) <= y_range[1]) + .where(z_range[0] <= (ST_Z(cameras.origin) - getZ(query.trajCentroids))) + .where((ST_Z(cameras.origin) - getZ(query.trajCentroids)) <= z_range[1]) + ) + # print(str(q)) + return q + + def filter_traj_volume(self, query: Query, volume: str): + overlap = CustomFunction("overlap", ["bbox1", "bbox2"]) + return SnowflakeQuery.from_(query).select("*").where(overlap(query.largestBbox, volume)) + + def interval(self, query, start, end): + # https://pypika.readthedocs.io/en/latest/4_extending.html + Tmin = CustomFunction("Tmin", ["stbox"]) + Tmax = CustomFunction("Tmax", ["stbox"]) + return ( + SnowflakeQuery.from_(query) + .select("*") + .where((start <= Tmin(query.trajBbox)) & (Tmax(query.trajBbox) < end)) + ) + + def get_video(self, query, cams, boxed): + bbox = Table(BBOX_TABLE) + Xmin = CustomFunction("Xmin", ["stbox"]) + Ymin = CustomFunction("Ymin", ["stbox"]) + Zmin = CustomFunction("Zmin", ["stbox"]) + Xmax = CustomFunction("Xmax", ["stbox"]) + Ymax = CustomFunction("Ymax", ["stbox"]) + Zmax = CustomFunction("Zmax", ["stbox"]) + Tmin = CustomFunction("Tmin", ["stbox"]) + + query = ( + SnowflakeQuery.from_(query) + .inner_join(bbox) + .using("itemid") + .select( + query.itemid, + Xmin(bbox.trajBbox), + Ymin(bbox.trajBbox), + Zmin(bbox.trajBbox), + Xmax(bbox.trajBbox), + Ymax(bbox.trajBbox), + Zmax(bbox.trajBbox), + Tmin(bbox.trajBbox), + ) + ) + + self.cur.execute(query.get_sql()) + fetched_meta = self.cur.fetchall() + fetched_meta = video_fetch_reformat(fetched_meta) + get_video(fetched_meta, cams, self.start_time, boxed) + + +Database.insert_bbox_traj.comparators = {"annotation": lambda df: df[0].equals(df[1])} diff --git a/apperception/new_readme.md b/apperception/new_readme.md new file mode 100644 index 00000000..d1b4fc26 --- /dev/null +++ b/apperception/new_readme.md @@ -0,0 +1,24 @@ +# New query engine + +## Prerequisite +- Create a docker container for mobilitydb + +``` +docker volume create mobilitydb_data +docker run --name "mobilitydb" -d -p 25432:5432 -v mobilitydb_data:/var/lib/postgresql mobilitydb/mobilitydb +``` + +## Design + +### Data Persistency +### Query Optimization + +- Each world will have access to the list of operations done since the first world. +- Each item in the DB will have a row indicating the world id that creates it. +- When call operations on a world, we do not execute them right away. Instead, we collect these operations to be a sequence of operations. +- When we call get-data method (such as selectKey / get_trajectories) we construct an SQL - query based on the sequence of operations. +- When see predicates, we nest the query of the old world. +- When see update, we concat the query of the old world. +- We can add cache on each node to accelerate. + + diff --git a/apperception/new_util.py b/apperception/new_util.py new file mode 100644 index 00000000..346ca991 --- /dev/null +++ b/apperception/new_util.py @@ -0,0 +1,407 @@ +import ast +import datetime +import os +from typing import Dict, List, Tuple + +import lens +import numpy as np +import point +import uncompyle6 +from box import Box +from camera_config import CameraConfig +from pyquaternion import Quaternion +from scenic_util import bbox_to_data3d, convert_timestamps, join +from tracked_object import TrackedObject +from video_context import Camera +from video_util import (convert_datetime_to_frame_num, get_video_box, + get_video_roi) +from world_executor import (create_transform_matrix, + reformat_fetched_world_coords, world_to_pixel) + + +def create_camera(cam_id, fov): + # Let's define some attribute for constructing the world first + name = "traffic_scene" # world name + video_file = "./amber_videos/traffic-scene-mini.mp4" # example video file + lens_attrs = {"fov": fov, "cam_origin": (0, 0, 0), "skew_factor": 0} + point_attrs = { + "p_id": "p1", + "cam_id": cam_id, + "x": 0, + "y": 0, + "z": 0, + "time": None, + "type": "pos", + } + camera_attrs = {"ratio": 0.5} + fps = 30 + + fov, res, cam_origin, skew_factor = ( + lens_attrs["fov"], + [1280, 720], + lens_attrs["cam_origin"], + lens_attrs["skew_factor"], + ) + + cam_lens = lens.PinholeLens(res, cam_origin, fov, skew_factor) + + pt_id, cam_id, x, y, z, time, pt_type = ( + point_attrs["p_id"], + point_attrs["cam_id"], + point_attrs["x"], + point_attrs["y"], + point_attrs["z"], + point_attrs["time"], + point_attrs["type"], + ) + location = point.Point(pt_id, cam_id, (x, y, z), time, pt_type) + + ratio = camera_attrs["ratio"] + + # Ingest the camera to the world + return Camera( + cam_id=cam_id, + point=location, + ratio=ratio, + video_file=video_file, + metadata_id=name + "_" + cam_id, + lens=cam_lens, + ) + + +def video_fetch_reformat(fetched_meta): + result = {} + for meta in fetched_meta: + item_id, coordinates, timestamp = meta[0], meta[1:-1], meta[-1] + if item_id in result: + result[item_id][0].append(coordinates) + result[item_id][1].append(timestamp) + else: + result[item_id] = [[coordinates], [timestamp]] + + return result + + +def get_video(metadata_results, cams, start_time, boxed): + # The cam nodes are raw data from the database + # TODO: I forget why we used the data from the db instead of directly fetch + # from the world + + video_files = [] + for cam in cams: + cam_id, ratio, cam_x, cam_y, cam_z, focal_x, focal_y, fov, skew_factor = ( + cam.cam_id, + cam.ratio, + cam.lens.cam_origin[0], + cam.lens.cam_origin[1], + cam.lens.cam_origin[2], + cam.lens.focal_x, + cam.lens.focal_y, + cam.lens.fov, + cam.lens.alpha, + ) + cam_video_file = cam.video_file + transform_matrix = create_transform_matrix(focal_x, focal_y, cam_x, cam_y, skew_factor) + + for item_id, vals in metadata_results.items(): + world_coords, timestamps = vals + # print("timestamps are", timestamps) + world_coords = reformat_fetched_world_coords(world_coords) + cam_coords = world_to_pixel(world_coords, transform_matrix) + + vid_times = convert_datetime_to_frame_num(start_time, timestamps) + # print(vid_times) + + vid_fname = "./output/" + cam.metadata_id + item_id + ".mp4" + # print(vid_fname) + if boxed: + get_video_box(vid_fname, cam_video_file, cam_coords, vid_times) + else: + get_video_roi(vid_fname, cam_video_file, cam_coords, vid_times) + video_files.append(vid_fname) + print("output video files", ",".join(video_files)) + return video_files + + +def compile_lambda(pred): + s = uncompyle6.deparse_code2str(pred.__code__, out=open(os.devnull, "w")) + tree = ast.parse(s) + # print(pred.__code__) + # print(s) + # apprint(tree) + subtree = tree.body[0] + assert isinstance(subtree, ast.Return) + + x_range = [] + y_range = [] + + if isinstance(subtree.value, ast.BoolOp): + left_node = subtree.value.values[0] + right_node = subtree.value.values[1] + + # parse left + if isinstance(left_node, ast.Compare): + cmp_node = left_node + left = cmp_node.left + ops = cmp_node.ops + comparators = cmp_node.comparators + + if ( + len(comparators) == 2 + and isinstance(comparators[0], ast.Attribute) + and comparators[0].attr == "x" + ): + if isinstance(left, ast.BinOp): + if isinstance(left.left, ast.Attribute) and left.left.attr == "x": + if isinstance(left.op, ast.Sub): + assert isinstance(left.right, ast.Num) + x_range.append(-left.right.n) + elif isinstance(left.op, ast.Add): + assert isinstance(left.right, ast.Num) + x_range.append(left.right.n) + + if isinstance(comparators[-1], ast.BinOp): + right = comparators[-1] + if isinstance(right.left, ast.Attribute) and right.left.attr == "x": + if isinstance(right.op, ast.Sub): + assert isinstance(right.right, ast.Num) + x_range.append(-right.right.n) + elif isinstance(right.op, ast.Add): + assert isinstance(right.right, ast.Num) + x_range.append(right.right.n) + + if isinstance(right_node, ast.Compare): + cmp_node = right_node + left = cmp_node.left + ops = cmp_node.ops + comparators = cmp_node.comparators + + if ( + len(comparators) == 2 + and isinstance(comparators[0], ast.Attribute) + and comparators[0].attr == "y" + ): + if isinstance(left, ast.BinOp): + if isinstance(left.left, ast.Attribute) and left.left.attr == "y": + if isinstance(left.op, ast.Sub): + assert isinstance(left.right, ast.Num) + y_range.append(-left.right.n) + elif isinstance(left.op, ast.Add): + assert isinstance(left.right, ast.Num) + y_range.append(left.right.n) + + if isinstance(comparators[-1], ast.BinOp): + right = comparators[-1] + if isinstance(right.left, ast.Attribute) and right.left.attr == "y": + if isinstance(right.op, ast.Sub): + assert isinstance(right.right, ast.Num) + y_range.append(-right.right.n) + elif isinstance(right.op, ast.Add): + assert isinstance(right.right, ast.Num) + y_range.append(right.right.n) + return x_range, y_range + + +def recognize(camera_configs: List[CameraConfig], annotation): + annotation = annotation.head(500) + annotations: Dict[str, TrackedObject] = {} + # sample_token_to_frame_num: Dict[str, str] = {} + # for config in camera_configs: + # if config.frame_id not in sample_token_to_frame_num: + # sample_token_to_frame_num[config.frame_id] = [] + # sample_token_to_frame_num[config.frame_id].append(config.frame_num) + + # for a in annotation.itertuples(index=False): + # sample_token = a.sample_token + # if sample_token not in sample_token_to_frame_num: + # continue + # frame_nums = sample_token_to_frame_num[sample_token] + # item_id = a.instance_token + # if item_id not in annotations: + # annotations[item_id] = TrackedObject(a.category, [], []) + + # box = Box(a.translation, a.size, Quaternion(a.rotation)) + + # corners = box.corners() + + # bbox = np.transpose(corners[:, [3, 7]]) + # # print(sample_token, item_id) + # # print(set(frame_nums)) + # for frame_num in set(frame_nums): + # # TODO: fix this: why are there duplicates + # annotations[item_id].bboxes.append(bbox) + # annotations[item_id].frame_num.append(int(frame_num)) + # break + + # for item_id in annotations: + # frame_num = np.array(annotations[item_id].frame_num) + # bboxes = np.array(annotations[item_id].bboxes) + + # index = frame_num.argsort() + + # annotations[item_id].frame_num = frame_num[index].tolist() + # annotations[item_id].bboxes = bboxes[index, :, :] + + # print(item_id, len(annotations[item_id].frame_num) == len(set(annotations[item_id].frame_num))) + for img_file in camera_configs: + # get bboxes and categories of all the objects appeared in the image file + sample_token = img_file.frame_id + frame_num = img_file.frame_num + all_annotations = annotation[annotation["sample_token"] == sample_token] + # camera_info = {} + # camera_info['cameraTranslation'] = img_file['camera_translation'] + # camera_info['cameraRotation'] = img_file['camera_rotation'] + # camera_info['cameraIntrinsic'] = np.array(img_file['camera_intrinsic']) + # camera_info['egoRotation'] = img_file['ego_rotation'] + # camera_info['egoTranslation'] = img_file['ego_translation'] + + for _, ann in all_annotations.iterrows(): + item_id = ann["instance_token"] + if item_id not in annotations: + # annotations[item_id] = {"bboxes": [], "frame_num": []} + # annotations[item_id]["object_type"] = ann["category"] + annotations[item_id] = TrackedObject(ann["category"], [], []) + + box = Box(ann["translation"], ann["size"], Quaternion(ann["rotation"])) + + corners = box.corners() + + # if item_id == '6dd2cbf4c24b4caeb625035869bca7b5': + # # print("corners", corners) + # # transform_box(box, camera_info) + # # print("transformed box: ", box.corners()) + # # corners_2d = box.map_2d(np.array(camera_info['cameraIntrinsic'])) + # corners_2d = transformation(box.center, camera_info) + # print("2d_corner: ", corners_2d) + # overlay_bbox("v1.0-mini/samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg", corners_2d) + + bbox = [corners[:, 1], corners[:, 7]] + annotations[item_id].bboxes.append(bbox) + annotations[item_id].frame_num.append(int(frame_num)) + + print("Recognization done, saving to database......") + return annotations + + +def add_recognized_objs( + conn, formatted_result: Dict[str, TrackedObject], start_time: datetime.datetime, camera_id: str +): + for item_id in formatted_result: + object_type = formatted_result[item_id].object_type + recognized_bboxes = np.array(formatted_result[item_id].bboxes) + tracked_cnt = formatted_result[item_id].frame_num + + top_left = recognized_bboxes[:, 0, :] + bottom_right = recognized_bboxes[:, 1, :] + + obj_traj = [] + for i in range(len(top_left)): + current_tl = top_left[i] + current_br = bottom_right[i] + obj_traj.append([current_tl.tolist(), current_br.tolist()]) + + bboxes_to_postgres( + conn, + item_id, + object_type, + "default_color", + start_time, + tracked_cnt, + obj_traj, + camera_id, + ) + + +def bboxes_to_postgres( + conn, + item_id: str, + object_type: str, + color: str, + start_time: datetime.datetime, + timestamps: List[int], + bboxes: List[List[List[float]]], + camera_id: str, +): + converted_bboxes = [bbox_to_data3d(bbox) for bbox in bboxes] + pairs = [] + deltas = [] + for meta_box in converted_bboxes: + pairs.append(meta_box[0]) + deltas.append(meta_box[1:]) + postgres_timestamps = convert_timestamps(start_time, timestamps) + insert_general_trajectory( + conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs, camera_id + ) + # print(f"{item_id} saved successfully") + + +# Insert general trajectory +def insert_general_trajectory( + conn, + item_id: str, + object_type: str, + color: str, + postgres_timestamps: List[str], + bboxes: List[ + List[List[float]] + ], # TODO: should be ((float, float, float), (float, float, float))[] + pairs: List[Tuple[float, float, float]], + camera_id: str, +): + # Creating a cursor object using the cursor() method + cursor = conn.cursor() + + # Inserting bboxes into Bbox table + insert_bbox_trajectories_builder = [] + min_tl = np.full(3, np.inf) + max_br = np.full(3, np.NINF) + + traj_centroids = [] + + prevTimestamp = None + for timestamp, (tl, br), current_point in zip(postgres_timestamps, bboxes, pairs): + if prevTimestamp == timestamp: + continue + prevTimestamp = timestamp + min_tl = np.minimum(tl, min_tl) + max_br = np.maximum(br, max_br) + + # Insert bbox + insert_bbox_trajectories_builder.append( + f""" + INSERT INTO General_Bbox (itemId, cameraId, trajBbox) + VALUES ( + '{item_id}', + '{camera_id}', + STBOX 'STBOX ZT( + ({join([*tl, timestamp])}), + ({join([*br, timestamp])}) + )' + ); + """ + ) + + # Construct trajectory + traj_centroids.append(f"POINT Z ({join(current_point, ' ')})@{timestamp}") + + # Insert the item_trajectory separately + insert_trajectory = f""" + INSERT INTO Item_General_Trajectory (itemId, cameraId, objectType, color, trajCentroids, largestBbox) + VALUES ( + '{item_id}', + '{camera_id}', + '{object_type}', + '{color}', + '{{{', '.join(traj_centroids)}}}', + STBOX 'STBOX Z( + ({join(min_tl)}), + ({join(max_br)}) + )' + ); + """ + + cursor.execute(insert_trajectory) + cursor.execute("".join(insert_bbox_trajectories_builder)) + + # Commit your changes in the database + conn.commit() diff --git a/apperception/new_world.py b/apperception/new_world.py new file mode 100644 index 00000000..4c2f1e61 --- /dev/null +++ b/apperception/new_world.py @@ -0,0 +1,610 @@ +from __future__ import annotations + +import datetime +import glob +import inspect +import uuid +from collections.abc import Iterable +from enum import IntEnum +from os import makedirs, path +from pyclbr import Function +from typing import Any, Dict, List, Optional, Set, Tuple + +import cv2 +import dill as pickle +import matplotlib +import matplotlib.pyplot as plt +import numpy as np +import yaml +from camera import Camera +from new_db import Database +from new_util import compile_lambda + +matplotlib.use("Qt5Agg") +print("get backend", matplotlib.get_backend()) + +makedirs("./.apperception_cache", exist_ok=True) + + +class Type(IntEnum): + # query type: for example, if we call get_cam(), and we execute the commands from root. when we encounter + # recognize(), we should not execute it because the inserted object must not be in the final result. we use enum + # type to determine whether we should execute this node + CAM, BBOX, TRAJ = 0, 1, 2 + + +BASE_VOLUME_QUERY_TEXT = "STBOX Z(({x1}, {y1}, {z1}),({x2}, {y2}, {z2}))" + + +class World: + # all worlds share a db instance + db = Database() + camera_nodes: Dict[str, Camera] = {} + + _parent: Optional[World] + _name: str + # TODO: Fix _fn typing: (World, *Any, **Any) -> Query | str? | None + _fn: Any + _kwargs: dict[str, Any] + _done: bool + _world_id: str + _timestamp: datetime.datetime + _types: set[Type] + _materialized: bool + + def __init__( + self, + world_id: str, + timestamp: datetime.datetime, + name: str = None, + parent: World = None, + fn: Any = None, + kwargs: dict[str, Any] = None, + done: bool = False, + types: Set[Type] = None, + materialized: bool = False, + ): + self._parent = parent + self._name = "" if name is None else name + self._fn = None if fn is None else (getattr(self.db, fn) if isinstance(fn, str) else fn) + self._kwargs = {} if kwargs is None else kwargs + self._done = done # update node + self._world_id = world_id + self._timestamp = timestamp + self._types = set() if types is None else types + self._materialized = materialized + + def overlay_trajectory(self, cam_id, trajectory): + matplotlib.use( + "Qt5Agg" + ) # FIXME: matplotlib backend is agg here (should be qt5agg). Why is it overwritten? + print("get backend", matplotlib.get_backend()) + camera = World.camera_nodes[cam_id] + video_file = camera.video_file + for traj in trajectory: + current_trajectory = np.asarray(traj[0]) + frame_points = camera.lens.world_to_pixels(current_trajectory.T).T + vs = cv2.VideoCapture(video_file) + frame = vs.read() + frame = cv2.cvtColor(frame[1], cv2.COLOR_BGR2RGB) + for point in frame_points.tolist(): + cv2.circle(frame, tuple([int(point[0]), int(point[1])]), 3, (255, 0, 0)) + plt.figure() + plt.imshow(frame) + plt.show() + + def select_intersection_of_interest_or_use_default(self, cam_id, default=True): + camera = self.camera_nodes[cam_id] + video_file = camera.video_file + if default: + x1, y1, z1 = 0.01082532, 2.59647246, 0 + x2, y2, z2 = 3.01034039, 3.35985782, 2 + else: + vs = cv2.VideoCapture(video_file) + frame = vs.read() + frame = frame[1] + cv2.namedWindow("Frame", cv2.WINDOW_NORMAL) + cv2.resizeWindow("Frame", 384, 216) + initBB = cv2.selectROI("Frame", frame, fromCenter=False) + print(initBB) + cv2.destroyAllWindows() + print("world coordinate #1") + tl = camera.lens.pixel_to_world(initBB[:2], 1) + print(tl) + x1, y1, z1 = tl + print("world coordinate #2") + br = camera.lens.pixel_to_world((initBB[0] + initBB[2], initBB[1] + initBB[3]), 1) + print(br) + x2, y2, z2 = br + return BASE_VOLUME_QUERY_TEXT.format(x1=x1, y1=y1, z1=0, x2=x2, y2=y2, z2=2) + + def select_by_range(self, cam_id, x_range: Tuple[float, float], z_range: Tuple[float, float]): + camera = self.camera_nodes[cam_id] + x, _, z = camera.point.coordinate + + x_min = x + x_range[0] + x_max = x + x_range[1] + z_min = z + z_range[0] + z_max = z + z_range[1] + + return BASE_VOLUME_QUERY_TEXT.format( + x1=x_min, y1=float("-inf"), z1=z_min, x2=x_max, y2=float("inf"), z2=z_max + ) + + def recognize(self, camera: Camera, annotation): + node1 = self._insert_bbox_traj(camera=camera, annotation=annotation) + node2 = node1._retrieve_bbox(camera_id=camera.id) + node3 = node2._retrieve_traj(camera_id=camera.id) + return node3 + + def get_video(self, cam_ids: List[str] = [], boxed: bool = False): + return derive_world( + self, + {Type.TRAJ}, + self.db.get_video, + cams=[World.camera_nodes[cam_id] for cam_id in cam_ids], + boxed=boxed, + )._execute_from_root(Type.TRAJ) + + def get_bbox(self): + return derive_world( + self, + {Type.BBOX}, + self.db.get_bbox, + )._execute_from_root(Type.BBOX) + + def get_traj(self): + return derive_world( + self, + {Type.TRAJ}, + self.db.get_traj, + )._execute_from_root(Type.TRAJ) + + def get_traj_key(self): + return derive_world( + self, + {Type.TRAJ}, + self.db.get_traj_key, + )._execute_from_root(Type.TRAJ) + + def get_headings(self): + # TODO: Optimize operations with NumPy if possible + trajectories = self.get_traj() + headings = [] + for traj in trajectories: + traj = traj[0] + heading = [None] + for j in range(1, len(traj)): + prev_pos = traj[j - 1] + current_pos = traj[j] + heading.append(0) + if current_pos[1] != prev_pos[1]: + heading[j] = np.arctan2( + current_pos[1] - prev_pos[1], current_pos[0] - prev_pos[0] + ) + heading[j] *= 180 / np.pi # convert to degrees from radian + heading[j] = ( + heading[j] + 360 + ) % 360 # converting such that all headings are positive + headings.append(heading) + return headings + + def get_distance(self, start: float, end: float): + return derive_world( + self, + {Type.TRAJ}, + self.db.get_distance, + start=str(self.db.start_time + datetime.timedelta(seconds=start)), + end=str(self.db.start_time + datetime.timedelta(seconds=end)), + )._execute_from_root(Type.TRAJ) + + def get_speed(self, start, end): + return derive_world( + self, + {Type.TRAJ}, + self.db.get_speed, + start=str(self.db.start_time + datetime.timedelta(seconds=start)), + end=str(self.db.start_time + datetime.timedelta(seconds=end)), + )._execute_from_root(Type.TRAJ) + + def filter_traj_type(self, object_type: str): + return derive_world(self, {Type.TRAJ}, self.db.filter_traj_type, object_type=object_type) + + def filter_traj_volume(self, volume: str): + return derive_world(self, {Type.TRAJ}, self.db.filter_traj_volume, volume=volume) + + def filter_traj_heading(self, lessThan=float("inf"), greaterThan=float("-inf")): + return derive_world( + self, + {Type.TRAJ}, + self.db.filter_traj_heading, + lessThan=lessThan, + greaterThan=greaterThan, + ) + + def filter_relative_to_type( + self, + x_range: Tuple[float, float], + y_range: Tuple[float, float], + z_range: Tuple[float, float], + type: str, + ): + return derive_world( + self, + {Type.TRAJ}, + self.db.filter_relative_to_type, + x_range=x_range, + y_range=y_range, + z_range=z_range, + type=type, + ) + + def filter_pred_relative_to_type(self, pred: Function): + x_range, y_range = compile_lambda(pred) + + return derive_world( + self, + {Type.TRAJ}, + self.db.filter_relative_to_type, + x_range=x_range, + y_range=y_range, + z_range=[float(-(2**31)), float(2**31)], + type="camera", + ) + + def add_camera(self, camera: Camera): + """ + 1. For update method, we create two nodes: the first node will write to the db, and the second node will retrieve from the db + 2. For the write node, never double write. (so we use done flag) + ... -> [write] -> [retrive] -> ... + """ + node1 = self._insert_camera(camera=camera) + node2 = node1._retrieve_camera(camera_id=camera.id) + return node2 + + def interval(self, start, end): + return derive_world( + self, + {Type.BBOX}, + self.db.interval, + start=str(self.db.start_time + datetime.timedelta(seconds=start)), + end=str(self.db.start_time + datetime.timedelta(seconds=end)), + ) + + def add_properties(self, cam_id: str, properties: Any, property_type: str, new_prop): + # TODO: Should we add this to DB instead of the global object? + self.camera_nodes[cam_id].add_property(properties, property_type, new_prop) + + def predicate(self, condition: str): + return derive_world( + self, + {Type.CAM}, + self.db.filter_cam, + condition=condition, + ) + + def get_len(self): + return derive_world( + self, + {Type.CAM}, + self.db.get_len, + )._execute_from_root(Type.CAM) + + def get_camera(self): + return derive_world( + self, + {Type.CAM}, + self.db.get_cam, + )._execute_from_root(Type.CAM) + + def get_bbox_geo(self): + return derive_world( + self, + {Type.BBOX}, + self.db.get_bbox_geo, + )._execute_from_root(Type.BBOX) + + def get_time(self): + return derive_world( + self, + {Type.BBOX}, + self.db.get_time, + )._execute_from_root(Type.BBOX) + + def _insert_camera(self, camera: Camera): + return derive_world( + self, + {Type.CAM}, + self.db.insert_cam, + camera=camera, + ) + + def _retrieve_camera(self, camera_id: str): + return derive_world( + self, + {Type.CAM}, + self.db.retrieve_cam, + camera_id=camera_id, + ) + + def _insert_bbox_traj(self, camera: Camera, annotation): + return derive_world( + self, + {Type.TRAJ, Type.BBOX}, + self.db.insert_bbox_traj, + camera=camera, + annotation=annotation, + ) + + def _retrieve_bbox(self, camera_id: str): + return derive_world(self, {Type.BBOX}, self.db.retrieve_bbox, camera_id=camera_id) + + def _retrieve_traj(self, camera_id: str): + return derive_world(self, {Type.TRAJ}, self.db.retrieve_traj, camera_id=camera_id) + + def _execute_from_root(self, type: Type): + nodes: list[World] = [] + curr: Optional[World] = self + res = None + query = "" + + # collect all the nodes til the root + while curr: + nodes.append(curr) + curr = curr._parent + + # execute the nodes from the root + for node in nodes[::-1]: + # root + if node.fn is None: + continue + # if different type => pass + if type not in node.types: + continue + # treat update method differently + elif node.fn == self.db.insert_cam or node.fn == self.db.insert_bbox_traj: + print("execute:", node.fn.__name__) + if not node.done: + node._execute() + node._done = True + node._update_log_file() + else: + print("execute:", node.fn.__name__) + # print(query) + query = node._execute(query=query) + print("done execute node") + + res = query + return res + + def _execute(self, **kwargs): + fn_spec = inspect.getfullargspec(self._fn) + if "world_id" in fn_spec.args or fn_spec.varkw is not None: + return self._fn(**{"world_id": self._world_id, **self._kwargs, **kwargs}) + return self._fn(**{**self._kwargs, **kwargs}) + + def _print_lineage(self): + curr = self + while curr: + print(curr) + curr = curr._parent + + def __str__(self): + return ( + f"fn={self._fn}\nkwargs={self._kwargs}\ndone={self._done}\nworld_id={self._world_id}\n" + ) + + @property + def filename(self): + return filename(self._timestamp, self._world_id, self._name) + + @property + def world_id(self): + return self._world_id + + @property + def timestamp(self): + return self._timestamp + + @property + def parent(self): + return self._parent + + @property + def name(self): + return self._name + + @property + def fn(self): + return self._fn + + @property + def kwargs(self): + return self._kwargs + + @property + def done(self): + return self._done + + @property + def types(self): + return self._types + + @property + def materialized(self): + return self._materialized + + def _update_log_file(self): + with open(self.filename, "r") as f: + children = yaml.safe_load(f).get("children_filenames", None) + with open(self.filename, "w") as f: + f.write( + yaml.safe_dump( + { + **({} if self._parent is None else {"parent": self._parent.filename}), + **({} if self._types == set() else {"types": set(map(int, self._types))}), + **({} if self._fn is None else {"fn": self._fn.__name__}), + **({} if self._kwargs == {} else {"kwargs": pickle.dumps(self._kwargs)}), + **({} if not self._done else {"done": self._done}), + **({} if not self._materialized else {"materialized": self._materialized}), + **({} if children is None else {"children_filenames": children}), + } + ) + ) + + +def empty_world(name: str) -> World: + matched_files = list( + filter(path.isfile, glob.glob(f"./.apperception_cache/*_*_{name}.ap.yaml")) + ) + if len(matched_files): + return _empty_world_from_file(matched_files[0]) + return _empty_world(name) + + +def _empty_world_from_file(log_file: str) -> World: + with open(log_file, "r") as f: + content = yaml.safe_load(f) + if "children_filenames" in content: + del content["children_filenames"] + return World(*split_filename(log_file), **content) + + +def _empty_world(name: str) -> World: + world_id = str(uuid.uuid4()) + timestamp = datetime.datetime.utcnow() + log_file = filename(timestamp, world_id, name) + with open(log_file, "w") as f: + f.write(yaml.safe_dump({})) + return World(world_id, timestamp, name) + + +def derive_world(parent: World, types: set[Type], fn: Any, **kwargs) -> World: + # world = _derive_world_from_file(parent, types, fn, **kwargs) + # if world is not None: + # return world + return _derive_world(parent, types, fn, **kwargs) + + +def _derive_world(parent: World, types: set[Type], fn: Any, **kwargs) -> World: + world_id = str(uuid.uuid4()) + timestamp = datetime.datetime.utcnow() + log_file = filename(timestamp, world_id) + + with open(parent.filename, "r") as pf: + content = yaml.safe_load(pf) + with open(parent.filename, "w") as pf: + content["children_filenames"] = content.get("children_filenames", set()) + content["children_filenames"].add(log_file) + pf.write(yaml.safe_dump(content)) + + with open(log_file, "w") as f: + f.write( + yaml.safe_dump( + { + "fn": fn.__name__, + "kwargs": pickle.dumps(kwargs), + "parent": parent.filename, + "types": set(map(int, types)), + } + ) + ) + + return World( + world_id, + timestamp, + fn=fn, + kwargs=kwargs, + parent=parent, + types=types, + ) + + +def _derive_world_from_file(parent: World, types: set[Type], fn: Any, **kwargs) -> Optional[World]: + with open(parent.filename, "r") as f: + sibling_filenames: Iterable[str] = yaml.safe_load(f).get("children_filenames", []) + + for sibling_filename in sibling_filenames: + with open(sibling_filename, "r") as sf: + sibling_content = yaml.safe_load(sf) + + if op_matched(sibling_content, types, fn, kwargs): + return World( + *split_filename(sibling_filename), + parent=parent, + **format_content(sibling_content), + ) + + return None + + +def from_file(filename: str) -> World: + with open(filename, "r") as f: + content = yaml.safe_load(f) + + parent_filename = content.get("parent_filename", None) + if parent_filename is None: + parent = None + else: + parent = from_file(parent_filename) + + return World(*split_filename(filename), parent=parent, **format_content(content)) + + +def filename(timestamp: datetime.datetime, world_id: str, name: str = ""): + return f".apperception_cache/{str(timestamp).replace(':', ';')}_{world_id}_{name}.ap.yaml" + + +def split_filename(filename: str) -> Tuple[str, datetime.datetime, str]: + filename = filename.replace("\\", "/") + timestamp_str, world_id, name = filename[: -len(".ap.yaml")].split("/")[-1].split("_", 2) + return world_id, datetime.datetime.fromisoformat(timestamp_str.replace(";", ":")), name + + +DUMPED_EMPTY_DICT = pickle.dumps({}) + + +def double_equal(a: Tuple[Any, Any]): + return a[0] == a[1] + + +def op_matched( + file_content: dict[str, Any], + types: set[Type], + fn: Any, + kwargs: dict[str, Any] = None, +) -> bool: + f_fn: str | None = file_content.get("fn", None) + f_types: set[int] = file_content.get("types", set()) + + if f_fn != fn.__name__ or f_types != set(map(int, types)): + return False + + kwargs = {} if kwargs is None else kwargs + f_kwargs: dict[str, Any] = pickle.loads(file_content.get("kwargs", DUMPED_EMPTY_DICT)) + + if len(f_kwargs) != len(kwargs): + return False + + cmps = fn.comparators if hasattr(fn, "comparators") else {} + a = all( + key in f_kwargs and cmps.get(key, double_equal)((f_kwargs[key], kwargs[key])) + for key in kwargs + ) + return a + + +def format_content(content: dict[str, Any]) -> dict[str, Any]: + if "types" in content: + content["types"] = set(map(Type, content["types"])) + + if "kwargs" in content: + content["kwargs"] = pickle.loads(content["kwargs"]) + + if "parent" in content: + del content["parent"] + + if "children_filenames" in content: + del content["children_filenames"] + + return content diff --git a/apperception/object_tracker_yolov4_deepsort.py b/apperception/object_tracker_yolov4_deepsort.py index b13fd0c2..000f5b3b 100644 --- a/apperception/object_tracker_yolov4_deepsort.py +++ b/apperception/object_tracker_yolov4_deepsort.py @@ -216,7 +216,7 @@ def yolov4_deepsort_video_track(video_file: str, recognition_area: BoundingBox = formatted_result[item_id].bboxes.append( BoundingBox(int(bbox[0]), int(bbox[1]), int(bbox[2]), int(bbox[3])) ) - formatted_result[item_id].tracked_cnt.append(frame_num) + formatted_result[item_id].frame_num.append(frame_num) else: break diff --git a/apperception/object_tracker_yolov5_deepsort.py b/apperception/object_tracker_yolov5_deepsort.py index ce20f858..3ad5ae0e 100644 --- a/apperception/object_tracker_yolov5_deepsort.py +++ b/apperception/object_tracker_yolov5_deepsort.py @@ -64,7 +64,7 @@ def detect(opt: YoloV5Opt): cfg.merge_from_file(opt.config_deepsort) attempt_download(deep_sort_weights, repo="mikel-brostrom/Yolov5_DeepSort_Pytorch") deepsort = DeepSort( - cfg.DEEPSORT.REID_CKPT, + deep_sort_weights, max_dist=cfg.DEEPSORT.MAX_DIST, min_confidence=cfg.DEEPSORT.MIN_CONFIDENCE, max_iou_distance=cfg.DEEPSORT.MAX_IOU_DISTANCE, @@ -92,30 +92,30 @@ def detect(opt: YoloV5Opt): names = model.module.names if hasattr(model, "module") else model.names # Run inference - if device.type != "cpu": - _, img, _, _ = dataset[0] - h, w = img.shape[1:] - - # crop image - x1, y1, x2, y2 = [ - int(v / 100.0) - for v in [ - w * crop.x1, - h * crop.y1, - w * crop.x2, - h * crop.y2, - ] - ] - - img = img[:, y1:y2, x1:x2] - model( - torch.zeros(1, 3, img.shape[1], img.shape[2]) - .to(device) - .type_as(next(model.parameters())) - ) # run once + # if device.type != "cpu": + # _, img, _, _ = dataset[0] + # h, w = img.shape[1:] + + # # crop image + # x1, y1, x2, y2 = [ + # int(v / 100.0) + # for v in [ + # w * crop.x1, + # h * crop.y1, + # w * crop.x2, + # h * crop.y2, + # ] + # ] + + # img = img[:, y1:y2, x1:x2] + # model( + # torch.zeros(1, 3, img.shape[1], img.shape[2]) + # .to(device) + # .type_as(next(model.parameters())) + # ) # run once formatted_result: Dict[str, TrackedObject] = {} - for frame_idx, (_, img, im0s, _) in enumerate(dataset): + for frame_idx, (_, img, im0s, _, _) in enumerate(dataset): h, w = img.shape[1:] # crop image @@ -152,7 +152,7 @@ def detect(opt: YoloV5Opt): continue # add padding from cropped frame - det[:, :4] += torch.tensor([[x1, y1, x1, y1]]) + det[:, :4] += torch.tensor([[x1, y1, x1, y1]]).to(device) # Rescale boxes from img_size to im0 size det[:, :4] = scale_coords( @@ -179,7 +179,7 @@ def detect(opt: YoloV5Opt): formatted_result[item_id] = TrackedObject(object_type=names[c]) formatted_result[item_id].bboxes.append(bboxes) - formatted_result[item_id].tracked_cnt.append(frame_idx) + formatted_result[item_id].frame_num.append(frame_idx) return formatted_result diff --git a/apperception/point.py b/apperception/point.py index 01691864..70c20d5e 100644 --- a/apperception/point.py +++ b/apperception/point.py @@ -1,20 +1,11 @@ +from dataclasses import dataclass +from typing import Tuple + + +@dataclass class Point: - def __init__( - self, - point_id: str, - object_id: str, - x: float, - y: float, - z: float, - time: float, - point_type: str, - ): - """ - Initializes an Point given coordinates, time, type and associated point ID - and object ID. - """ - self.point_id = point_id - self.object_id = object_id - self.coordinate = (x, y, z) - self.time = time - self.point_type = point_type + point_id: str + object_id: str + coordinate: Tuple[float, float, float] + time: float + point_type: str diff --git a/apperception/scenic_util.py b/apperception/scenic_util.py index e92b51eb..4136627e 100644 --- a/apperception/scenic_util.py +++ b/apperception/scenic_util.py @@ -108,7 +108,7 @@ def create_or_insert_camera_table(conn, world_name, camera): insert_camera( conn, world_name, - fetch_camera_config(camera.scenic_scene_name, camera.object_recognition.sample_data), + fetch_camera_config(camera.id, camera.object_recognition.sample_data), ) return CREATE_CAMERA_SQL @@ -520,6 +520,7 @@ def fetch_camera(conn, scene_name, frame_num): cameraId = '{scene_name}' AND frameNum IN ({",".join(map(str, frame_num))}); """ + print(query) cursor.execute(query) return cursor.fetchall() @@ -583,14 +584,14 @@ def import_tables(conn): # Helper function to convert the timestam to the timestamp formula pg-trajectory uses -def convert_timestamps(start_time, timestamps): +def convert_timestamps(start_time: datetime.datetime, timestamps: Iterable[int]): return [str(start_time + datetime.timedelta(seconds=t)) for t in timestamps] # Helper function to convert trajectory to centroids -def bbox_to_data3d(bbox): +def bbox_to_data3d(bbox: List[List[float]]): """ Compute the center, x, y, z delta of the bbox """ diff --git a/apperception/test_parse_scenic_pred.py b/apperception/test_parse_scenic_pred.py new file mode 100644 index 00000000..c027653c --- /dev/null +++ b/apperception/test_parse_scenic_pred.py @@ -0,0 +1,95 @@ +import ast +import os + +import uncompyle6 +from astpretty import pprint as apprint + + +def main(): + def pred(obj): + return (cam.x - 10) <= obj.x <= (cam.x + 10) and (cam.y - 15) <= obj.y <= (cam.y + 70) + + s = uncompyle6.deparse_code2str(pred.__code__, out=open(os.devnull, "w")) + tree = ast.parse(s) + # print(pred.__code__) + # print(s) + # apprint(tree) + subtree = tree.body[0] + assert isinstance(subtree, ast.Return) + + apprint(subtree) + + x_range = [] + y_range = [] + + if isinstance(subtree.value, ast.BoolOp): + left_node = subtree.value.values[0] + right_node = subtree.value.values[1] + + # parse left + if isinstance(left_node, ast.Compare): + cmp_node = left_node + left = cmp_node.left + ops = cmp_node.ops + comparators = cmp_node.comparators + + if ( + len(comparators) == 2 + and isinstance(comparators[0], ast.Attribute) + and comparators[0].attr == "x" + ): + if isinstance(left, ast.BinOp): + if isinstance(left.left, ast.Attribute) and left.left.attr == "x": + if isinstance(left.op, ast.Sub): + assert isinstance(left.right, ast.Num) + x_range.append(-left.right.n) + elif isinstance(left.op, ast.Add): + assert isinstance(left.right, ast.Num) + x_range.append(left.right.n) + + if isinstance(comparators[-1], ast.BinOp): + right = comparators[-1] + if isinstance(right.left, ast.Attribute) and right.left.attr == "x": + if isinstance(right.op, ast.Sub): + assert isinstance(right.right, ast.Num) + x_range.append(-right.right.n) + elif isinstance(right.op, ast.Add): + assert isinstance(right.right, ast.Num) + x_range.append(right.right.n) + + if isinstance(right_node, ast.Compare): + cmp_node = right_node + left = cmp_node.left + ops = cmp_node.ops + comparators = cmp_node.comparators + + if ( + len(comparators) == 2 + and isinstance(comparators[0], ast.Attribute) + and comparators[0].attr == "y" + ): + if isinstance(left, ast.BinOp): + if isinstance(left.left, ast.Attribute) and left.left.attr == "y": + if isinstance(left.op, ast.Sub): + assert isinstance(left.right, ast.Num) + y_range.append(-left.right.n) + elif isinstance(left.op, ast.Add): + assert isinstance(left.right, ast.Num) + y_range.append(left.right.n) + + if isinstance(comparators[-1], ast.BinOp): + right = comparators[-1] + if isinstance(right.left, ast.Attribute) and right.left.attr == "y": + if isinstance(right.op, ast.Sub): + assert isinstance(right.right, ast.Num) + y_range.append(-right.right.n) + elif isinstance(right.op, ast.Add): + assert isinstance(right.right, ast.Num) + y_range.append(right.right.n) + + print(x_range) + print(y_range) + + +if __name__ == "__main__": + main() diff --git a/apperception/tracked_object.py b/apperception/tracked_object.py index ce891f19..276769e5 100644 --- a/apperception/tracked_object.py +++ b/apperception/tracked_object.py @@ -1,11 +1,33 @@ from dataclasses import dataclass, field -from typing import List +from typing import List, Union -from bounding_box import BoundingBox +import numpy as np @dataclass class TrackedObject: object_type: str - bboxes: List[BoundingBox] = field(default_factory=list) - tracked_cnt: List[int] = field(default_factory=list) + bboxes: Union[List[np.ndarray], np.ndarray] = field(default_factory=list) + frame_num: List[int] = field(default_factory=list) + + def __eq__(self, other) -> bool: + return ( + isinstance(other, TrackedObject) + and self.object_type == other.object_type + and self.frame_num == other.frame_num + and np.array_equal(np.array(self.bboxes), np.array(other.bboxes)) + ) + + def equal(self, other) -> bool: + if not isinstance(other, TrackedObject) or self.object_type != other.object_type: + return False + + s_frame_num = np.array(self.frame_num) + o_frame_num = np.array(other.frame_num) + + s_indices = s_frame_num.argsort() + o_indices = o_frame_num.argsort() + + return np.array_equal(s_frame_num[s_indices], o_frame_num[o_indices]) and np.array_equal( + np.array(self.bboxes)[s_indices], np.array(other.bboxes)[o_indices] + ) diff --git a/apperception/video_context.py b/apperception/video_context.py index 89cb46c7..7a1f6918 100644 --- a/apperception/video_context.py +++ b/apperception/video_context.py @@ -7,9 +7,10 @@ import psycopg2 +@dataclass class Camera: - def __init__(self, scenic_scene_name): - self.scenic_scene_name = scenic_scene_name + def __init__(self, id: str): + self.id = id # Contain objects that still have yet to be added to the backend # If user calls recognize, those items will have already been diff --git a/apperception/video_context_executor.py b/apperception/video_context_executor.py index 7d178969..10feaa33 100644 --- a/apperception/video_context_executor.py +++ b/apperception/video_context_executor.py @@ -48,7 +48,7 @@ def visit_camera(self, camera_node: Camera): return camera_sql def visit_obj_rec(self, camera_node, object_rec_node): - cam_id = camera_node.scenic_scene_name + cam_id = camera_node.id start_time = self.current_context.start_time diff --git a/apperception/video_util.py b/apperception/video_util.py index a08d777a..72c48165 100644 --- a/apperception/video_util.py +++ b/apperception/video_util.py @@ -1,4 +1,21 @@ -from typing import Any, Dict +from __future__ import annotations + +import datetime +import random +from typing import TYPE_CHECKING, Any, Dict, List, Optional + +import cv2 +import numpy as np +from bounding_box import WHOLE_FRAME, BoundingBox +from lens import Lens +from tracker import Tracker +from typing_extensions import Literal + +if TYPE_CHECKING: + from object_tracker_yolov5_deepsort import TrackedObject + +# TODO: add more units +Units = Literal["metrics"] def video_data_to_tasm(video_file, metadata_id, t): @@ -33,7 +50,127 @@ def bound_height(y): t.add_bulk_metadata(metadata_info) -def create_or_insert_world_table(conn, name, units): +def convert_datetime_to_frame_num(start_time, date_times): + + return [(t.replace(tzinfo=None) - start_time).total_seconds() for t in date_times] + + +def get_video_roi(file_name, cam_video_file, rois, times): + """ + Get the region of interest from the video, based on bounding box points in + video coordinates. + + Args: + file_name: String of file name to save video as + rois: A list of bounding boxes + time_intervals: A list of time intervals of which frames + """ + + rois = np.array(rois).T + print(rois.shape) + len_x, len_y = np.max(rois.T[2] - rois.T[0]), np.max(rois.T[3] - rois.T[1]) + # len_x, len_y = np.max(rois.T[0][1] - rois.T[0][0]), np.max(rois.T[1][1] - rois.T[1][0]) + + len_x = int(round(len_x)) + len_y = int(round(len_y)) + # print(len_x) + # print(len_y) + vid_writer = cv2.VideoWriter( + file_name, cv2.VideoWriter_fourcc("m", "p", "4", "v"), 30, (len_x, len_y) + ) + # print("rois") + # print(rois) + start_time = int(times[0]) + cap = cv2.VideoCapture(cam_video_file) + frame_cnt = 0 + while cap.isOpened(): + # Capture frame-by-frame + ret, frame = cap.read() + if frame_cnt in times and ret: + i = frame_cnt - start_time + if i >= len(rois): + print("incorrect length:", len(rois)) + break + current_roi = rois[i] + + b_x, b_y, e_x, e_y = current_roi + b_x, b_y = max(0, b_x), max(0, b_y) + # e_x, e_y = current_roi[1] + e_x, e_y = max(0, e_x), max(0, e_y) + diff_y, diff_x = int(abs(e_y - b_y)), int(abs(e_x - b_x)) + pad_y = int((len_y - diff_y) // 2) + pad_x = int((len_x - diff_x) // 2) + + # print("padding") + # print(pad_y) + # print(pad_x) + roi_byte = frame[int(b_y) : int(e_y), int(b_x) : int(e_x), :] + + roi_byte = np.pad( + roi_byte, + pad_width=[ + (pad_y, len_y - diff_y - pad_y), + (pad_x, len_x - diff_x - pad_x), + (0, 0), + ], + ) + frame = cv2.cvtColor(roi_byte, cv2.COLOR_RGB2BGR) + + vid_writer.write(roi_byte) + frame_cnt += 1 + if not ret: + break + + vid_writer.release() + + +def get_video_box( + file_name: str, cam_video_file: str, rois: List[(int, int, int, int)], times: List[int] +): + """ + Get the frames of interest from the video, while boxing in the object at interest + with a box. + + Args: + file_name: String of file name to save video as + rois: A list of bounding boxes + time_intervals: A list of time intervals of which frames + """ + + rois = np.array(rois).T + print(rois.shape) + + cap = cv2.VideoCapture(cam_video_file) + width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) + height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) + vid_writer = cv2.VideoWriter( + file_name, cv2.VideoWriter_fourcc("m", "p", "4", "v"), 30, (width, height) + ) + + start_time = int(times[0]) + frame_cnt = 0 + while cap.isOpened(): + # Capture frame-by-frame + ret, frame = cap.read() + if frame_cnt in times and ret: + i = frame_cnt - start_time + if i >= len(rois): + print("incorrect length:", len(rois)) + break + current_roi = rois[i] + + x1, y1, x2, y2 = current_roi + cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (255, 255, 0), 2) + + vid_writer.write(frame) + frame_cnt += 1 + if not ret: + break + + vid_writer.release() + + +def create_or_insert_world_table(conn, name, units: Units): # Creating a cursor object using the cursor() method cursor = conn.cursor() """ @@ -64,3 +201,374 @@ def insert_world(conn, name, units): print("New world inserted successfully........") # Insert the existing cameras of the current world into the camera table conn.commit() + + +def create_or_insert_camera_table(conn, world_name, camera): + """Create a camera table""" + # Creating a cursor object using the cursor() method + cursor = conn.cursor() + """ + Create and Populate A camera table with the given camera object. + """ + # Creating table with the first camera + sql = "\n".join( + [ + "CREATE TABLE IF NOT EXISTS Cameras(", + " cameraId TEXT,", + " worldId TEXT,", + " ratio real,", + " origin geometry,", + " focalpoints geometry,", + " fov INTEGER,", + " skev_factor real,", + " width integer,", + " height integer", + ");", + ] + ) + cursor.execute(sql) + print("Camera Table created successfully........") + insert_camera(conn, world_name, camera) + return sql + + +def insert_camera(conn, world_name, camera_node): + """Helper function to insert the camera""" + # Creating a cursor object using the cursor() method + cursor = conn.cursor() + lens = camera_node.lens + focal_x = str(lens.focal_x) + focal_y = str(lens.focal_y) + cam_x, cam_y, cam_z = str(lens.cam_origin[0]), str(lens.cam_origin[1]), str(lens.cam_origin[2]) + width, height = camera_node.dimension + cursor.execute( + """INSERT INTO Cameras (cameraId, worldId, ratio, origin, focalpoints, fov, skev_factor, width, height) """ + + """VALUES (\'%s\', \'%s\', %f, \'POINT Z (%s %s %s)\', \'POINT(%s %s)\', %s, %f, %d, %d);""" + % ( + camera_node.cam_id, + world_name, + camera_node.ratio, + cam_x, + cam_y, + cam_z, + focal_x, + focal_y, + lens.fov, + lens.alpha, + width, + height, + ) + ) + print("New camera inserted successfully.........") + conn.commit() + + +def get_video_dimension(video_file: str): + vid: cv2.VideoCapture = cv2.VideoCapture(video_file) + width = vid.get(cv2.CAP_PROP_FRAME_WIDTH) + height = vid.get(cv2.CAP_PROP_FRAME_HEIGHT) + # width and height are floats + return (int(width), int(height)) + + +def recognize( + video_file: str, + recog_algo: str = "", + tracker_type: str = "default", + customized_tracker: Optional[Tracker] = None, + recognition_area: BoundingBox = WHOLE_FRAME, +): + """Default object recognition (YOLOv5)""" + from object_tracker_yolov4_deepsort import yolov4_deepsort_video_track + from object_tracker_yolov5_deepsort import (YoloV5Opt, + yolov5_deepsort_video_track) + + # recognition = item.ItemRecognition(recog_algo = recog_algo, tracker_type = tracker_type, customized_tracker = customized_tracker) + # return recognition.video_item_recognize(video.byte_array) + if recognition_area.is_whole_frame(): + recognition_area = BoundingBox(0, 0, 100, 100) + if recog_algo == "yolov4": + return yolov4_deepsort_video_track(video_file, recognition_area) + else: + # use YoloV5 as default + return yolov5_deepsort_video_track(YoloV5Opt(video_file, recognition_area=recognition_area)) + + +def add_recognized_objs( + conn: Any, + lens: Lens, + formatted_result: Dict[str, TrackedObject], + start_time: datetime.datetime, + world_id: str = "default", + properties: dict = {"color": {}}, + default_depth: bool = True, +): + # # TODO: move cleaning to apperception_benchmark.py + # clean_tables(conn) + for item_id in formatted_result: + object_type = formatted_result[item_id].object_type + recognized_bboxes = np.array( + [bbox.to_tuples() for bbox in formatted_result[item_id].bboxes] + ) + tracked_cnt = formatted_result[item_id].frame_num + top_left = np.vstack((recognized_bboxes[:, 0, 0], recognized_bboxes[:, 0, 1])) + if default_depth: + top_left_depths = np.ones(len(recognized_bboxes)) + else: + top_left_depths = self.__get_depths_of_points( + recognized_bboxes[:, 0, 0], recognized_bboxes[:, 0, 1] + ) + top_left = lens.pixels_to_world(top_left, top_left_depths) + + # Convert bottom right coordinates to world coordinates + bottom_right = np.vstack((recognized_bboxes[:, 1, 0], recognized_bboxes[:, 1, 1])) + if default_depth: + bottom_right_depths = np.ones(len(tracked_cnt)) + else: + bottom_right_depths = self.__get_depths_of_points( + recognized_bboxes[:, 1, 0], recognized_bboxes[:, 1, 1] + ) + bottom_right = lens.pixels_to_world(bottom_right, bottom_right_depths) + + top_left = np.array(top_left.T) + bottom_right = np.array(bottom_right.T) + obj_traj = [] + for i in range(len(top_left)): + current_tl = top_left[i] + current_br = bottom_right[i] + obj_traj.append([current_tl.tolist(), current_br.tolist()]) + + bbox_to_postgres( + conn, + item_id, + object_type, + "default_color" if item_id not in properties["color"] else properties["color"][item_id], + random.uniform(-10, 10), # heading + start_time, + tracked_cnt, + obj_traj, + world_id, + type="yolov4", + ) + # bbox_to_tasm() + + +def convert_timestamps(start_time, timestamps): + """Helper function to convert the timestam to the timestamp formula pg-trajectory uses""" + return [str(start_time + datetime.timedelta(seconds=t)) for t in timestamps] + + +def bbox_to_data3d(bbox): + """Helper function to convert trajectory to centroids + Compute the center, x, y, z delta of the bbox + """ + tl, br = bbox + x_delta = (br[0] - tl[0]) / 2 + y_delta = (br[1] - tl[1]) / 2 + z_delta = (br[2] - tl[2]) / 2 + center = (tl[0] + x_delta, tl[1] + y_delta, tl[2] + z_delta) + + return center, x_delta, y_delta, z_delta + + +def bbox_to_postgres( + conn, + item_id, + object_type, + color, + heading, + start_time, + timestamps, + bboxes, + world_id="default", + type="yolov3", +): + """Insert bboxes to postgres""" + if type == "yolov3": + timestamps = range(timestamps) + + converted_bboxes = [bbox_to_data3d(bbox) for bbox in bboxes] + pairs = [] + deltas = [] + for meta_box in converted_bboxes: + pairs.append(meta_box[0]) + deltas.append(meta_box[1:]) + postgres_timestamps = convert_timestamps(start_time, timestamps) + create_or_insert_general_trajectory( + conn, item_id, object_type, color, heading, postgres_timestamps, bboxes, pairs, world_id + ) + print(f"{item_id} saved successfully") + + +def clean_tables(conn): + cursor = conn.cursor() + cursor.execute("DROP TABLE IF EXISTS General_Bbox;") + cursor.execute("DROP TABLE IF EXISTS Item_General_Trajectory;") + conn.commit() + + +def create_or_insert_general_trajectory( + conn, + item_id, + object_type, + color, + heading, + postgres_timestamps, + bboxes, + pairs, + world_id="default", +): + """Create general trajectory table""" + # Creating a cursor object using the cursor() method + cursor = conn.cursor() + """ + Create and Populate A Trajectory table using mobilityDB. + Now the timestamp matches, the starting time should be the meta data of the world + Then the timestamp should be the timestamp regarding the world starting time + """ + + # Creating table with the first item + create_itemtraj_sql = """CREATE TABLE IF NOT EXISTS Item_General_Trajectory( + itemId TEXT, + objectType TEXT, + color TEXT, + heading REAL, + trajCentroids tgeompoint, + largestBbox stbox, + worldId TEXT, + PRIMARY KEY (itemId) + );""" + cursor.execute(create_itemtraj_sql) + cursor.execute( + "CREATE INDEX IF NOT EXISTS traj_idx ON Item_General_Trajectory USING GiST(trajCentroids);" + ) + conn.commit() + # Creating table with the first item + create_bboxes_sql = """CREATE TABLE IF NOT EXISTS General_Bbox( + itemId TEXT, + trajBbox stbox, + worldId TEXT, + FOREIGN KEY(itemId) + REFERENCES Item_General_Trajectory(itemId) + );""" + cursor.execute(create_bboxes_sql) + cursor.execute("CREATE INDEX IF NOT EXISTS item_idx ON General_Bbox(itemId);") + cursor.execute("CREATE INDEX IF NOT EXISTS traj_bbox_idx ON General_Bbox USING GiST(trajBbox);") + conn.commit() + # Insert the trajectory of the first item + insert_general_trajectory( + conn, item_id, object_type, color, heading, postgres_timestamps, bboxes, pairs, world_id + ) + + +def insert_general_trajectory( + conn, + item_id, + object_type, + color, + heading, + postgres_timestamps, + bboxes, + pairs, + world_id="default", +): + """Insert general trajectory""" + # Creating a cursor object using the cursor() method + cursor = conn.cursor() + # Inserting bboxes into Bbox table + insert_bbox_trajectory = "" + insert_format = ( + "INSERT INTO General_Bbox (itemId, worldId, trajBbox) " + + "VALUES ('%s','%s'," % (item_id + "-" + world_id, world_id) + ) + # Insert the item_trajectory separately + insert_trajectory = ( + "INSERT INTO Item_General_Trajectory (itemId, worldId, objectType, color, heading, trajCentroids, largestBbox) " + + "VALUES ('%s', '%s', '%s', '%s', '%s', " + % (item_id + "-" + world_id, world_id, object_type, color, heading) + ) + traj_centroids = "'{" + min_ltx, min_lty, min_ltz, max_brx, max_bry, max_brz = ( + float("inf"), + float("inf"), + float("inf"), + float("-inf"), + float("-inf"), + float("-inf"), + ) + # max_ltx, max_lty, max_ltz, min_brx, min_bry, min_brz = float('-inf'), float('-inf'), float('-inf'), float('inf'), float('inf'), float('inf') + for i in range(len(postgres_timestamps)): + postgres_timestamp = postgres_timestamps[i] + # Insert bbox + # print(bboxes[i]) + tl, br = bboxes[i] + min_ltx, min_lty, min_ltz, max_brx, max_bry, max_brz = ( + min(tl[0], min_ltx), + min(tl[1], min_lty), + min(tl[2], min_ltz), + max(br[0], max_brx), + max(br[1], max_bry), + max(br[2], max_brz), + ) + # max_ltx, max_lty, max_ltz, min_brx, min_bry, min_brz = max(tl[0], max_ltx), max(tl[1], max_lty), max(tl[2], max_ltz),\ + # min(br[0], min_brx), min(br[1], min_bry), min(br[2], min_brz) + current_bbox_sql = "stbox 'STBOX ZT((%s, %s, %s, %s), (%s, %s, %s, %s))');" % ( + tl[0], + tl[1], + tl[2], + postgres_timestamp, + br[0], + br[1], + br[2], + postgres_timestamp, + ) + insert_bbox_trajectory += insert_format + current_bbox_sql + # Construct trajectory + current_point = pairs[i] + tg_pair_centroid = "POINT Z (%s %s %s)@%s," % ( + str(current_point[0]), + str(current_point[1]), + str(current_point[2]), + postgres_timestamp, + ) + traj_centroids += tg_pair_centroid + traj_centroids = traj_centroids[:-1] + traj_centroids += "}', " + insert_trajectory += traj_centroids + insert_trajectory += "stbox 'STBOX Z((%s, %s, %s)," % ( + min_ltx, + min_lty, + min_ltz, + ) + "(%s, %s, %s))'); " % (max_brx, max_bry, max_brz) + # print(insert_trajectory) + cursor.execute(insert_trajectory) + cursor.execute(insert_bbox_trajectory) + # Commit your changes in the database + conn.commit() + + +def merge_trajectory(item_id, new_postgres_timestamps, new_bboxes, new_pairs): + # Fetch the timestamps of the current trajectory from the database + # Filter out the already had timestamp from the new timestamps + # Construct the adding trajectory + # Calling the merge function of mobilitydb + # do the same thing for the bboxes + return + + +def fetch_camera(conn, world_id="default", cam_id=[]): + cursor = conn.cursor() + + if cam_id == []: + query = ( + """SELECT cameraId, ratio, ST_X(origin), ST_Y(origin), ST_Z(origin), ST_X(focalpoints), ST_Y(focalpoints), fov, skev_factor """ + + """FROM Cameras WHERE worldId = \'%s\';""" % world_id + ) + else: + query = ( + """SELECT cameraId, ratio, ST_X(origin), ST_Y(origin), ST_Z(origin), ST_X(focalpoints), ST_Y(focalpoints), fov, skev_factor """ + + """FROM Cameras WHERE cameraId IN (\'%s\') AND worldId = \'%s\';""" + % (",".join(cam_id), world_id) + ) + cursor.execute(query) + return cursor.fetchall() diff --git a/apperception/world.py b/apperception/world.py index f5eedbdc..dadd9ce8 100644 --- a/apperception/world.py +++ b/apperception/world.py @@ -48,6 +48,7 @@ def get_name(self): def get_units(self): return self.VideoContext.get_units() + # TODO: should be add_item / add_camera? def item(self, item_id, cam_id, item_type, location): new_context = copy.deepcopy(self) new_context.VideoContext.item(item_id, cam_id, item_type, location) diff --git a/apperception/apperception_benchmark.py b/benchmarks/apperception_benchmark.py similarity index 92% rename from apperception/apperception_benchmark.py rename to benchmarks/apperception_benchmark.py index 2a6c0bf4..fa4e416b 100644 --- a/apperception/apperception_benchmark.py +++ b/benchmarks/apperception_benchmark.py @@ -10,7 +10,7 @@ # Let's define some attribute for constructing the world first name = "traffic_scene" # world name units = "metrics" # world units -video_file = "./amber_videos/traffic-scene-shorter.mp4" # example video file +video_file = "./amber_videos/traffic-scene-mini.mp4" # example video file lens_attrs = {"fov": 120, "cam_origin": (0, 0, 0), "skew_factor": 0} point_attrs = {"p_id": "p1", "cam_id": "cam1", "x": 0, "y": 0, "z": 0, "time": None, "type": "pos"} camera_attrs = {"ratio": 0.5} @@ -43,7 +43,7 @@ point_attrs["time"], point_attrs["type"], ) -location = point.Point(pt_id, cam_id, x, y, z, time, pt_type) +location = point.Point(pt_id, cam_id, (x, y, z), time, pt_type) ratio = camera_attrs["ratio"] @@ -80,7 +80,12 @@ .get_trajectory(distinct=True) .execute() ) + print(trajectory) + + # plot the trajectory of each cars on the first video frame + traffic_world.overlay_trajectory(cam_id, trajectory) + # Get the videos of these items # entire_video = traffic_world.predicate(lambda obj: obj.object_id in id_array, {"id_array":id_array}).get_video() # entire_video.execute() diff --git a/apperception_example.ipynb b/benchmarks/apperception_example.ipynb similarity index 98% rename from apperception_example.ipynb rename to benchmarks/apperception_example.ipynb index 12dae4be..c17210ea 100644 --- a/apperception_example.ipynb +++ b/benchmarks/apperception_example.ipynb @@ -125,27 +125,53 @@ "output_type": "stream", "name": "stdout", "text": [ - "Worlds Table created successfully........\n", - "New world inserted successfully........\n", - "Camera Table created successfully........\n", - "New camera inserted successfully.........\n", - "# of tracked items: 16\n", - "car-1 saved successfully\n", - "car-2 saved successfully\n", - "person-3 saved successfully\n", - "person-4 saved successfully\n", - "person-5 saved successfully\n", - "traffic light-6 saved successfully\n", - "traffic light-7 saved successfully\n", + "video 1/1 (1/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/byronhsu/Desktop/apperception/env/lib/python3.8/site-packages/torch/functional.py:445: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:2157.)\n", + " return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "video 1/1 (2/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (3/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (4/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (5/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (6/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (7/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (8/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (9/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (10/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (11/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (12/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (13/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (14/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (15/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (16/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (17/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (18/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (19/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (20/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (21/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (22/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (23/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (24/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (25/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (26/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (27/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (28/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (29/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (30/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (31/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (32/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (33/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (34/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (35/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (36/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (37/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (38/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (39/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (40/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (41/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (42/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (43/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (44/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (45/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (46/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (47/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (48/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (49/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (50/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (51/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (52/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (53/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (54/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (55/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (56/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (57/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (58/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (59/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (60/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (61/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (62/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (63/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (64/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (65/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (66/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (67/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (68/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (69/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (70/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (71/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (72/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (73/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (74/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (75/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (76/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (77/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (78/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (79/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (80/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (81/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (82/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (83/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (84/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (85/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (86/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (87/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "video 1/1 (88/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (89/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (90/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (91/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (92/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (93/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (94/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (95/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (96/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (97/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (98/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (99/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (100/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (101/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (102/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (103/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (104/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (105/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (106/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (107/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (108/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (109/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (110/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (111/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (112/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (113/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (114/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (115/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (116/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (117/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (118/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (119/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (120/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (121/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (122/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: video 1/1 (123/123) /Users/byronhsu/Desktop/apperception/amber_videos/traffic-scene-shorter.mp4: car-1 saved successfully\n", + "person-2 saved successfully\n", + "traffic light-3 saved successfully\n", + "car-4 saved successfully\n", + "car-6 saved successfully\n", + "person-7 saved successfully\n", + "traffic light-8 saved successfully\n", + "person-9 saved successfully\n", "person-10 saved successfully\n", "person-11 saved successfully\n", - "car-12 saved successfully\n", - "person-13 saved successfully\n", - "car-15 saved successfully\n", - "car-17 saved successfully\n", - "person-21 saved successfully\n", + "traffic light-12 saved successfully\n", + "person-12 saved successfully\n", + "car-13 saved successfully\n", + "person-15 saved successfully\n", + "car-18 saved successfully\n", + "traffic light-10 saved successfully\n", + "traffic light-9 saved successfully\n", + "person-19 saved successfully\n", + "car-20 saved successfully\n", + "truck-20 saved successfully\n", + "bus-20 saved successfully\n", + "person-24 saved successfully\n", "person-25 saved successfully\n", - "person-26 saved successfully\n" + "traffic light-25 saved successfully\n", + "traffic light-11 saved successfully\n" ] } ], diff --git a/benchmarks/new-api-scenic.ipynb b/benchmarks/new-api-scenic.ipynb new file mode 100644 index 00000000..e5bc3d91 --- /dev/null +++ b/benchmarks/new-api-scenic.ipynb @@ -0,0 +1,164 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "408d6be8", + "metadata": {}, + "outputs": [], + "source": [ + "%cd .." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e582655f", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import pandas as pd\n", + "import cv2\n", + "import psycopg2\n", + "import pickle\n", + "sys.path.append(os.path.join(os.getcwd(),\"apperception\"))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "51e7b5ce", + "metadata": {}, + "outputs": [], + "source": [ + "from new_world import empty_world, World\n", + "from camera import Camera" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f6156ab5", + "metadata": {}, + "outputs": [], + "source": [ + "World.db.reset()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0915d633", + "metadata": {}, + "outputs": [], + "source": [ + "# conn = psycopg2.connect(database=\"mobilitydb\", user=\"docker\", password=\"docker\", host=\"localhost\", port=25432)\n", + "# import_tables(conn)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4641c93d", + "metadata": {}, + "outputs": [], + "source": [ + "name = 'ScenicWorld' # world name\n", + "units = 'metrics' # world units\n", + "user_data_dir = os.path.join(\"v1.0-mini\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b5458d32", + "metadata": {}, + "outputs": [], + "source": [ + "with open('df_sample_data.pickle', \"rb\") as f:\n", + " df_sample_data = pickle.loads(f.read())\n", + "with open('df_annotation.pickle', \"rb\") as f:\n", + " df_annotation = pickle.loads(f.read())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "43aaae6f", + "metadata": {}, + "outputs": [], + "source": [ + "world = empty_world(name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "46d2d6f7", + "metadata": {}, + "outputs": [], + "source": [ + "from camera_config import fetch_camera_config\n", + "# scenes = [\"scene-0061\", \"scene-0103\",\"scene-0553\", \"scene-0655\", \"scene-0757\", \"scene-0796\", \"scene-0916\", \"scene-1077\", \"scene-1094\", \"scene-1100\"]\n", + "scenes = [\"scene-0061\"]\n", + "for scene in scenes:\n", + " config = fetch_camera_config(scene, df_sample_data)\n", + " camera = Camera(config=config, id=scene)\n", + " world = world.add_camera(camera)\n", + " df_config = df_sample_data[df_sample_data['scene_name'] == scene][['sample_token']]\n", + " df_ann = df_annotation.join(df_config.set_index('sample_token'), on='sample_token', how='inner')\n", + " world = world.recognize(camera, df_ann)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c11fd0c6", + "metadata": {}, + "outputs": [], + "source": [ + "car_trajectories = world.filter_traj_type(object_type='vehicle.car').get_traj()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9a372800", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a1d4ec08", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/benchmarks/new_apperception_benchmark.ipynb b/benchmarks/new_apperception_benchmark.ipynb new file mode 100644 index 00000000..c721cb0f --- /dev/null +++ b/benchmarks/new_apperception_benchmark.ipynb @@ -0,0 +1,426 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "49d6ebd1", + "metadata": {}, + "outputs": [], + "source": [ + "# Deleting the .apperception_cache if it exists, as to avoid DB conflict errors\n", + "import os\n", + "import shutil\n", + "\n", + "dirpath = os.path.join('.apperception_cache')\n", + "if os.path.exists(dirpath) and os.path.isdir(dirpath):\n", + " shutil.rmtree(dirpath)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "04d5291c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "get backend Qt5Agg\n" + ] + } + ], + "source": [ + "import sys\n", + "sys.path.append(os.path.join(os.getcwd(),\"apperception\"))\n", + "\n", + "### IMPORTS\n", + "import lens\n", + "import point\n", + "from new_world import empty_world\n", + "\n", + "# Let's define some attribute for constructing the world first\n", + "name = \"trafficScene\" # world name\n", + "units = \"metrics\" # world units\n", + "video_file = \"amber_videos/traffic-scene-shorter.mp4\" # example video file\n", + "lens_attrs = {\"fov\": 120, \"cam_origin\": (0, 0, 0), \"skew_factor\": 0}\n", + "point_attrs = {\"p_id\": \"p1\", \"cam_id\": \"cam1\", \"x\": 0, \"y\": 0, \"z\": 0, \"time\": None, \"type\": \"pos\"}\n", + "camera_attrs = {\"ratio\": 0.5}\n", + "fps = 30\n", + "\n", + "# 1. define a world\n", + "traffic_world = empty_world(name)\n", + "\n", + "# 2. construct a camera\n", + "fov, res, cam_origin, skew_factor = (\n", + " lens_attrs[\"fov\"],\n", + " [1280, 720],\n", + " lens_attrs[\"cam_origin\"],\n", + " lens_attrs[\"skew_factor\"],\n", + ")\n", + "cam_lens = lens.PinholeLens(res, cam_origin, fov, skew_factor)\n", + "\n", + "pt_id, cam_id, x, y, z, time, pt_type = (\n", + " point_attrs[\"p_id\"],\n", + " point_attrs[\"cam_id\"],\n", + " point_attrs[\"x\"],\n", + " point_attrs[\"y\"],\n", + " point_attrs[\"z\"],\n", + " point_attrs[\"time\"],\n", + " point_attrs[\"type\"],\n", + ")\n", + "location = point.Point(pt_id, cam_id, (x, y, z), time, pt_type)\n", + "\n", + "ratio = camera_attrs[\"ratio\"]\n", + "\n", + "# ingest the camera into the world\n", + "traffic_world = traffic_world.add_camera(\n", + " cam_id=cam_id,\n", + " location=location,\n", + " ratio=ratio,\n", + " video_file=video_file,\n", + " metadata_identifier=name + \"_\" + cam_id,\n", + " lens=cam_lens,\n", + ")\n", + "\n", + "# Call execute on the world to run the detection algorithm and save the real data to the database\n", + "recognized_world = traffic_world.recognize(cam_id)\n", + "\n", + "volume = traffic_world.select_intersection_of_interest_or_use_default(cam_id=cam_id)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5f1f65fd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cameras are [('cam1', 0.5, 0.0, 0.0, 0.0, 369.5041722813606, 207.84609690826534, 120, 0.0)]\n", + "lens are [(0.5, 0.0, 0.0, 0.0, 120, 0.0)]\n" + ] + } + ], + "source": [ + "cams = traffic_world.get_camera()\n", + "lens = traffic_world.get_len()\n", + "# ids = traffic_world.get_id()\n", + "print(\"cameras are\", cams)\n", + "print(\"lens are\", lens)\n", + "# print(\"ids are\", ids)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3bd024c9", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading weights from C:\\Users\\youse\\Desktop\\Research\\Apperception\\apperception\\apperception\\../yolov5-deepsort/deep_sort_pytorch/deep_sort/deep/checkpoint/ckpt.t7... Done!\n", + "YOLOv5 v6.0-159-gdb6ec66 torch 1.10.2+cu113 CUDA:0 (NVIDIA GeForce RTX 3060 Laptop GPU, 6144MiB)\n", + "\n", + "Fusing layers... \n", + "Model Summary: 213 layers, 7225885 parameters, 0 gradients\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "car-1 saved successfully\n", + "person-2 saved successfully\n", + "traffic light-3 saved successfully\n", + "car-4 saved successfully\n", + "car-6 saved successfully\n", + "person-7 saved successfully\n", + "traffic light-8 saved successfully\n", + "person-9 saved successfully\n", + "person-10 saved successfully\n", + "traffic light-12 saved successfully\n", + "person-12 saved successfully\n", + "person-13 saved successfully\n", + "car-14 saved successfully\n", + "person-16 saved successfully\n", + "bus-14 saved successfully\n", + "car-19 saved successfully\n", + "traffic light-10 saved successfully\n", + "traffic light-13 saved successfully\n", + "person-20 saved successfully\n", + "car-21 saved successfully\n", + "truck-21 saved successfully\n", + "bus-21 saved successfully\n", + "person-25 saved successfully\n", + "person-26 saved successfully\n", + "traffic light-26 saved successfully\n", + "traffic light-9 saved successfully\n", + "get_traj_key SELECT sq2.itemid FROM (SELECT * FROM (SELECT * FROM (SELECT * FROM item_general_trajectory WHERE worldId='a29b573e-70a0-4b6c-b19d-4f453867ce4f') sq0 WHERE sq0.objecttype='car') sq1 WHERE overlap(sq1.largestBbox,'STBOX Z((0.01082532, 2.59647246, 0),(3.01034039, 3.35985782, 2))')) sq2\n", + "filtered_ids are [('car-1-a29b573e-70a0-4b6c-b19d-4f453867ce4f',), ('car-4-a29b573e-70a0-4b6c-b19d-4f453867ce4f',), ('car-14-a29b573e-70a0-4b6c-b19d-4f453867ce4f',), ('car-21-a29b573e-70a0-4b6c-b19d-4f453867ce4f',)]\n" + ] + } + ], + "source": [ + "# This piece of code is unsafe, and should not be run if not needed. \n", + "# It serves for test purposes when one recieves a \"dead kernel\" error.\n", + "# os.environ[\"KMP_DUPLICATE_LIB_OK\"]=\"TRUE\"\n", + "\n", + "filtered_world = recognized_world.filter_traj_type(\"car\").filter_traj_volume(volume).interval(0, fps * 3)\n", + "filtered_ids = filtered_world.get_traj_key()\n", + "print(\"filtered_ids are\", filtered_ids)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "6e5d5bc6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "get_traj SELECT asMFJSON(trajCentroids)::json->'coordinates' FROM (SELECT * FROM (SELECT * FROM (SELECT * FROM item_general_trajectory WHERE worldId='a29b573e-70a0-4b6c-b19d-4f453867ce4f') sq0 WHERE sq0.objecttype='car') sq1 WHERE overlap(sq1.largestBbox,'STBOX Z((0.01082532, 2.59647246, 0),(3.01034039, 3.35985782, 2))')) as final\n", + "trajectories are [([[2.212424273730558, 2.574019950137081, 1], [2.212424273730558, 2.574019950137081, 1], [2.213777438423971, 2.574019950137081, 1], [2.213777438423971, 2.574019950137081, 1], [2.213777438423971, 2.574019950137081, 1], [2.213777438423971, 2.574019950137081, 1], [2.213777438423971, 2.574019950137081, 1], [2.213777438423971, 2.574019950137081, 1], [2.213777438423971, 2.574019950137081, 1], [2.212424273730558, 2.574019950137081, 1], [2.213777438423971, 2.574019950137081, 1], [2.213777438423971, 2.574019950137081, 1], [2.213777438423971, 2.574019950137081, 1], [2.212424273730558, 2.574019950137081, 1], [2.212424273730558, 2.574019950137081, 1], [2.211071109037144, 2.571614324015457, 1], [2.211071109037144, 2.571614324015457, 1], [2.211071109037144, 2.571614324015457, 1], [2.211071109037144, 2.571614324015457, 1], [2.211071109037144, 2.569208697893834, 1], [2.209717944343731, 2.574019950137081, 1], [2.208364779650318, 2.569208697893834, 1], [2.208364779650318, 2.569208697893834, 1], [2.208364779650318, 2.569208697893834, 1], [2.208364779650318, 2.569208697893834, 1], [2.208364779650318, 2.569208697893834, 1], [2.208364779650318, 2.571614324015457, 1], [2.207011614956905, 2.569208697893834, 1], [2.208364779650318, 2.574019950137081, 1], [2.208364779650318, 2.571614324015457, 1], [2.208364779650318, 2.571614324015457, 1], [2.208364779650318, 2.574019950137081, 1], [2.208364779650318, 2.574019950137081, 1], [2.208364779650318, 2.574019950137081, 1], [2.211071109037144, 2.574019950137081, 1], [2.211071109037144, 2.574019950137081, 1], [2.212424273730558, 2.574019950137081, 1], [2.211071109037144, 2.574019950137081, 1], [2.211071109037144, 2.574019950137081, 1], [2.208364779650318, 2.574019950137081, 1], [2.208364779650318, 2.576425576258704, 1], [2.211071109037144, 2.576425576258704, 1], [2.211071109037144, 2.576425576258704, 1], [2.211071109037144, 2.574019950137081, 1], [2.211071109037144, 2.574019950137081, 1], [2.211071109037144, 2.574019950137081, 1], [2.209717944343731, 2.574019950137081, 1], [2.209717944343731, 2.574019950137081, 1], [2.208364779650318, 2.574019950137081, 1], [2.208364779650318, 2.574019950137081, 1], [2.208364779650318, 2.574019950137081, 1], [2.207011614956905, 2.574019950137081, 1], [2.208364779650318, 2.574019950137081, 1], [2.209717944343731, 2.571614324015457, 1], [2.211071109037144, 2.571614324015457, 1], [2.21377743842397, 2.569208697893834, 1], [2.211071109037144, 2.574019950137081, 1], [2.21377743842397, 2.569208697893834, 1], [2.212424273730557, 2.569208697893834, 1], [2.212424273730557, 2.564397445650587, 1], [2.21377743842397, 2.564397445650587, 1], [2.21377743842397, 2.55958619340734, 1], [2.211071109037144, 2.55958619340734, 1], [2.211071109037144, 2.566803071772211, 1], [2.211071109037144, 2.564397445650587, 1], [2.211071109037144, 2.564397445650587, 1], [2.211071109037144, 2.564397445650587, 1], [2.211071109037144, 2.564397445650587, 1], [2.211071109037144, 2.566803071772211, 1], [2.209717944343731, 2.569208697893834, 1], [2.208364779650318, 2.571614324015457, 1], [2.208364779650318, 2.569208697893834, 1], [2.208364779650318, 2.571614324015457, 1], [2.208364779650318, 2.569208697893834, 1], [2.208364779650318, 2.569208697893834, 1], [2.208364779650318, 2.569208697893834, 1], [2.208364779650318, 2.564397445650587, 1], [2.208364779650318, 2.564397445650587, 1], [2.208364779650318, 2.564397445650587, 1], [2.208364779650318, 2.569208697893834, 1], [2.208364779650318, 2.569208697893834, 1], [2.209717944343731, 2.569208697893834, 1], [2.209717944343731, 2.569208697893834, 1], [2.211071109037144, 2.564397445650587, 1], [2.211071109037144, 2.566803071772211, 1], [2.212424273730557, 2.566803071772211, 1], [2.212424273730557, 2.569208697893834, 1], [2.212424273730557, 2.566803071772211, 1], [2.211071109037144, 2.569208697893834, 1], [2.211071109037144, 2.569208697893834, 1], [2.211071109037144, 2.569208697893834, 1], [2.211071109037144, 2.569208697893834, 1], [2.211071109037144, 2.569208697893834, 1], [2.211071109037144, 2.569208697893834, 1], [2.209717944343731, 2.569208697893834, 1], [2.211071109037144, 2.569208697893834, 1], [2.209717944343731, 2.569208697893834, 1], [2.209717944343731, 2.574019950137081, 1], [2.211071109037144, 2.571614324015457, 1], [2.209717944343731, 2.569208697893834, 1], [2.211071109037144, 2.566803071772211, 1], [2.211071109037144, 2.566803071772211, 1], [2.211071109037144, 2.566803071772211, 1], [2.211071109037144, 2.569208697893834, 1], [2.211071109037144, 2.566803071772211, 1], [2.211071109037144, 2.566803071772211, 1], [2.209717944343731, 2.566803071772211, 1], [2.209717944343731, 2.569208697893834, 1], [2.209717944343731, 2.569208697893834, 1], [2.209717944343731, 2.566803071772211, 1], [2.208364779650318, 2.564397445650587, 1], [2.208364779650318, 2.564397445650587, 1], [2.208364779650318, 2.564397445650587, 1], [2.208364779650318, 2.566803071772211, 1], [2.209717944343731, 2.566803071772211, 1], [2.211071109037144, 2.569208697893834, 1], [2.209717944343731, 2.569208697893834, 1], [2.209717944343731, 2.571614324015457, 1], [2.209717944343731, 2.571614324015457, 1], [2.209717944343731, 2.571614324015457, 1], [2.209717944343731, 2.571614324015457, 1]],), ([[0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.606217782649107, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.60351145326228, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.60351145326228, 2.569208697893834, 1], [0.60351145326228, 2.569208697893834, 1], [0.60351145326228, 2.569208697893834, 1], [0.60351145326228, 2.569208697893834, 1], [0.60351145326228, 2.569208697893834, 1], [0.60351145326228, 2.569208697893834, 1], [0.60351145326228, 2.569208697893834, 1], [0.604864617955694, 2.569208697893834, 1], [0.60351145326228, 2.569208697893834, 1], [0.60351145326228, 2.569208697893834, 1], [0.60351145326228, 2.569208697893834, 1], [0.60351145326228, 2.569208697893834, 1], [0.60351145326228, 2.569208697893834, 1], [0.60351145326228, 2.569208697893834, 1], [0.602158288568867, 2.569208697893834, 1], [0.602158288568867, 2.569208697893834, 1], [0.602158288568867, 2.569208697893834, 1], [0.602158288568867, 2.569208697893834, 1], [0.602158288568867, 2.569208697893834, 1], [0.602158288568867, 2.569208697893834, 1], [0.60351145326228, 2.564397445650587, 1], [0.602158288568867, 2.569208697893834, 1], [0.602158288568867, 2.569208697893834, 1], [0.602158288568867, 2.569208697893834, 1], [0.602158288568867, 2.569208697893834, 1], [0.602158288568867, 2.569208697893834, 1]],), ([[2.414045813049122, 3.343820309056582, 1], [2.408633154275469, 3.310141543353854, 1], [2.408633154275469, 3.305330291110607, 1], [2.411339483662296, 3.290896534380866, 1], [2.411339483662296, 3.269245899286255, 1], [2.414045813049122, 3.254812142556514, 1], [2.414045813049122, 3.247595264191644, 1], [2.412692648355708, 3.23797275970515, 1], [2.414045813049122, 3.213916498488916, 1], [2.414045813049122, 3.194671489515929, 1], [2.411339483662296, 3.180237732786188, 1], [2.40457366019523, 3.158587097691577, 1], [2.40457366019523, 3.15377584544833, 1], [2.405926824888643, 3.14655896708346, 1], [2.40051416611499, 3.129719584232096, 1], [2.397807836728164, 3.120097079745602, 1], [2.397807836728164, 3.122502705867225, 1], [2.395101507341337, 3.117691453623979, 1], [2.392395177954511, 3.112880201380732, 1], [2.389688848567685, 3.108068949137485, 1], [2.389688848567685, 3.100852070772614, 1], [2.389688848567685, 3.096040818529367, 1], [2.392395177954511, 3.08401268792125, 1], [2.392395177954511, 3.064767678948263, 1], [2.392395177954511, 3.045522669975275, 1], [2.397807836728164, 3.028683287123911, 1], [2.405926824888643, 3.023872034880664, 1], [2.414045813049122, 3.0070326520293, 1], [2.420811636516188, 2.99259889529956, 1], [2.428930624676667, 2.980570764691442, 1], [2.438402777530559, 2.963731381840078, 1], [2.446521765691038, 2.94448637286709, 1], [2.457347083238344, 2.927646990015726, 1], [2.470878730172476, 2.910807607164362, 1], [2.476291388946128, 2.896373850434622, 1], [2.487116706493434, 2.877128841461634, 1], [2.497942024040739, 2.86028945861027, 1], [2.514180000361698, 2.84585570188053, 1], [2.525005317909003, 2.829016319029166, 1], [2.538536964843135, 2.814582562299425, 1], [2.550715447083854, 2.795337553326438, 1], [2.562893929324572, 2.780903796596697, 1], [2.573719246871878, 2.766470039866956, 1], [2.589957223192836, 2.752036283137215, 1], [2.604842034820381, 2.737602526407475, 1], [2.6170205170611, 2.718357517434487, 1], [2.633258493382058, 2.708735012947994, 1], [2.648143305009603, 2.689490003975006, 1], [2.663028116637148, 2.679867499488512, 1], [2.668440775410801, 2.670244995002019, 1], [2.687385081118586, 2.650999986029031, 1], [2.699563563359304, 2.646188733785785, 1], [2.709035716213196, 2.63656622929929, 1], [2.721214198453915, 2.631754977056044, 1], [2.73609901008146, 2.617321220326302, 1], [2.746924327628766, 2.612509968083056, 1], [2.756396480482658, 2.600481837474939, 1], [2.767221798029963, 2.588453706866821, 1], [2.773987621497029, 2.581236828501951, 1], [2.780753444964095, 2.574019950137081, 1], [2.788872433124574, 2.571614324015457, 1], [2.801050915365293, 2.55958619340734, 1], [2.809169903525772, 2.549963688920847, 1], [2.817288891686251, 2.542746810555976, 1], [2.828114209233556, 2.535529932191106, 1], [2.836233197394036, 2.535529932191106, 1], [2.841645856167688, 2.535529932191106, 1], [2.852471173714994, 2.521096175461365, 1], [2.857883832488647, 2.516284923218119, 1], [2.866002820649126, 2.506662418731625, 1], [2.872768644116191, 2.501851166488378, 1], [2.88494712635691, 2.492228662001884, 1], [2.894419279210803, 2.487417409758637, 1], [2.898478773291042, 2.48260615751539, 1], [2.912010420225174, 2.477794905272143, 1], [2.920129408385654, 2.472983653028896, 1], [2.925542067159306, 2.46817240078565, 1], [2.933661055319785, 2.458549896299156, 1], [2.941780043480264, 2.456144270177532, 1], [2.95260536102757, 2.448927391812662, 1], [2.958018019801222, 2.441710513447791, 1], [2.966137007961701, 2.439304887326168, 1], [2.971549666735354, 2.436899261204545, 1], [2.976962325509007, 2.432088008961298, 1], [2.985081313669486, 2.424871130596427, 1], [2.993200301829965, 2.420059878353181, 1], [2.998612960603618, 2.41284299998831, 1], [3.006731948764097, 2.40562612162344, 1], [3.01214460753775, 2.39840924325857, 1], [3.014850936924576, 2.396003617136946, 1], [3.022969925085055, 2.388786738772076, 1], [3.031088913245534, 2.386381112650453, 1], [3.036501572019187, 2.376758608163959, 1], [3.04191423079284, 2.376758608163959, 1], [3.047326889566492, 2.374352982042336, 1], [3.052739548340146, 2.367136103677465, 1], [3.060858536500624, 2.364730477555842, 1], [3.066271195274277, 2.359919225312595, 1], [3.074390183434756, 2.355107973069348, 1], [3.077096512821583, 2.352702346947725, 1], [3.079802842208409, 2.347891094704478, 1], [3.082509171595235, 2.345485468582854, 1], [3.090628159755715, 2.345485468582854, 1], [3.096040818529367, 2.338268590217984, 1], [3.10145347730302, 2.333457337974737, 1], [3.104159806689847, 2.32864608573149, 1], [3.109572465463499, 2.326240459609867, 1], [3.114985124237152, 2.319023581244997, 1], [3.117691453623978, 2.311806702880126, 1], [3.123104112397631, 2.309401076758503, 1], [3.128516771171284, 2.30699545063688, 1], [3.133929429944936, 2.302184198393633, 1], [3.139342088718589, 2.302184198393633, 1]],), ([[1.764526760210793, 3.271651525407878, 1], [1.73746346634253, 3.247595264191644, 1], [1.661686243511391, 3.199482741759176, 1], [1.661686243511391, 3.199482741759176, 1], [1.615678643935343, 3.177832106664565, 1], [1.588615350067079, 3.165803976056448, 1], [1.577790032519774, 3.151370219326707, 1], [1.552079903344923, 3.141747714840213, 1], [1.526369774170073, 3.136936462596966, 1], [1.511484962542528, 3.132125210353719, 1], [1.497953315608396, 3.129719584232096, 1], [1.477655845207198, 3.122502705867225, 1], [1.458711539499413, 3.105663323015861, 1], [1.435707739711389, 3.100852070772614, 1], [1.415410269310192, 3.096040818529367, 1], [1.39781912829582, 3.088823940164497, 1], [1.374815328507796, 3.07679580955638, 1], [1.359930516880251, 3.050333922218522, 1], [1.350458364026358, 3.026277661002288, 1], [1.340986211172466, 3.016655156515794, 1], [1.324748234851508, 2.99259889529956, 1], [1.30851025853055, 2.966137007961702, 1], [1.294978611596418, 2.954108877353585, 1], [1.282800129355699, 2.93005261613735, 1], [1.267915317728154, 2.910807607164362, 1], [1.257090000180849, 2.891562598191375, 1], [1.250324176713783, 2.877128841461634, 1], [1.236792529779651, 2.8530725802454, 1], [1.223260882845519, 2.83863882351566, 1], [1.2110824006048, 2.821799440664296, 1], [1.198903918364082, 2.809771310056178, 1], [1.18943176551019, 2.790526301083191, 1], [1.178606447962884, 2.77609254435345, 1], [1.165074801028752, 2.766470039866956, 1], [1.158308977561686, 2.752036283137215, 1], [1.150189989401207, 2.737602526407475, 1], [1.142071001240728, 2.723168769677734, 1], [1.136658342467075, 2.708735012947994, 1], [1.128539354306596, 2.6991125084615, 1], [1.120420366146117, 2.684678751731759, 1], [1.109595048598812, 2.667839368880395, 1], [1.102829225131746, 2.655811238272278, 1], [1.09606340166468, 2.641377481542537, 1], [1.089297578197614, 2.631754977056044, 1], [1.082531754730548, 2.626943724812797, 1], [1.074412766570069, 2.614915594204679, 1], [1.064940613716176, 2.598076211353315, 1], [1.063587449022764, 2.583642454623575, 1], [1.051408966782045, 2.583642454623575, 1], [1.047349472701805, 2.574019950137081, 1], [1.040583649234739, 2.564397445650587, 1], [1.0365241551545, 2.55236931504247, 1], [1.028405166994021, 2.540341184434353, 1], [1.021639343526955, 2.533124306069483, 1], [1.017579849446715, 2.523501801582989, 1], [1.009460861286236, 2.521096175461365, 1], [1.005401367205996, 2.511473670974872, 1], [0.99863554373893, 2.501851166488378, 1]],)]\n" + ] + } + ], + "source": [ + "trajectory = filtered_world.get_traj()\n", + "print(\"trajectories are\", trajectory)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "afc827d0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "get_traj SELECT asMFJSON(trajCentroids)::json->'coordinates' FROM (SELECT * FROM (SELECT * FROM (SELECT * FROM item_general_trajectory WHERE worldId='a29b573e-70a0-4b6c-b19d-4f453867ce4f') sq0 WHERE sq0.objecttype='car') sq1 WHERE overlap(sq1.largestBbox,'STBOX Z((0.01082532, 2.59647246, 0),(3.01034039, 3.35985782, 2))')) as final\n", + "headings are [[None, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 240.64224645719918, 0.0, 0.0, 0.0, 270.0, 105.70863782901449, 254.29136217098548, 0.0, 0.0, 0.0, 0.0, 90.0, 240.64224645720623, 74.29136217098551, 270.0, 0.0, 90.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 90.0, 0.0, 0.0, 270.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 299.35775354278474, 0.0, 318.36646066342803, 119.35775354278525, 299.35775354278525, 0.0, 270.0, 0.0, 270.0, 0.0, 90.0, 270.0, 0.0, 0.0, 0.0, 90.0, 119.35775354279377, 119.35775354279377, 270.0, 90.0, 270.0, 0.0, 0.0, 270.0, 0.0, 0.0, 90.0, 0.0, 0.0, 0.0, 285.7086378290145, 90.0, 0.0, 90.0, 270.0, 119.35775354278576, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 90.0, 299.35775354278474, 240.64224645720623, 299.3577535427938, 0.0, 0.0, 90.0, 270.0, 0.0, 0.0, 90.0, 0.0, 270.0, 240.64224645721524, 0.0, 0.0, 90.0, 0.0, 60.64224645720623, 0.0, 90.0, 0.0, 0.0, 0.0], [None, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 285.7086378290133, 105.7086378290133, 0.0, 0.0, 0.0, 0.0], [None, 260.8698235177206, 270.0, 280.61965527615735, 270.0, 280.61965527615394, 270.0, 261.99527114270296, 273.2194948968547, 270.0, 259.380344723846, 252.64597536373927, 270.0, 280.6196552761549, 252.18111108547583, 254.29136217098616, 90.0, 240.64224645719815, 240.64224645721475, 240.642246457213, 270.0, 270.0, 282.68038349181927, 270.0, 270.0, 287.81888891452274, 329.3493320429478, 295.74070835623223, 295.1148348861449, 304.01934998982523, 299.3577535427904, 292.8736651906257, 302.73522627210974, 308.7843641002978, 290.55604521958094, 299.3577535427917, 302.7352262721065, 318.36646066343224, 302.7352262721065, 313.152389734005, 302.3261399943782, 310.1559996249172, 306.8698976458454, 318.36646066342814, 315.88140399658323, 302.32613999437694, 329.34933204294947, 307.7197109160052, 327.1187603347254, 299.3577535427924, 314.5488614532131, 338.442920714965, 314.54886145320773, 338.4429207149664, 315.8814039965797, 336.0375110254266, 308.2204320548504, 311.98721249581337, 313.1523897340067, 313.1523897340068, 343.4956386182417, 315.3558698306227, 310.15599962492115, 318.36646066342706, 326.30993247402074, 0.0, 0.0, 306.8698976458443, 318.3664606634374, 310.15599962491723, 324.58294472352856, 321.68690932618284, 333.07232214896084, 310.155999624917, 340.4268741695884, 329.3493320429492, 318.3664606634327, 310.15599962491723, 343.4956386182417, 326.309932474024, 306.8698976458361, 343.4956386182474, 336.0375110254275, 318.3664606634321, 318.3664606634255, 329.34933204295106, 306.8698976458429, 318.36646066343076, 306.86989764584797, 318.36646066341694, 318.36646066343076, 343.4956386182474, 299.3577535427921, 0.0, 336.03751102542225, 306.8698976458491, 343.4956386182457, 318.3664606634295, 329.34933204294646, 318.36646066344207, 299.3577535427893, 318.3664606634123, 0.0, 306.8698976458412, 318.3664606634321, 299.357753542795, 336.03751102542225, 306.86989764584797, 290.5560452195796, 336.0375110254257, 336.0375110254275, 318.36646066342513, 0.0], [None, 221.63353933657015, 212.41230661835067, 0.0, 205.20112364547506, 203.96248897457784, 233.13010235415794, 200.5193171608242, 190.5994237164336, 197.91250938596315, 190.08059798754033, 199.57312583041212, 221.63353933656953, 191.81314470013723, 193.33510634104744, 202.3062050549055, 207.60397993061923, 240.64224645720856, 248.50795996665428, 225.45113854678763, 235.98065001017392, 238.46520809481171, 221.63353933656973, 243.14918670604567, 232.28028908399415, 240.64224645720915, 244.88516511385575, 240.64224645720833, 226.84761026599236, 234.1250086479352, 224.64413016938153, 243.79416530447276, 233.1301023541551, 215.41705527646823, 244.88516511385575, 240.64224645720864, 240.6422464572095, 249.4439547804146, 229.84400037508198, 240.6422464572095, 237.26477372789347, 240.64224645720833, 244.88516511385575, 234.88798881557486, 215.41705527646698, 235.9806500101755, 240.6422464572073, 264.6441749571486, 0.0, 247.12633480937143, 234.88798881557736, 251.35046124595095, 235.98065001017426, 226.84761026599236, 247.12633480937143, 196.5043613817579, 247.1263348093697, 234.88798881557858]]\n" + ] + } + ], + "source": [ + "headings = filtered_world.get_headings()\n", + "print(\"headings are\", headings)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "aca1cfc3", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "get backend Qt5Agg\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAADfCAYAAAAN+JPJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9WYxlW3rfif3WsKczxJiRkeO9t6puFWsii8Vm05So7pbdNtBu2BBgoAW1DaMNCCAEyBAM+oGUX/pJgJ4EGLBfaLhhNeC2JHhAN4zulluEZolki8VisaZbd74354z5DHtagx/W3id2nDjnxInMvFSKyO8ib0TsYe21117rv77v/33rW8J7zxt5I2/kjbyRP10i/3VX4I28kTfyRt7Iq5c34P5G3sgbeSN/CuUNuL+RN/JG3sifQnkD7m/kjbyRN/KnUN6A+xt5I2/kjfwplDfg/kbeyBt5I38K5QsDdyHEfyCEeE8I8YEQ4re+qOe8kTfyRt7IG7ks4ouIcxdCKOBnwP8EeAD898B/7L3/8St/2Bt5I2/kjbyRS/JFae6/Anzgvf/Ie18Bfwf4C1/Qs97IG3kjb+SNzIn+gsq9C3ze+fsB8D9YdnG/3/c7OzsLzwkhXm3NlpTfWjBf9PNeRF64Tmved+Gqq+7xnkW2nrjG866qx9Ly56vyAmUvK0MsOLayvOYiL1aXv0oWWs3/uvrfXF38kuPdvviva3X7v0mr6l+2rlfd/+DBgwPv/d6ic18UuF85FoUQvw78OsD29ja/8Ru/0T238Pe5+5dec1WDCCEu/FtW7qrnX+e8lJcNJOfcWuV672dlrFsXN/f3peua9vHN+bbsdSY67/3Cuq9Tv0V1vVBGW/78tWuXevEez3mnUwu+NYBt3lV13t0tmcC6dZkH96XiL9636GUu9Nduv54rZjYRzX2n+XIWvacQYmn7LirDOYf3/sIzBCDnwL1tP7nguS8KbN3nLnvXrrT9sXtNO24ulIsHD6Jt2blmepH6ts9p750vo23HZc9Y9sz5cpfd8xu/8RufLqvbFwXuD4D7nb/vAY+6F3jvfxv4bYD79+/7V6kxX1XWIrBddN/L1qkLmPNltXVYBJTz9813kG4ZHnDtQFhR9+5gcc21wnsQAu8cLGiT+QEyXwcp5ZWT1DJZNPjmZZUm355fCIANOHfbcNE3n9WhO/g6Za871K+67sqyhFj4HvP3vEh/XNinrwCxV6UZv4yWPw9sy97dez/rh917VraV55UA+5XP4fJ7rLp/0fsumtzW7QdfFLj/98BXhRBfAh4Cfwn4X35Bz7ryg84P7GWazarzi+RlwL+9dxFALpsIriPe+4VUyUzDoOnf3uMbgJ9vg0Uds51o2jpJKZdqLVe1z1Ud9ipwX1puW14DmleCTDPhLXv+Qlnz0/vmv3DL/HT0auUq5aRr0S3TjNs+s3BMzWnys+c097wKab/dOpM/nWsXAfzaz/yCaZ759l72vFVWyjoWzLx8IeDuvTdCiP8t8PcBBfxn3vsfrXPvq9Tgu6B4FaB/UTIPmIsAsAXIVR16GUUCjVd8Tvu7dH/3vmXnugO80erb6+fvaes6o4LmJqj2nWb1bq+/+FIX6vNiNsBlWdVW6zxjVTvOK32L4HqBLUZDClzJ/S8TNXsngRfLrSrZ/SZraozdWtJo9l3LctZnm/7bvoe4UK/rSbeO3Vq+EAXXAfh5RePi5ARefLFAvqhu7c92jKyrzS8D+XUB/ovS3PHe/9fAf73OtYu471XXriPX5YCvU/5167qKnukO0mXXdMtb1GlXm6BLNK0Vf3frBsvBvdvJ5i0Q7xyiO7kuee6l2nVog+7EsEjmJ4tXoYHNa64Lzy+ox4U6zPHUYRJbW9Vf+rALbzuvcXf7GlygpeaL6z6ie3/XkhMspq0WyTpa5XU16lU0zKryr6b6xBdpPC1V4LrWLlz0Eyxrm2Xtum5bfmHg/rLyMlp1F9jX4cS+CFk2ucwDwTqd8kUoo1XyQpPeooMdbXyRVnoJ0ub644yuWKLRd8u5gHl/whZXK4u0/xYQL/D713nQkjHa1fN9KPhi3eb8Cpfq3znnGoruKppr4WTbOUdbjyV02nX45fljyyi6hQ5FLs+B3fddee+adM/LyDKA79ahC/TdOi2iOFdNGKvktQX368oX+cHWdtQsufeqcy9T9xdxVF1Xlt0hCBo6QgRtlzlA77bZqnZYUTc/d83Ker4A37qgkJWWwqVohwV1W7eNvfdLX0zQoVe4CF4t2Lfa9fyzL1gz8/c1Za3TTldplNe5Z51nrTo+Tw2tU1aXCln1nFUT+bqySGmbL2sdyrVrEa8D8KvktQT3FwW7VfTOdemWVWFV64DyIipmXc1lXbkuR9+VVnPodqSXqUvL77Za1VVExCXNawWwyyX16t7RarNyrpx5sLuqF5zTKJ16XPHcF56aFw3YzvPX+QoX+mXz8wLtsuK+mdN9hUghsF3lZs06rduHZt++y+UvAca2vvPhmIvq1KVC1uW65++fr8O6Mv+cS/TYiv7VHYOLyvnX7lB9UXlZ7XsVuL9sXVowvIoiedEOtKwDdD/2SmfRkvosknnaquscnZ/U1ql71ynWHpdXgJ5Y5V1sr1nxzGV1WjbQl5XZlav43GXPeGFtldV96Kr1CpfK4uLkul4lxGzdw6IyoeMch6URM8uLX0Nh6DiD1ylrNoktUW7mJ4T5gIWXtXbXtXqWyVWUDSwPM75O/V8bcF9r4DYvtmg2m5/x1nneqtl1/vgicF9WhxcxoRZd275zW5619tplwWWn7TKLYlHbXlXHrlYEF6M11tLyllZ69r/2gWuUdrFur1Kuq42tI6soDyEEihXau18QZTJfp/bS5ueM5W3adh46ltVHdH7i/dJ1F4veo/v3Mg58/vy80nPdyJJVZc2HS74IB/+ik/l8nVtZ1q+WWQ/r1ve1AfdVctXsf12NfR1apZV5YFx233UH+zrn50M5lVIrtZV5oF31zK4mM9++63S+VZPeWl+ivWhZO4i1S/oTky9i0ljnWdeBkWU+ilarv+AM5XqUg/cevwawX0eW9eWrLORF16yiMLoK2LqBDOvW+zqW+qoJfZVCuEixvUpeW3Cf1zCXvdgi8O2Wsei6F6nLdY63z1tWz3WeteidVk1yV7179/dVHWQRWHcnglV1elHtdZmmtez6q667rlb5Rcqq+i6zBpZNlBc09WV9snOt6PzrlnGVk1rAJavAd39eoWwtkpd1UC46vwwM59t8vo1b7X1Rv+s+d93V19ex1Fdp/YsmnkXjsPv3KnmtwX3RytJlq9DWoRBetB7XtQy6z1xmHq66Z5WsA8xX1aXlIeeft+r+l7VEvqh7XsREXjQRvUpttCuvqt26gCw6vy8qb9m7rHKKXgDA+Wu8D//mrLwuQF6lWV6nvbtjf9Wq06s03nnKp/3ZVWBWgft8fdf1QV0l60yOiya3+XF41eTz2oH7dTWyZcCz7rGr6qKUWgluV3Fh65pv8wOle8+r1jRfJJ3Bq5JX8V1e9r55+aKB/VVMPhfOt+UvvvlCOcvKX/X3ouvnabx5ZaXtu61faF6uok3my2qlu+p0WV3XAf9F2vBVWLNs0dGy91sl16Fu5u950X702oE7XP7A3c7Vvab7+xcBgq8aZFfdv8phu2zmnj9/nee/CkC9Tmd7laD+sve+zHPWde698r4YCr4Yqz5vxTTPXjda5kWoklVUwary1qESF51fl2dep18u0tQX1WORgnVVkrzW2ug++0WT6i2qb7ee61KYrx24LzOZlzkLF83CXzSILZtJrzuo5zWhqz7aq6ATXqWWvG5dln2zV1WPly3jRUzqFy3/RayELo9+QWtvgNxznl+IzrVLOfU5muLK5y8A9HngelXWz6IJ5EXK6NZpXVC/6v5VFu91LIqrnr+OhbPq/lZeO3CHy062eWfevIb0RQF724kXde5l972I1nadOi+bAK7jg7iqDvPlrVvWOprYsuPX1c6uI1+klr+uFtWty8sA4TJ46YK5nHvGi3zLrizT1P+kpNWaX+a5L/re6yhc3fPzuPUq5CoNfpm8tuA+//sirmyVhvSqtMUuWK8L3OsO+HktZdnkcJXGvopDfdWAuG7HWlXWKivgRSapLwK8FznjXtXz50Fjnba8anCLuXPXqct8Wdepy6sob/6++XH8oiB5Xc35unz+PDa8KkpmkSL5IhPsawnuXVnGNy8DiJflO+fvnV+mv+zZ7TWLTN7rTAjz5bR/d2mpRZ2yvba7Gm+RGbmss75Iu131futQOdc9/yclbTtNJhMODw+JooitrS2SJLkylfS65b+MzNqey/TLKjB6Ff6A+Y1mFilezrkXArhXWc9ufa7z7JcpYxnwrkPBvOo6vbbgvqxjXAUkr4KWueqZqzrevEl2nQmnfecWoC+k0F1i6s2Xe9WAuq7Ta/456/CB1wH7+We/zDe7vtbftmnnnuZoXVUcHR8zOjujyAuKsuDx48dkWcbOzg4bGxskSfJKLMT5tl3296zWV7T5MjP+ZSmh+efMT3KLzs37ypbVvauULLvuT0JexJLq3tsdf4v6xrJEZleNvUXj7qq+9tqCeyvth39Rc/M61y7Siq/S0teVVeDVBfXu3y/aydrnvArA7D7nOpPcfF3a6xcdX3TNi1oR1xfX+ekxxnJ6csbJyTG1MSEHjrMIB6auGdU1o7MRWiuGGxtsbW0xHA6J4/iClfcyIL9K1qXcXlYLfZG+Pf93dzwt3Pzjiue8DmC/TJZZGKt2fZu3prvvty6FdJ3x8dqDu5Ry7bjsFx1Qi0B9nfLW5WJXfbjux3rZ0KllZXfr8qKyzqR33TZs208pBVye1NbpyN13tNbivZ+tTVhfwrL60XjE8eERRVF0T+Fdk9On80xTG46Pjzk9OUVpxXA4ZHd3l+FwOHufRQP3RZSObhnXsX5WafzLtPtlfy961nydVmnlV4HXPJ3xKsH8OhbLq7Rs1jn3Ir6Jde+5EtyFEP8Z8D8Dnnnvv90c2wH+LvAO8AnwF733x825vw78ZcACf817//evU+n5WXBZR72uLKMV2p+visJZVPY68iq17Hlt4bra2jr3rDNxrKvVd/+1dNR1Or21loODgwuAk2UZWZYRx/Hy+vjwHvl0yuHRAdPpBKyfbR1nrGU8GVPkBdYLdBShtUZKgRAS78E5i3WWw8NDjo+PieOYjY0Ndnd3ybIMrV+d/rSOBXSd+xcBxSprav66db5Rq5xdde0i7f9lLONV4+8qRes68qopr1c5qa3T8/5vwP8J+M87x34L+B3v/d8UQvxW8/dvCiG+SdgM+1vAHeAfCCG+5r1fvGytkS7nNg+07bku0K/zcebNphfRzK973auQ64L8VVrhi1g9y36/rlz1Lsu+SZd/XcfhNB6PGY1GbG5uzu7Jpzmj0QitNb1ej42NjUt1q6qKk6MDzs7O8N5C01ecs+R5QVVV9HphgiiKmsrUYQIA4jghjtPQ/pwDUVVVHBwccHR0RBLHbG5tsbW1Ra/Xu/Qt1nm3V3F80XXr0gGLyl2XLuyOu/Y5i8IaV/kW1rFClt3TLXdVOOVVx16kXVcdWyavmnq6Ety99/9ECPHO3OG/APz55ve/Dfwj4Deb43/He18CHwshPgB+BfiXVz1nEa8+DzLraMPdxpzntBaVOy8vqhVddc8XPUGseuZVz34R6+i6ALGsnsuoh+to8VEUEUVR8IR6QRsNLqWalYEXICTgsNZycnLCyfExti7BO4QAvGc6HVOWFVnaY2Nji8OjA3763nsMNze5dfs2vX4P7zx1bZhMJggpSOIEpAQ8QgrwYJ1lanLyac6zJ09Js4zNrU329vZIkuTa7bTutS+jfa4j1/nOixQ14JLzdH7MztdnfuPrdSeX7jO7/WhdgO+e+6IUwatWvr6MvKjNuO+9fwzgvX8shLjZHL8L/G7nugfNsWvJMlNqFQgtoxSu0mznj68DVMvK+yKonWV1WTTxXff5L6qhL/oOy+p61TOWTabtd1xHi/fOI2W41lp/Hv7iBYg234nAO8d4dMrR8SFVWYUFai44UvNiSlEUJEnC9tYWx8dn/O7v/h4//ulPmEwnCCkZDDe4ffs2b99/i/39fbKsBwiMMZiyxHtPHMdorc8tR8AYw3QyCZOBENy9e3dpe6wj8338RbTFF6EArkvPrFvH7mS+SlNfVd9lbbkI0Lt9bB0Loj13FXOw6vnLjl8neKKVdb/dq3aoLmrhhbUQQvw68OsAOzs7Kwtd9WGXAew6ptYi4Onytovu7XbEZXV4lbJO2avy0rxMude557oc6aJ7F32D+cHexk9fAA48WkrK6RRjHHEcI4QI3LkUCDzTySnHx0fk0+n5twSquiSfTpCRZnN7i9HZmH/1z/8FP/rRD5mMJ7NNvJ2znJ2dcHZ2yvs/+xn9wYBb+7d4++23uXXrFmma4gn8/7QoEYDWMVqdAz0CcOsB8Xw/vi4Qv0qAXzX2lo2Xdazr+VDKeaDtAuCLUhbLxvFV1/1JyCJgX3ccrXPNi4L7UyHE7UZrvw08a44/AO53rrsHPFpUgPf+t4HfBnj77bd9c2yldr1IK19S9qV7ls3ci0B+kWa0bBL5IoB9HRplXst4VR1i3ed3f76MWdnSJldZZavih7015GfHjM9OyYuSSGvSLKPfH6LTlMo5TqryAkhYaxtaBYYbQyb5lN/9vd/jj3/wQ85Oz5ACelmCcY6yqs77j/c47xmNThmNRnz40Yf0ej1u3rzJO++8w61btxgMBuDB1JY8zxFCoLUmjuMAWq6hbxqZ9yctaotutsV1Lct1ZBXAfxHaZPf6q47Nf/eXkXUmui9CXqRdXkZR6sqLgvt/BfwnwN9sfv6XneP/hRDibxEcql8Ffn+dApeZPV0AWXdl4Dz4XbexlgH7fL3WtSbWfVb3me25RR1+ZvIvmJyuW5/rUktd4FknCmId8T5QJ1rrhZpqV4u73Dc8k/EJxfQE72qwFbWtqMspk7NTNnf3UFojZKDcnXVMJhO89wyGfYqy5Hvf/yO+/0ff5/j4BIVgazjg61//Ob767leYTiY8e/6cBw8ecnB4yCTPsQ6CveBw1jEenzEan82A/tbNm7zz9jvcunOXfq+PQFLXNZPJhE8++YS8yPnq1752gU6bB3TRpASz1mKMwfvgxBVCYJvQzFelba6iT9a5dxmdsUyrv06d5leIv2p+et36veh7tPfCcmpq/vw6+PFKaBkhxP+D4Dy9IYR4APynBFD/e0KIvwx8BvxHzQN/JIT4e8CPAQP8VX9FpMyyCi8y0a/z8os63VWmYxc453+u0t5fpSwc6Eu0nFeprbdylfU0TwGtW491nrsKDBYdD9eD9xaPRQiLkE0/8YDwM57QOst0OsVaS5pmeOf40Y9+xB987w9DGKWA4XDIt37uXb75tXcZDAZ474mVYHMw4N133qEoCp4fHvLw8VOePn3G6fgM6xwOj0DgkEwnEz7++CM++eQT0jRj7+ZN3rr3Nnfv3mM4HAKgtJ7FwnffpSt1VVAUBXmeE0URpycjkjRld+8GURSt3MTiZeRFgH7Z+Jo/tq72vAgHulTOvGLzRTkku/Iymv86tFt77DpW1FV1Wida5j9ecurfX3L93wD+xlXlXvFM4HKDdc33ZXlTVsm6puC8mdxqll+0vAqgfFmr4br3rqudXTUxrwrZXDQQrrLGPOG7GWOYnI0w3tDv99Ba88EHH/CH3/s+z549x1nD1nDAu197l2998+tsDDOkcAgE1gqkVCAF1hmyfspbvbvcv3uXqq45Oj7h8dMnPHr8iJOzEZV1Yb2rDzHweZ7z2Wef89lnn5MmKXt7N/nSO1/irbffnr3DfLs55zg9PcFU5QXFQilNXRvGozFxHJOkydphri8qq8C2Ky9D3yyjRhc9o3tdt4z5ld3Lnjt/38u8y+V72789527G9l1bH4/A+/a7N/e482v8hXvb+rRltpNct9+sHr+v/QrVeWk52nYWX/TBV2m8y2QRqM+ff5Va0jKrYZXWvAzQrmPRLHv+Klnk61jGDc+XPz9JrvOseUtplebT/DX72V6rlWY0mvAvfvcPePDwIds3tvnqV7/K7u4Ojx49xGPZ2Ojx7jtv8e1vfZPBcBAGn5CMxmOKomB3ZwcDPHz8GK01N/f2kICQlkhG3Lp1k1u3bvIL3/o6p2cjnjw/4NGjJxwcjZgWxYXBKiRkWcqNGzfwhIRkaZpe6r/GmIaGuaiZllWOMYazsxOKoqQ36LO1tbU0x82rlHWUpnUm+RcZl/PPWFSnRVr9OnXoRjUB1HUNrLY22vu7E0lLneE9SmtCOG4Q1wC5EM29Hpy3oa819B7egQBBO0lZ6IB4i0tdn5Ex5t+8bfaWmR/z5uL8i79sx1mWv2ZVZ1kEtlcD0UUgX0QdLdJiVr3XKnC9iorqHl/2nldpVfPvAlz4Lu0559xSC6g7YS9yngaqxTdcdGPFSUkYBQ28C4FAURQlP33vR/z4xz9jnOckacpb/R43drZ58OABn3z0KXdu3+Q7/86vcePGdhhoaE7PRhyfnvLez37G3vYON7Z38N5zcHSEdZ6nz044PjrhG19/lySO2djoI4VA49jZ3mJne4tvfPUrjKcFT58/59Hjp4ynBfffeod3vvxlNoabSCF59PAhz54+5e133mF/f/980Lsw6EXTjHVVUZZhMZW1AXicD6GXo9Mzzk5PUVozHAzZ2g5A312R25Vu/143+mTV5HrVPa1ch4pZpsAsAttF/XUppTRfBQFKqUt7qc5TPO3YX9Re1oZFb1IqnLPUdY0xNSCI4whrLdbWSCnJ8wJjDFrHSKGw3lBXNXVdhdXPtkYIQRQleB8mmbIsm3QabuaLGo1GTfkxR0dHV7IJrx24L5XWDBHdQ4Eu6QLgOmA/f24Z4HUnkUUTzLo0z/w93fpdtan1VceuklVg/iLlz2vUV00K89/mOlkrLw9kh7OW0WjEs2fPEFIz3NigqksQIJF89NGn/MH3/pDTsxFxHPOtb3+Nd9/9CofPj/js00958vQ5N3a2+dbXv8budgDbUV5ydHzMxx99QlHkfPObX2ezv4FAIIUIi5d6PZ4/PcVZzUeffsrz58/5+s99lW/+3DcwrrqQT31j0GNj8DbvvvMWVmh0MkDI6PxbezC1wVkbQEZI8A7jPaaumU6mVMUEa02nDVx7K+Bn5n1dVhyVhxwfHxHFMZubm2xubjIcDsPCrk7btxLWA1xNM7Zjqc3Zs0qW9YPr9qlV/amraK17zazcznkQDfieO6attRdCE51zVJ0oKWMMVVVRFAWj0QhnbUPdhair6XQ6u14IQVEUlOWUOI4Zj8c452apKIwxs2e3VLNS7YK7FiMUUp5r/O17aR2TJBctvmXyeoF7872EnKv4jMK6yDPNf+CuNr8sWVHXhFukcS4qs/v7Op2wPd/9OX/vdTXxVbKKqnmV0nb6rjNwHoCXTnrNNZHWGGupyhKl9UL/xrJnTycTDg8OKIqc6TSnrGqOj4+JRI0mmMB7ezv88i99h9HZiDv37jKa5vzTf/q7TCZT/uyf/VX+x//DP0+SSpSQSEAJwaPHTzgbTbh37y7eCXZ3t1HIttJEOiHSKUlSc+PGFlFyg/v37uC8RSoxSxN86Z2FJIkjhJTU1uAsICRSBq3x5PiErNdj0O8zHY85Pj5qgMAiG0pHiNCexgYAqo2jKmtME13UAob3UJUlz58/4+D5c5I0ZXNzc0bdzOdpuqr/voi8iKbf3neVxb5sjC5SMLrg7n1ICmdq0wBueYF+qeqa8WhEWYZQ2TzPQ+I4ITg9O8V7TxRF1HVNVVVAWBEthSSOIpIkIY7jWWbQ9u8woYJunOfzlmw74V483rahRAjZ/N0NJJHAxUSK/+3/b3nqrtcG3F+EMVwGavNm/SJAnl8Is6iDreL4lj1/Wd2W0S5XvU8XNNd99vz5+ffwPuRVMcYQRdEsi+Iimmi+zFV1n6+bc47j42O898Q6Io5jnHM8ffqUg8NDdKQZDof0+336/T5xHC/M6FiWJQcHB4zPTnDONEfdzHclRKBrhIDhxoDhsI+1lsOjIzY3BvzSL36Lm3s3uHv3LkIojJ0iZ11E8Pb9t7HOcHpcMBoXVHVFP8sCtnuQUjcD6zylQb/fx1iDFAGGL1MJ4BHY2qCoiKQGpXBe4WxISvb82QGHh4dsDAco0eHnvQcZ+rExNc55pNQoqbEYcJYk0lhnKYpqpvlprcEHda/IQ7TN8+fPSdOUL3/5yxfy66xrcb2IXHXvKg1/UV+dv65rTcO5Vt1q25PJhKIoePr06YwKnI7DMSHO1xy0k2M7BqSUbG1tkaYpw83gy9CNAtL9p5RCAEqqtd93fvJZvAetw3s3A/E2DfX5ZAXdjRb/zdHcxTnlcqnS1+xnbeMt2kWpLX9ey1wG5POyKAXxsnsXTRar8j0ve5f5v6818DyIi1wWdVXx+YMHHB4eorUmyzL6vT69fo8sy0jiBKUXp82d900s4iWllDjvefjgAZPJhN3dXaZ1zcHB84Y/thhTU1Ylk0lIxKWUIo5j+r0+g+GAQb9PEsecnZ1xcnIanEzOgfPUdU1dVHgXHKDn79iERgJSSfb29vAIdna36WUZnkabQiOkxtkaITxpklKZCq09cSQZjwr6aY9WeZe0nKxGCY2xAfClcyztnE13boFfCEdVlgTNK0aJEHvvCAAuIwU+LJByzuGNxeOJdERdG549fcaHH33Ep598RlmV3L1zl3v377G3v08cx1hrm1TFAq1jlFYzB+N0OqUsy1CtrrIw61pNn+polN3v+8qktcznbJ32t0V93drAZ4eJzjAejzk6OiLPc5xz1HXNeDyeKSotGGdZxubmJv1+n16WkaYhAVwUBUBvVw7Tjn/ncL7x6whBFEcgxOy5l6zKpv1EB7fat5u9VedyIVpwDiKlwM1WK7chvYujgTo96VL7rJLXB9z54nnmrqwCyWXnlqUgXkcTXxeU1zVt1wZ5wcxBB1CWFY8fP6DIJ9gmMqMsCk6OjoEAslEckWYZg8GALMvo9XokSUIURQstknltvwX7uuGUTVWT5xOqKgBMXVdYa0Ccg4izljIvKKY5R4eHYYDGujFxmU1KeE+kNZUMPDXOAB6hFIKLGp1vB4SQGC+RIkKj8N5irEdgg8YvMwLHmRBFisnkFLtt8VKBcEgswkMSZ1irEFaFZ8rWaljyjYQHoahsjbA+TE7W4SjxQiKVQkYJ3hsqEzRMKSVaa6yBw8MDPv74Ez766COOjg7D5iHNO53+bMRP3n+P/mDA7Vu3eeutt7h96xZJkmKtoyoLpASlNFJG4C7SglJKvAPvHR5LWVUoHV9yyK6iytaRC32jwajmc15QDKxzFGXB2dkZo9GIPM9noF2W5az/tRbKxsYG/X6fNE1nWni7Ycqq+s6UM9/2j6YOvtGkRVAMEOdO1lU+Cu99uJYWeucmgJk4Wq07LP0Jd/jG8pw9HNmcs83vonPuevLagPu8KXhtDZXVgDsPyutqzO11y/K3vIz5ukpeVbndUsqy5OnTp+R5McuxIoS4AP4BZC1FUXJ6chKcikoSx3HghwcDelmPfr9H3OwnKoRACnk+QCBoQN7jrePs9BSPwzsXFuYUBcZaEMGsnZXRrXijtSHAmDqsYFWBKzcmx9RjrAWpNEIqlFLYeWftTFOU9PoD8qIiShTOGLxwswgbgLLIESJBiBitU8raEMcSIQVSK4TQaC2wzuG9wBrbVn+5eHj0+BFSx2xtbZJECqH0LL+MMwYnJdJo0iRFKMHh0RGffPIJH33wAScnJwwHA+7fv8c7d/d59Pgxh0fHVHWN9R6HYDRqVsd+8EFYHXvrNm+99Q77+3tkWdxQFTnvf/A+XsD+/v5MG3UmRGN4Z8mnU/LqlBs3boQ8OXMW2XX64zL+3DlHXVZUVcV0OuXk5ITj42PKMsT0IwNlsrm5yc2bN7l///4MvLvUYfcZy+jUZVRmy4F3Lc3ufq/zlgssc0B3rI/ZRLGwMWgnECHaq1ZNlnNWje/Wv33WVWUEeW3Avcu1zjtErpJux5unDV4WJNvnt1rVi0w68/VYRhO9aHmrxANSBO/9kydPmkEVeHBnL0+is0HU3OzxWGPJbU6RFxwfHs2ui+KYLE3p9/tkDaXTalFlMcXWZaA+PNRVSVHkRHGMrUqKoibp9dGRbupisc5fmESV1uRlTiQVWiuECSGBztV4W+MNWGPwKsE5cam/CCFRUYKKYoRKSNII6Wqc9LMFJc4JnDBUZYXUfZJMoeIdDo+e0u/vUlvD0dERg0FElAxQSmIij2cEqAvWx6Vv5OHBo895djAh6/Uoy5xf/qVfYXdrk1h7rKmQOGxd8pMPP+CnP/kph8eH9LKMt+/f4dd+9bvs7uwQRzHT6ZRvfO1dJtMJzw8O+fzRY54fHjLJC6x3OB/y2n/wwYd89NEnZFnK3t5Ok9jsLkkDki3VUZUlyjs8geOVKHCBv2+BblVk0yJrrf3ZTh5lWc4iSUajEVVVUVc1kdb0+30GgwFf+cpXZpahlPKC1rzOc+d/X/otxLkDc167b62llspdRJ1qrWf0TFOT2djx+MYaWVBnAd558CIkKQWQwWLCq0a3aAF9nnrxM19P8+fFgq+Q1wbc50O14JxzuyoqpTvbruPkfFHa5jJ4XJ1OuFtHuOzI/cLFQ1lVPH36hOl0wvHxCXEc8dlnnyGkZtAfzAaWECIsumi3q5MS3wB9l1sUogkly3OKPOf45Biab5AkCWmaIkUAbG8d0+kUgUcqxff/8A/5oz/6AVVtGWxusrExYGdnl5t7+9y4sYtSetbOSirSSOOtwZYVwlVIARKP8Mxi3qXoOoNDPaMopjcY0h/sYr3HOAcWLApUgnAOTw0i8NxRlFFZR1EGHl2IBOc1xnqOT04ZDO9RljWmtggc1lUkabTcKUkzXL2nqmqQBU+fHjCa1PQSyLYinClxtcHUNf1ewrtfeYtf3vh59m7skCYSIRSeYB4ooUBLNoYRG8NNvvSlt8mLnMOjMx4+eszTZweMxhOsceAs08mET6dnPHz4iL29ff7df/ffo9frhe/oG4O/+aSimcmFvOysbL93+/MC7dUAeVmW5Hketh08PQvx+iLEY2dZRr/fn1kEcRNp0p0ULvPLyxWe9vgyK7/7+6qggO6/1hc2v0F9t/wWh86fE9rMdwC5+9x2kgx7CZyXE/qEa3vHBX9Yl5cPZQkuN835Wo+r5LUB92Ua8Tpe/atA+0W47kX3dB21M0pDiIV1XOR0nC9rXXnZyaCuDePx2WwbuH/+L/4Z7/3sPQRBO+73B2xsDNna2mZza4fN4YBhluFljBBR0DxoN72QYZs52fleDY/qGiDPp1M2B32sMZR1TRRHfP7gc37v936Pp0+ehsGE4PjwKccHjzh43Cf+9rfZ30mwReAd4yRFiR6Hz56ytbEV2luKoKE3PJJoQgXBgXAIKVBxQraxzcbmLnGcAIJ8miOlJ5ZBm3a+h3MWU42RPmc8qajqCIREiArpBXs7+2hhSaKYL7/9LmnWZzwusT6Af5ELjo6fsb+3z7wpPS/GVigLWguUiEDGeOkQwgcqSSo2N7e4dWsf3UymxlmKoqasxmxubeKASe2J4z4CixI1/X5ELx1y79ZtaltzenbC08dPefzkOU5obt25y52797hxY59f+ZV/myRNg9MOCdZifE1Z5ownZ5yejEj722xtb1/yrXTB3BjDaDRiMplwdnY2i0AJzssBt2/dJUkSlL6sWXvf+ic68HQ+u1ySeeVp2dhcR4vvWuDtdd0yZ1q4P187053MhBCzdnHOYbEg5Gxi6G6n2F4zK7PRW6VvraG2FUTzewv2gX8/h4a2fy9+l6vktQH3boO2cpXGPi/LPv46VMq6DdYCPFy0MNap+7r0y4tSP4tECEFdV5yenhBFmn/8T/4xH3z4/mygGWuoyoKT4wNcXVJOT/l4PMU7UFFClg24ceMGG5sb9Hp90iQjAL1FCGaLLpRstAwhkEoxnUzRSlIWOf/kn/5jPvjgQ6q6ptVWpIBYK77y7pf5xV/4ebY2tqjrkqoswmRhoKoSnHXUtuLsbMqPfvzH7O/f4qvv3g+G8KyJAsDHScbm3k2itNecE8EcblaxAo1prJCqMb9t6xRzaB3Ri1N6mUIrQ10VYC2bwxgd1WRRRG0j8rImirfgtAgO4ys0qaC9V2itkFIhZsvTPUWR44Via2uLYloSRwmPnz7l6PiUu/duoVXIU+MReCkxVpFPDM5NSFLJVr+PqQriSLG3u8Pezg5f/8Y38TImSjOUilFSMx6P0UmEVoqzo2ccP3vItMxx3qG0wjnBNA8blrScdMs1B438FGMMQgiSJKHX6/HWW2+RZdnFJGi+dQi2/5ipo7PPdaFrC+Z7ehdw2z68THmaV8ra31eNtflVqMue2Tpv27UdXeu7PW7bhWgdyqe1bOE8pUGr4M9bCLCITrzYSKsUx1Xy2oA7rKY9urJqdl5ktq17/rrSDoB167nuBPIqfQZFkfP+h+/hvOcf/oPf4dNPPw3agD93AcVa8fPf/Ca/8PPfoqpKnPfUJjhVx5MJo9Exjx58QlXVCKVJkoStrSG3bt1mMBzw5NFjsjSm3+8TJSlJkpImKT/58Y/5V3/4Pc7GowCwzRZ0Wijeunub7/7iN7l96yZKBs03JNENDtDKWDbiiGjvBu+/9z4PP3/Cs2cnbG7tBIRuALtNEOZ92Ng6jvu0EQe+BXYkCINvgUeAd6JpA8kwjXAxpBEIYcBP8S5EyUjvcXXVTEwCKQWDRDDsaXa37yN82OVpoeY+w/BAzWgdB9oJEUDQS85Ox/Q3dsIydjul8JAXBWWVk6VxMOEbyksLUEKjhEFFMkyQcYypc4L2BwiJVgqdJlgJxlU4Z/nZ++8RfxpWsNbjI0wxob+1y3DzFjqOiWINUlBVFZ9//jmffPIJdV1z+/ZtbtwIawQuATnzY1RAs+ZA+kBJ+A6dF+TqZGeLxmgXzOcXKbaTzjxltEiWXdN1qM6Pufad58ucX4Q0H3p9oZxAygcqTIRoq3N65mpMexF5fcDd+4XmWfcjLuPpFtEy5yYgcAVPFw50HnqNtpzX4q8j57SG7x68fL4r16inaLRo7x3/4Hd+hyePHoeO2LjcPZ5eL+NX/61f5ue++m44ZgAJkbZkScL25jBojj4sjS6rmsl4HHKYHz3F5GccP3/Kp6Ow96jSmjTNGA6GmKri3u19jNnldDxiWkzppxnf/fnv8KW37xPFIZxRembOpqC0hI4vpAAhGU8KvBAM+hs081KjCYkL/KOY/fQ4D7auyCfHjCfTJqImhPqJxpfghcF6RxpJrHE4XwY+n7bvnIeizfqba6YgGxyzUzOZwdWiSf7G7i7jqeHZ8+eBrpB69p4eyPMCGZXBnpGSKE4Q7QVSIIVCqsZx20ZbCEmsI+RsJVZHayWY9hKLNWGRlZQCnKfMHc/LklRWDNKM/nCPs/GUo6PPePrsCZ8/fMDDhw958uQJRVHwjW98g7/yV/4Ku7u7szZYqMQs7JzBF9Isw1nVTdeW1rHZBdsrtfwLHPZlDb/7+yJ8WWSVz+eaaf1o3YiabnqDzhs0dWl/v+x/W6Slz9dt0XWL5PUBdwKfKxYsEOrOirAmvdFRJv51ybVm3daC5dVRMt77EP+rE9669xapjjg9PaXMC6qyZHOzx6/92V/l7p17WOuwzoOSHJ2NEd4S6QghRVj4kWiEh16U0stSbu5tU5YFaRZi4Z0x1HWNdY6yrBiPxlhTsr+3w1tvhfJNbRhuDEmzLIToGUcSNSvxfMsvBmQTBH5cEvKwjM7OODua8s5bew3uCVpfVTtYPB7clKooKcuCPJ9wenrEs6fP6Q2GYYFWkqBUSCmglUAKh3NlM+k1H0KA9yqAuFQIVIjOCYHh0PgbZOe7te3dFQF87ctf4qtf+SrjyYS8qBn0IiLpkS5MItZ6jk/OuH/vNhKBEgotFLjAjbetIfEoKXA+LNwSWiNVoxnPnsa5o9l5vK1w3uG8QgiJjHoIL/HOU5QFv//f/Tf8q+99n6PjY6wxCKVI0oTbd27z5S9/me/+4i+FSKeyCkvupcCLBfnTBeBbLrmhLkSzAgzTNk7bSqwzKBeNgXnN+Epf1gqI6HLp88daacG5S7m0TtJLWz3OUUHdsoIT2zdWZvtureOeS2Ws0xbrYOBrA+6tJrOMu15mpr2U+IszwBLj+mI9VzX+/M2i+4y5E0vOreX87T5qWYWbYqQQ/OJ3vsv9e3d58NmHGFPhjGM6mRJrwWDQD+yoFGgpqeuS2hhwhqquqU2NiiKGGxvkecHGoE+kBN4SImOyNIChrcPqykZj2d3eJssyNjYHFMUU8IH/jTSVsTjrSdIYIezMXL1suflZDL4QIYkXDXi1yk/75QL/bzg9ekLZhH3++Ec/46NPHlBVJft39vjOd75DomMePnzIzZs3uH/vNv0sCSDuZVOHiMpYTG2IIgVSUhtJmm7hrANp8eQ4Y85THa3gRL1zIAyDLGWQJShRIYXDmAAcWkc8PziZfbS2GYSQDWb6mVXbAr334BAzzfj8c59TIEVeg1Io1SzY8Q7R7ByFCn6jmztDfvk736AsCnQUk/X6bO3s0N/YAKUo8pz333+fKIoYDods72wz3NiYJSRr3zXUyZ1Hjszev8O5v+RwbTnwLv3SguxK31xbiwWXLLNE2nOtdMF8XttfZgkseAG6K3PbJrquL/CCc/qKe18bcAdmb7ws+uV6ESbtTTTa1sWyRHvuFXQ6Mftwc7K0up0Ht/V6QafJ4kpd/FMC0/Ep49Ex1gZQipRk0O+jAJWkSOdwdeCPnWUGKM6BagDF1AZTu8DPNhrZLKpACHq9TZy3IaGWV2SJbnZGEjO6oKgqhIxIkhgvaNyr553+4icRs8/nHKhIMxj0wlHhLlztvceZmg8+ep8/+sFPePDkCVpp3r5/h3ff/QpJEuERfPzhR0ynU27t30BrhRceT4wTnrr2lEWFF5ZIaXSwo6hMhXMDytIjZIyKPEIURFoTRwpbTFj+scWMRwrzgMFg8I3fwCMYT6YhhpqwqEg1i8ZCHhs3syqEVCih0doxH/58rr+H73E6rqlcyc7ONlmaUORn2DpHKx16hHDs722xv7cNQFmUVLXn8Cj0kcHGJjIKJFVVVRwcHHBweEicxHzlK19he3v7/PneI5sVXZfXcYZY7vPuvZ7W3mrpy1JxLwL2RZbT0mdw0bm5jiyigLrU6vnjfWsAXn6qmKmxzPeZVY7j7nPnjy+T1wLcgxa22hxZNYPNX3tBGq3hgtZ/4fzCRy+uZ2fSuWRFtBrmekVduu6i8+V6wH5Z3+3W6zwmXHgQToB3eGEbflnMlE/RDFDXaHpSiMbF6QGHd+3y93ORQqKkwlmDlBGHxyNirdjb3Ua4Eu8tAolWMdZZnANjqrCgRjQaCBcHTbcNBBBFknv3bvPOW++wt5uBr5g5EDtinac/2ODb3/4GX/val9ne3qasSn723gdMJjnf/aVf4s/92p8hinTgLwi8flEYKlujZVgMlfVCCCXCNRYDwSmApKocwlk8JYKK/Zt72GK8kJu9+DVmOlvni4WVvd638czBR5KmKVkVcqp4Z3FphvMeax2IkJpWConWwUF83lJNPUXYyk97gxcCqaLm+zviSDUUysVa+cbX8Oknn/Dhp5/RH27wpS+/y9tffrezwEhRliXGmAvrSpxzs+8lFyhgvrXMOn9fpah1AX4V/TH/e/eaZSAbmlrMAL69p/tzFe2xDGtm+uRKpW6xdLn1lVTTNWSdPVTvA/85cIswon7be/9/FELsAH8XeAf4BPiL3vvj5p6/DvxlwkT+17z3y/NScv7KnpC2VaygYK5Nz8hznfoifXKO6utSMedaOlzoMtdo+0v1fXmL9QLvPPv/OX4EXxyhXWcxtU3nF7igHePRKpqVE75DmAjwwUHp8XjhmoDdoCU6B9aeHxfCYZzFCYEiaOtCuFmHF0jqqgomvJcNLdNpn9az6j3SC4Qw/NJ3vtbkQvFIDK6BouBdbe8MZfV7Gf1eBt4ynkzYGPb5pX/rF9jc2mTQ38JbhzM17fITiUAnMRgJPkbKGiGbyU42hTdhnr4x90I+mnbvgIuffz5qA0BJjXNtJpOm3ZsskEIyY9Y9AudqJvmEPJ8G8BES2fQRJaOQVdKVBDrYk+nud2/7c8gH7pvvgw/bBma9Pvl0QpbGdDte60L2wvHVr32F2/fu8Mc//DEPPv+cXn/IjZs3SbO06QqeZ8+esbW1Rb/fv/S+3f0V4BzI5zXsRXTKbHwtnCQvtu+V4Ot906ahnbtfqVVmzlvufFw637qArzsqz/vt+STj5vS0i9p9t12u41NcZ3KE9TR3A/zvvfffE0IMgT8QQvx3wP8G+B3v/d8UQvwW8FvAbwohvgn8JeBbwB3gHwghvuZXbJTtnKWsSqSKQzIl2na6PEu/Eq79AvpdceklYL8E7WuXcdWx68gMVDrz1TIezwkXsioG8rXzHp7zCAyPIIBVmvaojES4Gq9MY0R2dfZzCsULTZINqesILzR5XqNjhSOE6knvwAeuV4hgK9g2ttxDN7GN7HINMzXIEEmL9+Z8+TYt0LYOqW5jtEvCJYPBACFC/hmlelga8FYWicQ1m2wIqZDS45wMESrS4b087yYy+BiC8uHQQqCiAJ7I1RYmCKI4xUtFVRSBg2+nFuHZ3hnyVnUr0Cwu5OcZbgzJ0ozN4SCs9HUW7yyxdnhRI4cgVITzbvZVZtZjW2mpsHWzSKpJjyyVatqqO5s2YAFEccRwY8D+rdtoHfHxZ5/zox99n+n3anZ297h16xb7+/uzBTuLNOv5HZ9aEJ8HpJYS6Spr84ETi6JE5u9v71sF9N5fBPf2s85/J+/Pp4NFk8w6O1hdtB6Wa+DzlsKiFOTn5Vw/PQmst0H2Y+Bx8/tICPET4C7wF4A/31z2t4F/BPxmc/zveO9L4GMhxAfArwD/ctkzptMpH3/8Mds7e6RZjziKieOIuN1JZvY/ln7sL0K6WoKUnef6czfWRRw9N7lnZmFXYxBdk/xlKnaxfudlX5wAhRBYa3j+/FmzRdflclrAdNbjpcc7jzUCW4PWHh3pJlVq+B5KqxnY9wbbDDbblAEB+L7y7oCyqojiBOnA2xgnKjzVTD8NWouY7SXZgvLFql0GzNkR34K57x7t9Ak/O+ebKA6lezx+fMDdW9soKXFehMEnQMzyjTROWyEuLDQKc2JwFjvnUJEm3RhSFdWFerZ16Fp4zmvK2gMmgHGDraKZkIbDPhvDTbwpiJWkl8b00p1wka/POWFvseUZXoxRQoBT6GbT7IuTeWhLKQW1sVR1hRBp8x7tlN5pt9mkGKw1qRRRknDz9j7bN28wmUz5R//knzOZTBiNRrOEXq3WfqlLzYFSdwxdah9xMfJm0SQ5X0573dqOTC5ateH6lZeHPtBq4p1+GRbqhVS97fqDeWmvDt9ZND8vg/yyd23f77zul/vXouOL5FqcuxDiHeC7wO8B+w3w471/LIS42Vx2F/jdzm0PmmPzZf068OsA/X6P4+MjrJMMhyZk+LOWSGu2NjfpD3oodf2EYOvwZyveda4saLc6w7vZ7H4RrOedP775uMvzyXTLWKuGrYLWAfDZ0+c0Ke89k/GE3//930eYnK1hr1Oz839BM3RIfQ5VxtZU1Ri8DQt4pKYsK4yxREohpGS4sUMcBz7Y4RFekvYUSRZWseJjnPUwHoMJu9hIFXjiujJoHXFB+770rjMuZIFc7ORaa4w93ybN+wBwreNSCYmpSoTwWBsW9jCjjkTY/csKQqIm15lAz62k2dQhBZVwOLFwfHc+lWQyqamdxuJwTNjZ2UIJhzAW32zVhg/5aoR0eFc22mOTVli0oNzy1k38p7U4W80/EBotvNdXxL0t8BLv2kiWVU3pMDZkvJwUBSdnp3gvuXnzFn/1r/41bt2+w2A4nG0qvYzrvlCs7yTXWuCTCN9o8Z4Lq8C7q/EvosG8byevVSNq0boU33z/Fcv+/Zzl00pHF5gdmusbqzFgfZxa1+pfG9yFEAPg/wX877z3ZysesOjEpRp7738b+G2Amzf3/Pb2Fl4YxpPnJPEQpWKqquLx4yf0eimbWxv0er0L+0Ium9UW/S4aSuJiNS8C8bmp347o+XAjefENhbjwc6mpd+lEOyguXrvgkoWnV2lM8+cm0ykHB0fc2dvoHPXzUxKRDjQFeG7s9HAuoq4z6qrCurCTUinlLGlX0GzEHGh0ILC5Rsx48dDetjYU0ykbgz5adgfgubYU2r8pRoBQcbNZR1t3f2HoCkGIAmrAbVaelyEaRkiQkiQNYZtShOgevMETnzfu7PO2S83DwiKtFQ6FUjV1bTkdnVKMJvSzjJ3BYFbv9tkt8DjvCAuyBEVZUpsRg36Ct46Nfo/atlq3DNu2pQlOOCSmqZMGPFLJQCUp1VhINuSxnzV384uAluZyZoIQDkFMWdR43yS/WgR4AtroIyEjhIipastkMuXtdzb4ylfeJU7TS/1rvq+1OZfOrd3F+x8AF/YsnT+/iI5tj59P3PISqF96p1lXFJfH06JbZkrGvFbtZ7N86zu5jrR9yV+yNi/ikW/Aoq3vIq3/OszFWuAuhIgIwP5/997/v5vDT4UQtxut/TbwrDn+ALjfuf0e8GhV+c45njx5Ql7m6BgindDvD+ln2wgvOTk54tHjh2xsbLCxsTFz5rRaxCJpG3LWCN42MdiGqqoxxs5M2hAJED5er5cRx0nIkOcuduRZZ1uyvZb38xDdTkDNwGkGcqMvt3fNrl0kovvbmppAW09jDAcHB+zv7yN9wXwPb6ckJR3eOkydY10NVAjvSbQkjdJwl/T0bm4jhAwLXgRYU1BWE4o8xyHQUYRSEUpqlIrC/qIiOG3bR6dpzK39XYaDLGiozs1A6dwXIDrd30MdLJ9JXhEnGinOh2AbiSGkANNpE6mQKqY36COEBqXJBkM8GoiQOJxQDSyKJqpEorTE+wCCEtFQMQIvLDoB6Q1VNUVpSVEVVM6GjTea9+gCkvMO33iQlIpAxEghMc4hhUZKOBuN8F6xubXJtDJkWUplPZNpETR259jc3MR6SW4kSvWCY9lPiCKFxGKqkg6Sce5REUA9GwvdDIUX+kH4wHgcW1s3iNINrBSMzs6CL2CBInWpjDlacJ5L7/bNRVTLVWV2uWnfRuf4DvjOUXTNjefvN2dRB2xg7p4WgNtnt9c1ZQvJpRDcy09d9jaddmnb4eLz/YV2IjAE7txVuSrVySJZJ1pGAP9X4Cfe+7/VOfVfAf8J8Debn/9l5/h/IYT4WwSH6leB31/1DKU0Ozv71MY3OcEjjC2pioI8L7DWkqYZZVny4MEDnj59ymCQMRxusLOzTb83QClN+3G899iqpqxLimLK6ekJ5XRCnucYUxNFEVVZUZRlsxtR2BSisjVJknDz5k32b+5zY3ePOEmgAYF1zaFO47W/AC21A7NOc37h4tsv/BK60TITt5Wu1qOUIs9zfvLjn/AL3/xyp8SL95k6p/HvderVtiUIIdEixCtbZxDeIhFMR4ccHp7w4YcfgZD0+wN6/R5pmpFkKUmakMQRztQzAE9TRSYUYJrJ8HJY3sWfkrOi4sP3P+f09Jhf/dVfQOr5VczNtVKgopQ4zegNNkjSPipJyPMCbwU7Owk4i1MaXA9ZTxGY2UC21jR5+13jYzkf3M5bZCKROLAepYJzOHcVSaLxRX1hKcU5kIZwUykkXqjZgBZCILzk6PAMEfXYuZFSF2dMneO0zDk6POCtO7dnNFariToL07FBRwXGwUavR+3PQw3PwaaxPLu9bEXu+XBtSJWcZT3S/n32bwZH7kX6cbEmOZ8md34T9auiP+b/7tItrYY/mxg8Lfo101jr6JTtm18sb/FTu28xO3JhIqK14EWzBd85vVVUOR5J2u5cdV11foEEw6F5b0Fw7S2hvuZ5+0Wyjub+a8D/GvhjIcT3m2P/BwKo/z0hxF8GPgP+o+ahPxJC/D3gx4RIm7+6KlIGwLkaa8/wPqKuoa4mICBLewyHm4xHE05OTplMpkynE5QSHB6GjWqjKGJjsMnN3ZtIKTk+PWU8GjEen4YBKkUAdCVnKTuLImc6GTPNp0wmAfTDruUJppfxs6MD3v/JT7h96xabWzsMNje5d+8+cdqbfYBFXN/yKbw1Cy9HnMxftvj38Ed3hd68LHOs/tu//Mv84s//Ag8/fY+Hn30897zW4SPwQuEwSK2xLsH6GkFY8n7v/tts7+xhraUsC4p8ymQy4uGjh0RpzP0vvUVdht11Dg+fUxtDXQdguHNrj7t3bod6NxqLvEBnnWucvgWx5n18E8FjHJyMzhBehqyKC/lQ0HHCzZ1b6DQmxOxLHB7nG3pAhNlVEhYHYatg0c0iOhpAFAEIhQ+gHGmFA0zD4RtnsLVFSCjqnFhEs3qffx/RWCPtcYmzYI0L8eoEesgYT1mHfPeIsFnF4MYWMtEgdcO1eyRNaKgXCO/RSqNEh7NuG6GZOHr9Ifk0D7y8bDb2dotpGd/5pcVN0fiP2rBTwUUKrusU7QJ8ty/C5QiTLrXS3QGpq9F3MzC27dmGWEopZztZBVBvLL2ZAnTeH9q/531j59p5l8W7nAog/BLCSoX3szBJ52p++NM/wscJP/+Vr5NGgdoTl3j8Tv+eb/OFY/jiO4RqX2zbbltdJetEy/wzlsPWv7/knr8B/I0rn96IsVOOjn+IVBlZ0iNOeoBkNNYoHaNEytZmgtYxbmuT6TRkKjw7OcGYmtPeMc8fP6Eocqyp0ZGmqkuss/SHG8FBWzu8t9gm57izBiUlSRSRxTGnZ2dMx1POTk/wzeDJp1Ok+oRev8+TRw95+0tfYWd3l6zXR0kNsnVWLdI+ml8Es0HHXAc8v+CccpltmuFCfHmribVpReF6s7iUkiRNmpWJCzqEB2MVp2cjoijGS83TZwUff/YeUtbcvLHH4cmUw6N/ibE1Wifc2N3l5q1b3Lr/NZJIMRmPqYsJxlSYugq0DR6tBINBSlXWOGsRPoBjVTvOTkdY59jf356DjXkRKNWEvV0IF7usn0kpiePeQvKpfdcLdzQ0kGjIE6UVUSKIk3C+riq8NcQKpBbkwoOwYds3rbHOcnY6ItvaItU68OBhQcBMe56FKgJVVVNWIf3DTCOTkmpah0y5AipnGU8rdKQJs2HQHoWUs3j7AGYSKdt+1YJIq4F68rwMNtHMQQh1WV7YlXO+nfEwHY9xPvD/SkXQpC24cOUS3r3bH+f/da+ZB/ZuWd1Mq90yL0wkHforzESXe885fz578tzvHeKvU1T7TNFBfucsRVWSphl4z5PDZzw/O8BHikcHm3zp9ttoGcJMxUxhai2OTr6ZpmNYa5kWU3ppr0NANvVqJ572PTpj/jqRMvCarFD1TpHnIc9IXRWoUYhq8ILAT/oEZxRVaXFWhBzJws2oh2I6ZlQdU1UVGxsDpFSkaUySJIxGYzyQxjGls0yn07AJsIe6KBHeU5uaQa/PGdNZzu3pdMro4ACAmzdv8uzJY8ajMzY2NxlubLK1tcPO7h79/iAslLrU4F2NvjODz8B+dpIZFHQ6cJtTW3SOt9fARdN11Ye31nJ09JzxZDJXv3PzLy8NRTklTlIcFqVipISimDKZjHn8+BEgGI3HaK05fPaQTz76aZOf5T55UWCtZ3Nrk6Q/QOsIhSOJm9SmZ6dURQHOU1WGk/GE0dkpw8EA4RUIO58dotMugbvO8xxXVzgLSs5WQpxf2rS5lzRZJoPGaW3QlNtcjAIxC8DxIiyMSpULGqorQVuwrtGELd4ZnHHY6gSXKpw0RNH5RtKmrqnxRJFElq0LNICwFJ6NfooloTQG57PgbbH2HDCF4Gw0xeKxAp6PTjkrp2RJyp2dG03AkAjg32xq7aQALfEqUFHtkptGxwMhOB1ZkJbhRobCYasSiUNHCilCSrLZlNpYSHjPT374A2pn2d27webWBhsbm8C7+A7Az4P4/PH5a7q5WVoAX6Z5zjtPu7Hyl31c4gJ+L3PeXrzHd3622vAKSxjL4fEzPvzwQ7757Z9HCsEnTz7BaEdVlTw4fMjtvdtsJjEW21mr4S9QVSF0MpT75OARP/noPX7527/CMDsPKQ1f5GKww/xEuiqKaF5eC3AHibMRSqVIkVLmJWVRIqUMS8WlpjYFtnGY9foZVRV2gBmNxiRxzObGJsPhgOFwQG0Mpa2ZTCZUzhJrjRCQ5zlFUVCWJZHSZFlKWZZ4PHGSkjmoTUWSJHjv2d3e5s6du5RlwenpGc+fP2MyGWPKnIMnjyhrw7233uLLX/kqvd4AoZrQPvz5bkFz9I1vtHFrDUo1DmF/DlTBqRhESTnjAedBvf29lWWajjE1ZVFySV8T5wuyIh2RphltFKCUkv5giPNT4iRiMOgRRTHDjT43dm9wa/8muBI89JIMiaQ2U7x3/PTHP8Y5x7tf/Sqnp9VMc03728RJDx1JbHQKUpE0C4HEzBnhOR9o5/Wt65raVJiyoqoDuJ5LiM1vuVjhHd7U1LaiLHJMPWUyzWfwF8VRs3NOjHQG4Tymys/T9jb/P4+ckhAriGLOJiOOj4+Y5iVCnFtZxm2S7d6A2oTFWs1isICXBVCRaMXtG4MAqkJhjA2rgAXUdVix6wWgBL1+bwYSYU/RUBcpBbaJnT6f+9q+4S9glHMeh6WqKob9HrYqUEqjZJPrpZ0c55iDNE04ePSIg8Pn3L59h5/7uX4TD7DYuloFNrMInU7/X9eJ2t5/qXx/fp2UkpAv8zLru8wftaieLWW4iN8uq5L333+f45MjPv38U/b3b2KcwVnP1mCbftonn07py5iffPw+7779JbIsm42tC74D7xlPx/z0vffI65yj40MG2fm39r7b69ev/zJ5LcDdO7CFwFISWUkmJcNhHyEUeVHgrGHQG8y0sDRNqLTEGENv7wb9QR/rHNZbwDGyOaOioJhOiKII6zwPHj7EGkO/36fX62GsZeRChr7dvV2EkFSm4ujoFGtrer0e4/GITz75iHfeeYdbt25ydHhImReMz864dfs21jqePnzAowcP+dKX3+X+218m6/URKuQpX6RJOOc4G4344Y//mG9+45tsb26DV8yiRcLIC4NJQFGFySb0vYavvmKgXNLi3Tl0XXDENgAvpW54TsJ4F4JeOqCuT1BKECchLYHCh6iioGeCACcqnA8bPeM8J0fH5PmEb3796wzSIZaK0XhCOR1xcnwQrAKl6fc3GA76xFFEJB3GFsgqTLT4znoBD1Vl6Pcz+jt7jeP8ouXTXuusYXT0OaaqqcuSo+MTHjx+xPPnh2xtbXPnzh16vYyqrkiSmOEgI0ticM0mISKwpueh9QJQeOcxtQ1x9F7Qy/oYa1AqXFgXJbY2IbSzycIYrC7R8NUeXFhhG1hbiWu2LpQS+v0UKTVnpmRS5iAFg/4QpTSSZuWu9yEVQRSRJAKlapQmxOd7OtaIQ3qF1FGwbkXLLXviNGMyGZFmCeoyIQCE/PP33nqb2hRIHNLbzoKu8/61yFLsrkadv25RP10GwO2/+XzoVVUxHo/Z2dlp6Io21Hj9CJJZfdoh0G6ZOVcn16wkfvLkCScnJyE18+gUH3uePntKbiqstQx6fbywfPLkUz5+8BFWOr757jeIRFgLQkcZc7XjybOnjKaBkvzk88/Y2tphe9CGKc9vzH2u7Kzbpl15LcBdSoiUwxqJEwKnNRWglaS3tYFqNtSt66DtOmdRUmGFZTqdcHBwgNQhF/WknDJxNUnWI0lTbBmyF25sbkCzJVwURWR7m4xFxaZKkZXHScHG5pAsjnly8JzxeMzmcIMkSfjss89wzpHGCYN+n7KsmE6mRFFEWZYcn55xenLKxx9/xDtf+QrvvvvVoF021N65AydQDO+9/x6Pnj5Gacl3v/Nd0rjHbKZueT8pODg65Cc//Qnf/ta36ff7PH36hHt37qKaUMxFqpQxhucHz7i1fxsInfT4+Cnl5PQisMNMVZBSoubCSpO0R1Ilge/2KiQH8zaAa6v1+2Zla+NT8ECchM0mRMtBAkqAMyX9SJD2M84mBWdnR0wmJ2glG99HjyzbZncvwZiSosxDGc6xu7PDn/0zv0oWx0hhmvCwRnX15+1rreXJw894//0P+fyzhxR1zebOFvfv3ePWjRtsDPs8eviQzz79jC+/+w4b/bcAFygcL0JKAjTGtQ48EFJTO4sTCqU0aZZxfHzKndu3kFqGmHlnoKjC/qyCxm/bCQeckbnMnMqhPzSUeCQovCE3JUIKdBQ3W7gZaudJdITHY43B+YqqNKjIhTm7NXoaB24rbV+zDb0fqPrF0SSzb57ERHFMfzDgbGzB1J1w4C5H7S/x5aE7XQaerqO0e7yt4yIt+vy6wIfnxRTnHA8fPuTBg4f84ne+w97eXrNQvFktukTm6+MaH5mQ7YK1i7RHt05VVZFlGdvb2xwcH1HbmseHz4gHGdSasir57PFnFFVOOc3Jfc7Hjz+hN+jzpTtvEws1K9/7sKXl2dkp48kYpTRRHDGZTuknaVi/M2dFhWpctobao1dNZ68FuINC6AGVLXCmwsaC2AukiMknBUJ46rrEVM3CDXzQNrUgjiOm0wnGwTBNIdHYvG60LDCNSdnLUqhqrLXoQYLra3xRMdEW5R21AlsVFNMzrA8f1tnTZmehlDwvODw85s6d2wyHGxwcH6OkZDwZM81zIq0p8ynv/eiHHD9/xre//W02NrcDX4oIQCUEZV1wUp4iUnh2+pSHzx7ypbtfQkmNb7xqHqjqmvc/+RnPz57y/Pgmo2nCH//kj9Facmf/NmHpkQzw2S5c8Z7PH33OJw8/ZnNzg2FvA1tV/PTHP6QfCTY2hheAJfziESpEmgg8qrYkWYKIJNbvoZUhaTq89R4dxyAUECG0Jk6HZP3tkANeCu699RbT6RQdhS3iJGrmUvRNAnQtI7LUkyUx/SxGeIMxjrPTAyaTAhUrknRAlikGwyFJklNXoW/4ZqsoT0gXEEqWSCeprSWONF965y3eun+XXn+AUIKz0zOKYsL2ziZf/7mf41vf+FoIWRaB5bQ+obYhuVlVVnhfESlBmmqc8JQKiMEUhuOTo2AZFAW1DZt/60jjN3rYwqKcm4HNDKgW9PgA7IKbt3aIb2yRVyEdbzxIgrbjHLk39JMIL4JFmkQyZNWUFuHAG4+PHJ6OleA9TgYtv6yqoD2Khu8VsrnKddwUjQaCD+PPCczZmIPDI6QXfOmdmyA088izTHu8Did8VdRHu5r4Jx//iJPJGDMpqUrDw4cPuHFjBzGPhgvqsfAZXgZrGYkQIQncZaevIc/HfPDxBxycPEdEimyQ8v6nHzAtJ/QHAwaNf29a5aBBZxHjYszD40fc3tsninozS9h7xyQfcTo5xXiL81DUBXk9pbQDpBYozieDWV064Z3BSmmjozysmNTgtQF3j5Ce7WEP35eMXUUqE8pJzjQvGorDz9b9VFVw4KVZTNbvc+fOXVQSI7TicHJKVVZooWeacxjEECcx2jvKuqCcVFTOIKUgSWJGkxFxGrF1a4+TR8cA1FXNNM8Zj8fcunULJRUnJ6copdne2gJCeFRZG6wEH0m8dTw7es4//91/wb17b3Pnzh10FKGjBBkpnpw8ZWpzdD/G1Y7xZExdV8hYXwh6OD075fD4CCHB+ppHTw4YT8c8ffqUW3v7QYOeOZSC8T/Ox7z3+YcgHeNqSr83ZDjc5D/8D//nPH/4KZ99/smldocQiaGkDAt2vKMoSpwTKBnWGwwGg5CoCU+SBn+EkrC9e4ukN8Q5T9yMjXe/tn3uCG4ckkxzwM40fK01yoel3g1tTBQpsiwOjnTvMOWY4yN49hSklmxubjLobZKkYRLNc4N1dTMVnmvxbR4cCFy9VIq9vT36g35wGBuHt+V5Q6OojcB4h2zWM8RxjBIzQiVYjcYwGo/Ah1QLzw+ezx473ByyMRxAFoGxiNLgO5E9WRpWsRbFpFXrmwyLjixJUJli6h3TyYTSmBn9Nuz3Ge7fDLsqOQt+giRncxjhhUKokGr5ogSyP8siCqfoqu4tfHVpiC7sOWdxTiJk4Jqno4Kv/Vx64ULnF2+QsQ6PfkFTnzksO8XPivCzQILDkyOOpqdYb1E9zUbaY1rkGGOIdcQV88eF57bPts5y+PyAvZvt/r2hPr6tlw/vkxdTjk+OcN7R7w0YT8cMNoZsp1sYYzk9PaUoCgaDQchv35httamoTIlTaZPSOViCVVXx9jtvcTw+RSpNaSs++PRD8J77t+6idCDLutp5O6m2rzkLHW0Hzgp5LcBdADhLZWqMURS+prI1wzhBOIWKY0bPj5mcjCnKgjiO2L91i53tLUbjMWdnp/SHG9hYYZ1FK9ksz5ZNJJjHS0E27FHjcAoENTESGSkq4YniKIQb+ojtvRuUkwnlNA+70/swoThnqI3h5PQYrUPWwTiOGQ6HiDSmtIajgwOyKGbQ6/PTH/+Qjz98H6UFXnqifoZNJaUtcbUhVTHWGMq6RimLbOKirXUcHT9vHImGw6MDjo6Pcc5QFFPKvKA/iAJINCBV25qHTz5nND1BJZJJeYZxN3DG8LOPPiCVy/PbIJo9Q2QA+lhLjAErY4rK4pzH2KqxZixCKTzNTx/AOOB2QDspZTPxhIU7iM6CFnGeKkwSUglL/AWNJFBniq3trRBBVeeU+QEPDkuM9SGx1a19hkiKYoqwNecbRDfPAXQcHNwIidcJVkRIZRG+DvDR5LTXWiO8C8CGRChP612WApSS5HWNkGF7u6iZEHUDDMZYXF4iZNRYK+e0CFJQmhKBnOWikT4oM14IXENLnR0eYV3IkaObBUDOWlxt8CpC+JAEDu+xVOG96vNPOFt6JtsdnMbs9MN+sXVZhG/URgEtG4deoaMEHSdkWYYUUcgb5D2tt2A+Nh3Oufb5UN2F/a2zKXTnc3XopeZPD9Z7Hh0/4/npEVopBmmfuqzY2Nxf8RYr3q9R8iaTM9774EeUJufenfsIAZPpiDTNUD60fVlUHB4egLNEcYTBEcUJ9bji4OAIawyD4QY3tneIoghThVTNQkqKsmRaFmzHG+ffRQiSJOHg4UGzh0CBKEviJObw6IAb2zvEUXKB0gvN0k7EokmlEc6rpeTaubwW4I4AFWucdFgcxobNAKrEUwuPUh56CYlx7O3f5M6d26RpghCCaZ5TWUOhoa5LEII0SUIUhAnAJ5XE4ynrCis8VqoAaEqitWY6nTJbCiJolo3DYBC2iLPWsrGxR51UnJ6c4IyhKAuqqgqx1WmGkwLnodfvQ2UoyxKtNUUR9iY1zjIQHhVH1HWBrSxpL+bJk8fko4JYp0RRjDUhcuLw5Bi8RyvF4dEhk8kErTSHxwd8/0ffI44Skjhh0B+SZX2iNObp0TNEJPDC8fmjz9jp7/P08SOeHh+wkerLE31zQEpBFCWYOqewhs1+s18kPSpzu1kAA4OkR5aGXZsEAuVBhITuhAx4ouHjaeio0Dl9SxA2nGakFUqJBsTaSachz72bdeA2/jzSkqjfY9hPGw625vMPPqQ0hq3dG+zt7pJlKWI6IbdHOGvxNjxUNKghZMbB4TH72wOEjjFeINy0yV0jOh42gZSttyBo186GxUxZmob8Lg6iSBOpsFFJbWtIIpzSqMrgbdjoRDg4OhpjnCLNeiE8N43BtrlhHKL21KKivzEksZ68nBIrHTJPRhGldwzOsZU5XXeOlWhik1xzg2vSLc/UW08beXOhD/j2bsH2zg3iJFh8VVWh42h29bIQxoPDQ6IoYnNzcyXkhGiXi2zxbLK/cKMA4cjzKYfHh8RRWNRk6gpT1hwcPufo+Iibu3uXJpL5qJzL4YOOx08fczg+Jn72mJt7+1RVwR/88F/ytXd/njvbt6jLmoPnz3n69AlCCKzzKCECTijBjd1dnHPESUochxxYznuSNKWuKqbTCWfjMbf6N2YhvtPplA8//JAHDx9iRAjhjmPdWIeOw6NDhBNs9DcuTYrhs5+bXt77Zp+KfwM0d+c8JTVqmCC9IdVpAFgd2MG6LOlt9xiNznj24Qd8+umnzfLwoB1t7+0SaUj6PVwFxtRoGVYYejzOghGe2nhUFuF9yIIopMI5SxJHFGVJldfoQUJ/u08kJadHp6T9AZGOGE9zNocbpL0ejx89YjQac3P3BkmaIOKICSbsoiMzqrMxkZJUZYFUiqKu0b0EHylqE3bR8coHq6G2HI2eIa1By5iyLBFaYVEY7xCq2QlIhO3evPe4CRSmojoaY/KaLM24eW+fkS3DIhkMZuj57MnHfPbhR0HbSjIuOI84d4qKehoAwBpwNQ7TRHOAEg6cRHpJFklEUwchoSpOcLnn5PgECBNl2EhYoaIo5GpRwSka4qgdUZOjJYB9k2u81U1EC6ptBEgAZyVSrDdNrR1prNnZHFLZmqoY8fknpzgvSdI+e7f2mwVoZxTjs6ApNouBhA9cPU4iRIVrVmEKIVEWEIGSEMKBkDjpMalGCIk0NbGP8VJSTAviKJ5Fyyg01nucFggU3oAygZo6Pp1wcmpR0ZjhpuLWrX2wno1Bn8qO8ErhhaIcnTHNc6yzTI2lLEtu376FHAyYKIFMEqRRSJniMTibB6B0Fu/tOWh2qDog7MHaWAxhobiHOVAQtOGVYWcqqSN6UUzWF1hT4USIv24hcha/LQSPnjziez/4Pns3bvDdX/glorkN7oOEyUYIT2UsKtKodgPt2RzlL8xXlbF8/OhTDk4OKEyOlIqt/iZJElNUBY+fPw7rKnQ8ozKEaFe2nvs9Zu/YgLzzlpPJCR6YllNGk1MOT59zNDnl+z/9Q3rf/bPELgQPWG/xEpJego9EoHprOBuNQQh6UmKb1L860mghGPZ7SKkpyyl5OaWX9fDOcXhyyPHZMV4GP6H3wTqI45iyLrF4pI4ag7edcD11XXBwfMT+3s0wNpSf4ZoxNavk9QB379CxonI1Z+MRURwTpwkIT5JG2EYjHG5vMiRhOBgQxTFlVVHXFWiJSBOmRY6tDINeH6zFOo/1DilViBF2DiUEKonRLnwQ5y2T6YS44cStNaBj0iwh3b/Fk6ePMd41GftAScWd27c5PT6ZxfCKZuVgbcOk4pwlL0v6vT6mNgx6KenOBmQx4/yMJE0oRYWlBW+JJuH46AwvHP1hH2TYsxQPQoVO5L1HRAqLI0kjfKKRBrJ+ihUOY2v6/T4oz9lkhKkshSnJogSl1YJoYACB9xY50wpDjLabmYVt3H6TK2WmPQgOD55R1zVPHj8Ji2tcm8RLgoQojtkYbrKxsdmsjBQhOYr00IB9oGHmAMeHDt5yoIWtOTo5Y3x2xt27+8QqaHZSQBJHbG/20EozmuR88LOfoJRie/cGe7fuga0ZT/JgYSUpOzf2UVHE2dkRxdkBbYZJOm9LqB3K+hCDr0JfMU6jbEhcFbaa00RRRJIkRFqBcRjpicS5FVPXhryoiYVARTFehBw2XnjQirNpQVEZ4ixEqozGI0ajEUpIJmdjBjpBxRnCWwoTEpHVlcK7Kmxw3k8p8+lsYmy8KCgdY+qSEGIbLDFr65n1dAHfO7+f5ypXeHu+0t8TVkm3OWOccxyfHPKDH3+fcXGCeZZz+/lt7u3fubjpSvsIETIqfvTZJ+zu73Nzc/vCs4PD0Df9EWprGedj+sMesYtIkwzlJK4yCODZ0TNuj25zY3sP2WysMmMGV8hoMubo+DBw9mmCl57xdITFM8rHPHj+iK/e+zJxGmO9R2iJ1AorYZpPOTw8oshzpJYYZ0O7GoPSulkfY8myjK/cfocsywCY5GOcN9zYv8Ho4YTJdEpRFEgk1tiQn0aGNRjPnz/nxo1dvA/W4cnpCT/74H3iKCJNEiKtOTk5prSBPVglrwW4B8dkMO2TJKauDdOJJetlxFrhlcRYS9JLSIjBeMbjMZHWpEmKSmMq4ehFCSLrIzzUxuJhlgDKW4+VAuMsZVWHQeZN4xzUWGOxxiIdlLbATEoymbGxsUFl6qABAXlRIKQg3t7g6OiEm1mKkB6JJFLBhI2HPXTt6CVpcBoqiYsUuavDFnRNMjRrLL2sh1MK5yWb21sUZcmoKKmdZTgc4AgmndY6ZLV0Fu8UpvZEaYISMTJLmVQFpanQKlA5TjhqX7G1s8Gd7bdw5YSTUX6p93vAC0mFCEnBdExVxozyI7QWJHGEkrKZtNqojAAAUig2hhlJlM5CzMDjbJMbHNjcDDG8zpjmrGi2ivMY54m1Xzggw6Kk4Lwcjaf84fd+gBSee/duX+Axwy8gFfR6EXt+gHOO6eiIHz15RJz2uHv/HYabmyAVOk2JkgQxKUIaXwwtYz1jLKTACxn8AcbjK8vB0SFJGlOXFf1+nziOmU7HHB4ekiRB4RjEcYjysg5pAz/qXHC6h/bSszYXAkTtkN6TDXsYZyiKAgfs7OygG0dcaQ27BMUEocE7rLFoLWjXRnSnRuGD9h0nIZe+cyHdr28cfcKr7hx9qS+cnTwnzyfEUYqSIRRW+E75M5rDM5qMGU3PMLYmLy1nk2Nqs0eikznjQCC95ODoGT/86R9zPz9j9zu/hGxSHQflq0nh2/aLOOL2/j7PTp9jK8Px+JBEpWRpxiTPcQmcjEdsDraJdUjihg/0ydJIHut4/OgReZGjteLg8HlYQCYccZJRm5pHzx5hS0OmwzfNy2kIYZxMOD47QSDZ3NwiSVOSNCKJY3BQ1RWIkCojShKeHD6npwbsDXfI0j47m4JHz5+RT3O8c+xsb6N11OQ5shwfHVIXFU+fPObu6C6T0Zhf+Pmf5+T0mKLK+aOf/jFCStIsZTwZhygtFKvktQB3GWt8P6aYjlBK0uuljCYT6rpEa4V1zVZvccx4PGF8cEyiY/o3bpD2e1TCYV2FqS2uKIKlbyzSy7C4yQHSoyOFqWuch7gXoyPJZJIznUxDpEUUnJROSyoMsTG0y6WtMTx88IC9mzfpbQxxWhAN+4zKgsFG0miuwV/Q62XIaUWvlxLFCaV3lLGnyEd4QhSHqWv6vZC2uK5qvHNESNJ+j7KAWAe/QF2FxRK6yS0znU6ItEKnCSJ2eG9w0uGFI8tSrA+5cxAClQbKIYlSyjI/p2znRva08BwdH7I5DKGSJ6cFP/rZezhXs7O1QV1V3Ni9QVkW7N7YYe/GbkhIpSQiihDOIZ1DR9EsKZjwgiSOkQqmkwnQaJ0Gjs8mnJ6ekCSae3duXK4QMAvvEAIlAz0gVIiZ77LOs3hoAg8pY42WmsFmyt04wyI5PDrh8weP2N7eYXNrQOp92EREKAQGJQROSpCKqKExvHBYAUIrNJIkjjk+PqXIQzv2ej22tsLEVRQFxlh8JvFSY4XH1QZpLKpxmEqlcK7pS97hpMclmqyfkFcVwqqZtdTr92cashCSHIvSFrwCF1IRCBVyy8xWNM+aMGjNo0mJ94IoSgN14yqEgDTJQFgWtbnH8/57P+Xw5IzBYMDu9g3u3rkLHZtvFnFiHePpBC8gSVI8noePH7E73GNv+wZaq3NFwntG0wk/eu8nOGE5Pj7g+PiI7a0doiieafpCNJ59B7mZ8PTgAOs9WZrRS3t4CzqOkVrhhGCcT8LCRdEqA1wC9i7AtwEBUZowmUzwVUGURFjnGE3HCAkjMWZve5+7d+5w+PwJE2NRUUwvy8j6GUVeUlU1sVTYvGI8LWeUldIK3eshpSSvCp4cPyWNYrTQPHj6hNqasPWjFBgb8uUroYiTiNPRSdg7ty74+NOPcaVhe2uLg4PnGFNjXFBEyzyntjW2jhD1iiyfvCbgjvOU45xpUVBUOVtb2yRpOuvgSZqGtLxeIPoxsp+QRj2MdxjnOJmekZsKhSBSYXm5R2JdyMWtpUJIT20dqhIoC95X5NJRlRWRitBekPXCFn9+UjI+OMHIgrTXC8mMlGJnb4dplZPJAQgYbm00eeFt0N6lQhNoiUlZ4Oo65E/JEmogUprpdEI+mRKrCNXT2NLiKxe0rERTm4q6LnFek8RxWC6OYDoOy/uV1kgVHDEWi1AEB6dSVMYyGp3hpCOJY7yFaJDircUbGygG33LcLc8doqTjKPDlzoZQwMFgyHR6QpJEGFORlxNqE6J3GuMZ8CE6Q6rGhxHx6MlTBJIvvfUWsfJ4XzdUR1hxY52nNBXIEKE0n+FRiPO6hbj/hrH1jrp2TWKp5uIZz+yQwhNHMf2teyGffLPQy0uI0wF7xjKZTDg9OWV4byPs1Stl4zwPXLW1lroyxELipUMhsJXhJJ8yno5BwObmJlVVU5Ulk3FYjKJ0FCwy58EYpHNIF4Z8XYVUGmk2oCprrLENzQUeST4pgyWpPCfHx3ggyzJ0FBFFwWpyUkAk0S7C+wglQpZHpJ05sJkRX8GBfXIyBeUZDPsMspRqWgenuTVEuqHfZrZW0/YI7t1/i7v3JVUdksC5YsSTx59RlRIvJXs3b7Kxucnx8RFHhwfYOmzlZ4zBVZ4nT58w7A8YxMNmy8Lg1/r80QOePn2GcZYsC5NXJGUn6iPM2s45xpMJnzz8hJPJCB1HVHnO0dExcZQwHG42zn/Lo0eP2d3c5e5eoIJCPzl/m3NcD3Hmpa2xAqbjKXGSoKKwcbk1lkFvwCSfMM1zTs6O+MmHFWf5FFNbpLQkw4TKhWCH09EZPs9D9JwUaCXZ2NwMi8bGY2JTE6mYjWTAwycPqGuL0pppPiWwFKGeOgoZj2pTY6wlI0Rmee+wwvH+px9gsSBDmGqImKpx1mCsx5Yrk+2+JuAuBLkNnvmdYX+2zZ4xIYujjhzWhRziWT8l2t3BjktKUzE9LamtJUsDZ2lq02RqFCBk0GN8CCiSQqJkBM5QTAumdU5VBHNqs9enjirKaYEqHcP+ECkk1ttZiNdgY8hmrBCECAQhJToKKWGtdZTGhA6DoLe1yeToGHtyQvG8Jt4ZoCNFRkyaKqSX1CcFljIAWqQDwRkp0iQsZJFKMTk54+zsjFhHswghZx1xKkFodKIRLix6MsYikMQITFFT+4opUz579jNiX9P6sM4l9H6tA3fsG54Yqen1+jg3IYo1qQubl2itZgt/WnBvS5Q+rBD9/OFD8umU27fuEPcUwjsQjiSJqOo6OC+VIm4W/yxy8M11DkyTs8XUJbWpUXF0/gZtpEf43OgoUGEXVvL54AQcDofc2N0OHHmUkzfvEBzsvqEx/KxQLwRWC0Qk6Q/DngF1WSFFsybAutDvZJi4qobHdbUP4Y4ONoZ9ahsjlaAspuQThbcGsTUIG5BPS4qiwmnL1uYmXoTEeN578jwHAk2TIEO4pm9DEWde0otkc+OI816EaIyGb5cqIk4D9RBnEXEcoaSa7RnbH1qsD6GrvaTPo0cP+P4//af8r/6n38A9/wH/3/dGPJjUfOe7v8wv/uIvkqYJd2/fIU3TWY4dpTS3928RJ9FszFkb6CYlNW/f/zKlqZFSYiqLNY6QTz+MrzDNOvA1xXTCeDSisBUYw/bGJlEco4TAWEh00PgrawJQqqaM2crZ1sRrYtwRjCYTDo4P8d4zLQoGekCbaz/Pc5IowVrLyfERJ+YwhP06UNaQj0pOxyecjsbkRclASuqqolSCqN+7kNakMjXgmU4mnNoRpjJEKqKsCkbjMUIKoiQhSWJMXVOVNd5BP8ugmYS89EyrHKEDtWzKEqk0WifBke8cSv6bsIhJQNpLGU3GnJycEMchRW2cxERxcAYKJxEuODi8DDzmje1ddJowrsJip/bDOn++mbFENbxeCDkypkJpRRJlIa2BylBCMxmPkE7Q39jkYHoAxrHZH87GkBQCLQzCWoQfNeAmA8fm+mEnHuepR4JxUZOkGZHW7G3vcnh4jJ1WyDiiLyS1CcAglCZsXBc+YH42QgjYvLmHNwaTF/R0TLKzi2xi0B0OISW2MhhvEELhbeAqkzgO+nFVgZS4wjEuxoxPRtzd26EnF3N0Ukp0myueoCX3sj61iZvkbcEaMuY8lrmlTZyz+GaRmfSeNI7DTkndpd0+UFHBeRrOaa0vbOgwi+7orKBtFa+wqArqylCVhrQD7mKGcQGURWfj4g68N9RFs9LWtAuqPKpZ6QugY0miBVo5rBCUzoCUlEXF0fFJWLJOoJxajng8HjWamSTXkvTObZSWTeii4O237vP2l8ImHcYGCqF2NU6HBGJaZWglOD07wnuPMQEMe73z/W77vR6ql6IzgapAVSEnTRzHDIYbJEmGVhqtI+IohFHe8xFRFjY1T3RQSKSOEFKdJ6qynWyLAmo8CI10oHXCN3/tkD/zVhooq5Hg//KhIssyTk9PQFg2BhtsDDbOE9wBCoGrKvLKzOYcKST37t7j7u27s1z2AHleIUTdOPBdmFiFxznD/f17DJIh/eGwySdEs57C43BUVUVZ28Dvd3K6z3wCvu0DnslkgvOOg6MDKlMz3NikrCtGZyN6vR5plgb/TlUTJ0mwgRTEOkbHisJUlGclkYjY39tHxpLi6BhvPSdlEXZuE6KtRnA8a0VRFcHHhCevppRViTFmprHjQtI+azylKZnm07DvRCyxdR0W0tkKbz2RB2E81BXeOZyznbG4WF4LcHfWIXyIK9/Y2EAIxdHhEd6DQGKqGh1rbG0xzeKZG1s7bPQG1LYm9pIk6wceazrF2PPBGzDGh0RPXiIUWBPCibABdIoyJ9aaRx9+zo29ClMVaB3hMhiPx3jnyNIMU4Som7qWlGVJ3IvJsjgMVK+QwhNhsNIQx4IqtxyfHLG9s4P1YWeoOIoZTUMoZmELahHKjrKMiJR8PGacT0iFxJU1sVd4KcmLgqiXkOgIV1RUeKSWCA0OEXLyVAZXW4TxwXpxHougPxyQpCl+SeiUEGEtgBSiYVcdWdYjL2OEELPtDK21zSq6ILPIDKlxHoRUZGkv7PkpASxtaoTzRU6+yeanUWrR5gbnJbeSJDHf+MbP0UtjBoMeM9hvZoDzMG4P3s7YGmtqsAaTTwEF6JBBkhYoHMKBlAYvmvBY4TDOgpfnjq7akCQx1jnSJEE2E2EbPWJrGxzk3mCrGuUaM0JKvLVgQqs2W28EqqUokAqEcZhySq/fD0nu6jpEUkhJHIf2n47HaOdQ8SZlZckLQ5IqbuztcXM3rGAtyoq6qjHWYGtPZSacjJs8PM4xOjujrOowOcmg/NRlsFq1UiGtcl1jvUf6kEfnP7iT4X2BKEGUBcIofvCDH/BHP7BYW6GkJJKSKI5nkWMq0vT6PXq9Ad47TF2jlEarKMQiCcGgPyBN06YNJXGckCRBa67rCilDRtRhkpJIjY7TEKLZbgYiXJNM7byP1HV97hD34nwicJ6qsggpuH/vS2xublPVFePphLwoZv1xKx1gnKF2lrIMm7hQeeqyRjpPz8egYqSKUFpgpSLOUrKdbUajU44Oj9i0m/R7PdI4wRuPmVahr0jw1oZoPa1IG8rZGRuwyoUd6KI4bP9IXUNZ4rwnVRGJilGRpigKJsUUU4dJ6HzTksXyWoC7khIhg4OoLCuqsibLMkxlKEfTsBNOYdBSo61HiwhnLYeHBxgbNg6OVFhUkkmNVh6vBJUxWBNC5qQSYD3eGYTWs5WVQoQMfcZY9m/exhhHlvZD/LoXIZ65sfCqusJag9aKsqrIhhtYqwPV4yHNEuJYk1RTKluSJppiMmWSh82ZN4Z9tJJMpiM8jlRpnK2ppgUJio3BgDhJmBY1NtVoAZlswjmVA0psYWfbbzklcTribDrFexikGdYYtAsx3QLbsOsSrWK8CYta2t192iBAJRVRkuCdR9SgI42KBuzK20CJ1mHlZZ5PQ/oBQAjFYGOTNB0AstmjQvK1r/ep65I4HeCEBa/xooYmKkVIRRTH4OVsJSbAuVewiW6aLXbx7O1usLe72RyvZyk1wmBuMl02b5qPT8Nm2d7grcWYivFoBEiUTtna6qE2N8L2imWF1h7rmpTIgrAwyytMo/1nWQ8rS0aTKTqKyHq92U5BSusQxdQkGqtN2Ey8FgJtHbKTyhnO86f7QJrjASMc1ntsVQUAaHYcwodc8d57hoMhUZoiQigXZTGmKhWffPwZn334Kbaug+Zrw0YXCJhMS/KqItaa3Z0tTB2sSWtLkrih87KoiSYLG4nEscRYUDrj6OSYf/hJha8Vtpjyu088tVBEePb2b1BUOaPxiIm3uGqM8w6JIFExdWE5HZ+gZcjqWjZbWoKgqkLkWaRDrLtWEXGcEMcxxhjqukJIiBqfQxwlDDaGs3BmKUKc+GA4oJ/2iHWEcY2/Kw50kxRBUVFKoYRg0MtoVz4P0luB/PFN7L6HsFdps/q3ob3C9psmBD+Y8G2rqiIvSipTooZh5fFonJOgcb5CTQpM4TGycTrXliwdoHQETrA5GCKUpK4NxtRMJwVJktDrZbPNaHyzu1TcG6CkZJBl1NMSgaA0FVGUMhhs4pzj9PR0Ja6us4dqCvwTIGmu/3967/9TIcQO8HeBd4BPgL/ovT9u7vnrwF8muNn/mvf+71/xEIy3eOMoiwAmSZKSaE95dIYuTciAl2ksDiksp9OcyXhEP8nopRmmLoniGF/WRITBUxiDtR6pddjAwXm0DPuBlrYCB0qE5FTChyW9xtpA/YSQGwa9YLLlec7B0QGbm5s4YLC5SZplPH9+gJKaLMsY9nucnozIej02siHTfEraj6hdhSnGVPWISFuUykkyj5CWuCjBK7Qc4dwGRT0AIbFAmnmUf4JyNcYSQqcSg3caawXeR7jKkEaaSMd4VyKlw6Eb52tEplPevvdlBpGmLgrKsgipFLxFNlsOCa8QQmEr0yyuKDCupqottZk0CceCRtuanl5Ikt4WSieN5iyxDvobSZh4cFg83qdYkTex067RaBuXbGs+dyj3872LQmx94GDDxBBi8F2goi5FQ0icdYxOn/D8+QEHBwdNFIshS1Nu7t/kxu5N8AbnHFWdhwlAtI7IsAS0RlIKTyE81lmsFEymU5QOdMdkOiXWOuzEVBQB3PGzfXhV1sNJRZ2q4FitDbImOLMlYfaQYUONojY8PTmaLTlvaUUpJarxGzjnmEwmKClJ+xFSeXa3MuLYIWVMqhRV46ijWfTlPWwNB5iGmkyShEp6kkxTFSVps0K4GXpAWH7gvSdN+wg9YDQZ8S++98f86NMht2/tE0UJngoda/qbPUTp8VHIpJ7nOXUd0mQnsSbWGt2swkyLXnC2Nl9wPJowGo0YZD2GSYa3sLW1zXQyRakQpjmZjinKknE+wU3GPDt4jjE2WFTQpOkQYSwrjbW+mSQ0aZbSS1PSJGFzcyNQvJFGNjRgFEWN5hz+Dv65sJ2kkCGcue1Pbf8K/1onP7PQVkeYUIuioiqnVGVBXcPJ6RHGVFRV8JkURRloYSmoq5qyKLDOobUKARb5lCSJ0VISR82COAQ9pZmMp0xHE+oyWHS3b9+mrmuePXs2y6G0TNbR3Evgf+S9HwshIuCfCSH+G+B/AfyO9/5vCiF+C/gt4DeFEN8E/hLwLcIG2f9ACPE1v2IfVeeCmSW0DOaaDOAapzFy2Kd6fkqsJXJaobQny/r0BxsM4owojknjGG8N/f6Ak5OT4IjygftyTY53UIF60BFeCtI4QytFrBRaKrTWxEmCcYZpmTMajYHgJJQIoiiYyKPRiP39W6RphlYRmxtbzSrHsNp0uLHBZ5894O233+LmzX2quuLZ06dMJzlRpBFSkmUbSCtxNifSU4Ssw4pJWVFWJUrGWCuoakskEyQKrTxSREg0XpYoXQU2T5yEpF0+AqmolcDLmCgJoZS9eMCjzz8hiVKGg02cVyT9HdIsJY0zkjgJ3nhfYGpHXVQkg7CEeporiipEb1RVhVI1Ump8E/kCEu9l49Nrd3U/j3YB12aZbYAnnJFeNNEqFzXbVi4sv55d4umuZm3v614bnPAhFPWdd96e0RoCGgdugtbBiRtphY8iQspfFRaJCUEhJFXjvNdKMKoNaZoyjGJUFOFMcO6WZcG0KMjSFJ0kRJGmrmsm0wlOKTbpoZrVryIOCbyEDZSZFWHloxCCre1tXLMiVWtNpPXsvZIkCfmFygqcpcjHREKTJs3Wee581XLQozw0Dm9vCxQhlYKti0BXNZt2n+/kGyaC1gHtfdi3WCVDdnZuEquYcpLz6MEjNrZ20GmGd47R0TG1qUAK8rqc1X0ynmCjmGhjMyzQGoUFiVIpjDUURYmXgq0bN4hU2PFMGMvJ6QF1ZRj0hgw3Ntje2eBsNGLSpPrNJwU6joh6abDUQ8p88nwaUmsbqMsa72E0PuPpk0c4a2eb4TgX/DBJGuLkB4MBm5ubYdKrqia/f0SkNb3BsJkEYnr9XrPBiUTKdvW1DFts0mjZUpBGPRhudRDtS1jrmoCQkIm2qksmxRTrLUVRUJQ5xtRMJuOQZ0Yq6rIiURmxcJT5lLOzYxTBwf78+XPwnuHGkLPTM/r9PpPxeBmkAuvtoeqBtpSo+eeBvwD8+eb43wb+EfCbzfG/470vgY+FEB8AvwL8yxUPIYljamtw3lKXZRMWlaK9I4o0tqo5Oz6l1+szOh2R5zn9wQAP9HpZyLN+Ujb5H4JTIrWCqMkcJ7xAySbRlbGksSZWgdfUWjGeTMmLnMHGBhvDLdI0pDsQwLA/YDKdst+YbGVZ0esNcM4TRSG3RK8XIlyMt9y8dZuPPvmUO7dvkSUJWxtb2NpwcHCIVIonxTOSJOHe/XvIJOSS0MJjhCTNSqaTCYYKSUwUDZGuBGGw3mNqhXcxogVH74ITEUB4Iu8RokY2i4i8LBluJkjjODr8lMk0x5pglkY67GgkEEgV0xsMiJMeXil6mxm7+28x6H29CVk8zy2STycU+Zg4ifCOsFagmAagdSEuWSrZUOKu4d1FoyFBP4kQSgctvFk+30ZtzJj8Wbw8tHAk2+iHWaRO+Ls7MSgVnH7d+GYpQ/pepVXIW4+7EFudVybwoaTUtUEIGzTsRBL3UqIso6pDSuMsyzg6PMY5y/jsDGcMfSHwSqFkyF7pXY2RoGqHroOSopM0xFYDJhbYKHDG5vSMPM/x3odoEKUaijJo93Eacn1HKkR+OREmU1kbpGlWDZ8nnrnw3t00YZ7A+84iTefmz3OuK2zasrW5yc7WVkj1oaAoDXfuvx24dSVROub5wXPOxuMZgPbSDOlD+g9jQ3KzfJxjBRydnlBVJVESM0w0QmuMtxTTEZQVSmimkzHGlOhYN68VLA8URGkU+Pk0pqwK6qokyRLiKEZ4wXBzSBLHuKLk9Og0RD+1lhCC6WRCVVacFSWHz59jTODD8R5jHc41/qM4rDRN0zhEKSVJ43eKm+NpmOwHfZIoCvsX0DpT23QWYW2GjBQ0eXGc67G5sY2H2V4BnuBvbDchMnVJVRVMpyNOTk4Yj0YoIXj+7FnYXyGOKUpDnPWZVhVRf7AUUmFNzl2EreT/AHgX+D97739PCLHvvX/cdKjHQoibzeV3gd/t3P6gOTZf5q8Dvw4hUsZZ1/yzzUKmHpHSOF9AYnEuZ2NHIMUEpRVbeylgcDikqHEqZG+MBwKlIiI1JLIRk3HVhOAFx9/NvV2qosSYmiTRRHFYnaq0YnRyyqPHj7mxv8/e3g1u7e9jjaHIi5BydjhkNBrx6PEThAAdRSjpSJKUo6MjsiRjY6MXnHYOfvTDHzGdTBj0e+zf2idLU5SO2N3d5fHjxzx68pjNvW3iJCHRCuegrCp6vR460UjnkVpRTR3FtEbp4BA0FUS6h1IRUqgm3DOMTyEkkY6ROiSeSkTG3u7bFJNjbFkQixDTIEXYnESK4Fy0ForKcHr2lKI2WOtCTLsLucGFEKRZSr8/IE5Ttja3iSJNL+uTF1M++PBnPHz4EC0k/86f+3NEkceaEuMczpkZZYAwKH0ORk46ZKP9n+/403ChhNRhWkYYe24dcAHkZ3dA5++LmfUUTm5ibYi7DqzdeVyolDFC1iHXlpCIVGKlQwtLLBVHp2c8ffZ8RvGcno6I4whjDNPplPFkErYm7PXYHA6JowiroNQeqzymqqGoUUKACsBuBVR5gXFhw+0ojtENTVDlBZPphDwv2N3dCdZGHJGgmuydTSRSJKF24DouaN+2R/NyzQ+lJN5ZBMEfc75gv9lztm0rZ8GHxXvb2zt8/PEnOO/Zu7mHIGwG44xlnI+QUrJ340aIDMmLmQYvZNgQxzYpQBSQxDFJHCOkIB9PKWXOxnDI5t4O05MzitMJaayoTcW0DE5D3WyOUrqwclw6j81LtBJIHdKPeAzewKg8I48U3lh6WR8QVGUZrHVkyB9V5SAhn0xQIqwlcN6HBVlnI6TSqGajlOPjI05OjhEIjDVhkZoXM3Dv93vc3N1lOAwL2WpjEI1iEcdJWKzUAH2/P5hZEVKIwME3UUpeAjGBynQJMMSzx1tvhzFgrcVUFbY2OGspyuDDaBc3/rd//x8uQOwga4F7Q6n8ohBiC/j/CCG+veLyRUHLl9y63vvfBn4bYLg99NPRlNIUITRLCSajMyKp+P9T92c/lqdpfh/2ebffepZYMiKX2qu6eqnu6Z7hLBzuI5GmyBFl2ZJpyIBhASKsGwE2YBiW9AcIoCFA8IUBA7qTYAg270gIkGWQEHdxJM6QMz29VXfXmlWVS6xn+23v4ovnPSeyarqbI4g0Wr9CVmZGRpw48Vue93m/z3dpSkN9VKDnVrqtIHAAFIxjoN91oAzOldiiwJSCI58uThk6j9FizqO1cGG1Aq0Knnx2w+3qmkePHuUhoZg57bodn33yMevba46OljjnsLZgc3XNYrHk/N452lhWtytilI5rsVhgtWLWVHSbnTBt/AQp8faX32K9XvPBhx/Q9x2LoyVN2zJbtlR1TVEXBANTDpNuGvGjCF5gAm0q2qYCv2LT7ShcgTORwhRY6/DTxGazFuaCsZRVSek0VSVdICmgYshXIMMEJDkPCMUTrVFWUSnxyWir4u6i7a9clGLvd9fsbiaefvw+kw84V2Gs5elnn/Hxhx9x794xdVuzPD6hrGqM1vhxoN9u6XcbJFxJDMp0GjPVRef3dWcwhpKHOWnNFDwhCnQgqMrdMPhw033uzf7BWzIky/X1NWcvPRRM80C1TKC0AD5G3EkxXqiGEbabHavrG0hgjcX7QFmW2TfeZoqol628scRJvIl0ECbOmBJXN7c8+eQZD86OePDwHiQt3B2jOVrMSUA/yvDUKs3tdkvfdWw3G1RK3Ds7E18aLTYVKkH0YvNQaZOnG3c/q9aGdtay2W6J8QW4RjCYjLPnxVC2d9J9psDV5VMimqQ0zy+e8cabb3Fy75ikEl3fkwjcbNZsOlF0juOQm46I0Yp+2KE2iaZpxc56GPBBHDCLsiBGGd4qZRmHidI4nNJQFFSNsGKm7ZoYE/0wYLVFh4E0FPh+ou86ykp8/00IhH4ioVFMhGFH4Sq63ZrgBTqbzWYSUmI0Zu4IGtxUyL0VwbgCW0hEY1UV1HUrMOO9I6ZJzOq894x+IkQ5f1OYuN1ecXH1DJ0cOuWsWGMylm9pmpq6Fi3H6ck96rqhqkpJYHJO5orWHeYAzlmM+kJmrNIY6yisQ2WW15y7z/mpFt75+B/Elkkp3Sil/jbwF4CnSqmHuWt/CDzLn/YYeOWFL3sZ+PRnvrDKDIKosMYd+KrVrKUfRkwsUF3AJhmG+inS7Xq2uzV1VYvyS3ecPXrAiDjkddFjnMNhiCEwDH0u7sLFPr13QoqBaZooi5q2bnG2YLY84uPHn/L4k8d89tkTHjx4QFVVpJR4//0PePjwIecPHjAMI8+fiTS4KArunZ7irLAP+r5jvmgwFh5/9BHtbMZXv/oV8cjWSpgDSoHR9NNEaas8/JLYwBgTZVlijGE79AzXa7rVGtNWlM7SNiXLtqUsC7bbDTDirKUua+bzOc+fXTCOI6enpxRFyTCsmXzHAaf+wo0xBU03Ttk6wPDk6TXduJUdVFUTYqBpakII1GXDUeNQ0QvMUlWs1huOjpbcPz+naRu+853vys9QWIqiom1m3L//gKPjB1hnKMuC5D3T2DEOW6Z+K57oKhGVEdw+CaSjUKzWO37v298m+siv/7FfpSiyhGrP0U4KpS34O69xpe6oc3tY5242sIeA8gxAK1KygEX7gLMKHcXqddVtcXVFyp2oUZpaG4kHzOHVe9+hhHTjNRLbrGLi8SefcXXT89JLL9HUmqQN+ESpNCYoVrsdT66vBPbJxnYxyM+x1xc0dS2K2whPP7vg+dML3n7zFawVu4XPu7SnnNO7EUZOXjSltVe0TfvCgPoPLoZ937EbRjbbjudXz3FlTe87Tk5OSCim4KlsyfJIFJn9IA1Zm2X1JmPpWIMrHUMMYomsYLsTjHy/QxmGgUKBJhK1Z9Nd53D2GqMjfgIfO8axQyVDXS8k9WrPdEOhk8IYxTDCNCVi0hAi0U+U1nK8XOIKyzp2bKce7aA8Mky3neD1GrSxlHVFSAPaKRSaaQzE5NHGknTCx4myslRNgbYNpS2oTMXp8T1IkU8++ZTNbuBmtabrep4+vcEH2Q2W1QdUVXVwTXXOiUahaYU6WdXMF3OauqashJAgtr4Gm+0ZnLECI7H3y/rZhR3+cGyZM2DKhb0G/hzwfwX+BvBvA381//7X85f8DeC/UEr9J8hA9W3gv/tZ30NrLdj4Pi5uioTo2W7Wsr2rDRWKuBvxIaFtISHUWrPtdxSlo5k3DDpC0gQf+fjpUx7/8GOsMnzzna9QNw3dbksKHiIsF0sp7GUh/GYMZWEYfGAxX3L/PLBer5nGiLWyLavrms1my2zdcTw/oS4aNus1KoFRmnbWclQc0/c9FxfPWd3ekrxnXlXM6obzB/fph4F4dc3tasXs5AhnhfvqY2Kz2eZtnXTO4ygD1vK4xRzV4pEeoesHjhcLnCuYtXMWszld12GVuMwtl0vZPmdq1dMnH2OsyHXEROruxogpsdt1XK9WHC2PmeLE5cWOq9UTQhg4Pjpmu91wdLxkGMRj5uWXH+ViqbBahslVUVIVMgAsioLXXn4Fpwb8NHFxveL733vCFMV+12hH07Q8fOlljo7mzE8fULiCfjew2a4JQWYnaEdSmpAUt6uNhApmXF6pFwzHVFaZvgjT7Av/5478eZlmmL9YhptRHqgcXMikIlFBPWuJw8iuW9H1PednZ5RlKapBP1FWFSjhWROF6il4sUJH6FdbfJfY3uzAGwpjmYaJZj4X/Pf2lsI4kVIZg0rZp0QbYWQkMck7M45xmLi9uOTJ48e8/vIDiqzGfWHqjAJCinz7u+/y6htvMG8bSmuZhp6iqOi6HVXpfkppUMxnc84fzNlud1zdrHh+eUk3bNjsNjx69BpFWdEuWrqhJ0zxsICO04h1DrQihERUicqUVJU4ZobspKmi8MqTInvjB3yY2A1b+s5TuBLvyTMIh7Ua00Y0AR/WJJswrsAYK9CNE1qyqjvKVvjpCUdVSszjbbrEUTFqw5QmSuWwixqtBmLakvRITBbJXddMdkAFUE6sESbfo2xiedLgjGFz2zEMO85PT1BV4GR5wtXlpxigriymWJI4zkEtGiZP9CK6urm+yRYEAreY7CqqrWW+WNC2DS4vXjEneTVNS+EKlvMFTdtK3QPm83kmB/z04w/TuT8E/rOMu2vgr6WU/kul1H8L/DWl1F8BPgL+cn6ovqOU+mvAdxFy87/3s5gy+WtQJvttJ6FuaVViCiVeEaMnoTBtRW1rTHJsNluscyyWJ7jSEQvNNkyorPKLQahY2/WWKePYr776GkZbVje3pKQ4Ol6KxbCrmKbAMEzcrm4ZhoGjoyOaZsZqdctHH36KsQKbXFxc8O677/L2l76MD55Z27Jar3n+/Dlf/sqXMdZwc3PDar1hNpszr2uOFguqzCMHRV3VtG1LTyCoSeh0Pgh+l0RRF0KgrEqMM3gFPkaMsfRdR6sKxnFi1s4oChkW+Skw5kT2uqkPmJ/Rhqqqhb7l/R847zp3uGVVSdhzku13VZZ4v4eJpHBYa3LKEuyVQ/uvf/7sgsePH1O3Je+++z0enp9RtxZnEst5xXLR4IPQM1frHevNLT/+8S0xRTFPsgWFqzi9d8r9h/c5PXuA1RKVWNYt9+4/ZLtaCXZCyoydF9kzcnw+tGHPBgEOpV/lrl7yKlOGgA4WvQ5GHfEqZPpnyhCcdNJ934vopKnlwczKxKIo8KNkqgZjSeQOXBucdRhVkcIEIRJ8lHwBBccnx2JdMY3yPQpRBe8pjCFkwds4sr5Zsbq9Zbvd/vS+Ldf5zXaXE7QClZPHXGsjLojpgNB/4UuFELrd9Fxd3dLUtTQoRE6/dJpfWyL4UkyZsiyxhj7HyPVb8TAvtM2MI+k2p10HeYaktZEiljFoXZb4MZGCUJeHTqGtwVU1UVn6XqHMhCkVySViqRinHh8CrvL4Qqyxo7ekkLAFTEY8P7EGVZf4YWIaJ4rCMQVYtA8p0Wxvt8SQKJqKTZCErsJa+k3P7fUGP40cHx8xbQKrzYrLy0va2Qx3brl3ckphLM+fPePpk2d4oD1agN4z88CgidGzWl9z72hGXMizb4ylGz3dOIm98W7D1dUFMQrjK0TROzhbHH6fzWZUdY02RpqMqvxZZfUPxZb5PeCXfsLHL4E/+1O+5j8C/qN/1mu/8BXi7maFZ2oy9zkQcEVB9GIm5G978AqrRPjgnBht1fOGnU4YU2KUJkxejKQqx7AxpBDotxvsg0eEZAlJ8/TJp6hnMoA8Ob3Hrut5+uwZwQe6oWc+n7NcLqnaik23Zeh7FrMGP4589NHHfO+7v4+2mnfe+RqzWcNu1/H0s09JaWJ5fMxy3tJ3HVXbcrteoa0mhMDTi2ucM9x/6b7caGMkqoC2it2mZ7vd4v0kftF+ZH6ywFiNsxbnCrbXK0JV8PTiGR998D5N03B+/z62KPDKgzFo69CuoOt22ARd79EqYvX+bOeymPnCzrS4QraBU4hc3VyzPBZPe61EIRpVEhGZMYfUqpQSBE8MnsXxMa8uLWocKZPACFoLbm6UeIaYBMYoitJxbGZUVcHxvCUlzzB4Lq83fPzRD/nxj74HKGbtkvsPHzBfHvHn/+JvogBjNWPf4VXBsFkRvDyQISGpPvqOsbDvalNeEIy1aMR0zRrLiCaR5xFJCpsxYkNrcKyGLcM4ibYhRKYQSCHQ7Tr85DFGlL32BezdTxMnZY2ysgieP3iIZkEMim54xpQ8lApfGuqiZbNZM/iRzXZL27ZiBWEtzplDZ7YvxsuzY15G4ZXKEKD+A7uTPdgSNTlnIJKUznklKhuWvTCAPRxCvRzGyDgFxqlHpcTXvvwVgkq4umAIHTNVopPi6kZyQK0zKBLb7Y6UUvauqWkKl4fa4oJZ1hVGa4EcYmK37USBWUlqmnMVxVLl8KiEKQymMCjjqFwlOyMDY+zxXqN0RVkkxnXH+rZjHCasLTlenpDGSLuYYVOgcI6d99zerAgh0HcDs6qhaEqOy5bH7z1m8hOP3niDcezQ2kEITOPA9eVzZs2M1fUtY98xDAP3z8/44Q9/yKsvPWQxW/DJpx/w0Ycfst7uKNsFZvS4UhZnm8TyxDhDWZds1rciWAoTPkyoWUuhHJXSLMISnQLkTObBj+y2Hd5Hog9MQ+Ti+gr/TMgIH3/8EW3b8LOOnwuFagyRME7ouqDvewojbMumqbFO+LOpC0Qf6TYdx8tTdt2OoiiYvGe73TIVoioMIZAmT1NXYkGrNU+ePGGxmPHGl8STIyZJr08hsDg9lZ5OCUShjOb4WChLygg+dnp2j+urK1KMnN075fLyitVqw2zecHNzyzvvfJ2PPvqQx588pq4cR8diTkUS9S1KMQwjVTPj5OSY5xfPUDmWT2nJuSSIw1/btjJ4ceJPMaRR3BinCTP0NPMWg6V2BfO6JiUYx0CKA1VZslgsiTHx4Ycf4pzj+FiwUucKUhgP5zw3YRm+yIlJmYHS9x3VJHYQ2hisjENIPvtZpGyvijjvKa149U+8yl/+37/Fj37nXf7R/+P3Eez3jlMdfODFcqK1yoU0G7A1FVq7g5owxkRShsvLp3zvB9+nHz3n52fcv/+As7P7PHrlS+jk8VPPNHQMXcfoI6617H0SVWb59P1AUorFcpFZRXtqpgKVBHPPE9aYIkElJiJYw3KxIKYkQhTvmcaRvt8Aibqeix2DzlTApsFaQ0wKkyJmCoyrHUE5oe3NG+yipshy/2HXSdOSIT9rrTBMQqDv5VzvLQ5SlqKfnp4SfMLUxed1Ai9WaqUIMQgl0eZ/SHsG0k8eOyulGMaREBTaWGEDpchrb71BcdwQbcLEhPGJq5UkEYXg8WHMi6VQ/sqqZMz+Jz4lbm9vuV3dUlpRnAYfss2Al2dkmFD9KDbH1uYUMoUqNLt+iysVhSnZbWX4bkpDysSA3c2aTz56zLgbOT055uzhEaUzAtukwDQNTGNiM+4y5TkrikNiJHK9XfH4s0+YL5b008h2s8XVNdpHbi6eU5YF987uEULg1k+cnpwAIvKbxomPP37Ms+fP8EGRsFze3FDFwKOXHmWtjpxL55RAKkl2yLfbDbapUH4Ea5i8J06esOmZ1y3LZkZwkemmY9nMsE4SmqqqxvvI5CfGcWSz2f7MuvpzUdxJYG3B2E/0mx3Pb9ciO543tGVL8BP1UYNyhqQU9WzOadMwXxxzcfuEbd+jkEBhlRI+RqZpYr5YMGwGdn0v0/7dlmZ2LCrMFLi5veLk0QMx88kXXmvN0dERPgSstcxmM3F7mya2V9e4suDN117hyZMLnl9f8eTJM1566RFt23BzfU1Vtey2HSFuqcocDKE1226HLUumELndrnl+dYGqC/FDD4K3Nm3D0PUEH2hnM0yhUV7RVBXr3QY/DpRVg+8nugSh2/Lmq2+yuh1Yb66Zxp6joyV9L0W86zqWy3h4EH+izVCm5xksKqlDdzxNAVdUaGcwyhJTwjNird0T6FDaYkyBUYHZq3Pas5Gz186ZnSzQxpGIBIThIYPMkDnDGlKJVgbxfEkIUXjvCSSLYjufc3J8TAqO73zvB1xfXDF1PR++9574lRSOs/MzHj16xPH9l7HWEYL42Y/9iA9e7FVVHiDmbj4lYZpEgCTahBRHfDKMJGyMOGAInmdXlzhXHCwGxkFEO4KJQtu2smNQcHX1hLIsOT87h6IEFzl+6YwYxXIhGk1A6KU+JXo/0TSzQwf+ohFU3+9Tdu6sfF22ca7b6m4onl4YkL/AtJjGkfV2DWrOoo2EKLjvT30Ec/GPefejraXvB/wUqA5bgcTASD2vKWfSTW/Wa8Zx4vj4GJN3Gq4sGaaRoRejrHk7E2OuELPStxCFtlKMmx1ljLSF0HcDmt0ozJRd39MqxWTEDTbgmVKk7waapubxBx/w8eNP+IV3vsbp8RGXl8+AxKOXHrK63VDMa+yswnSBuNux63uKwlG6gt2wY0yKjomHp8dMiK23qFYT1azBKYO2BuMsDx494sH9cz756CMA1ruO0T9lvVnjY8CWBW+89gq2LKTpyY1PROw8rLM0sxm3N7eMKTCbzdhFT8w2B7UrKWcaP4z0vZitnZ0cs7q9YX19xTQFzs8fcny8xC5qoRifHfP3/v5PL6s/F8VdW0MycvO52nJaHh2w3GgTVVOTtGI+a1DLI2rVYtCcnJ1z1V9hc1SMy1ila1uIAeVg0+2YF0JP2mw2lNWCGBPGWMZJVsCiEBKeMfIQHh0dMWXcq8gY6NnZGcPtmpQii+WCWXvE7ju/z831Ld/97nd55513aJqWxUIGjz6nN81mc8qqZLfzolA18Ojll6AymNLm9yIWx5tN7kDHkX7oWZ4uheNnDDoYzpYPaKqaJ8MTEolq1hIyvvrbv/2POT+/x/37DwB52G9ubjg/vy/QiytEqZiPF7s3wfQsIQuf6qoiEXBFKZa/VQVAv+vEsAgFStPMF+jCocfED/8/H/LZx5/SXyTePv0G1pb45BHS38DekkwrYZpozQEmkjchYMFhRpppegp49aVjXn74RwVacqJ2XN2u2GxHnj7+kI/e+yHGWk5Oznj1jbdYLJac3JMQ413XEVJkGoY7rDndNbqaiIqK5A1GGawfUWVkCB6fIovlEqONcIun6dB5WmvEbTBGqqbBWsvR0bEwQaaISZFyjBRag00oMxCBEOUe7cMk3GVkuAa8ENAhO4H9UM0agzWK1WbN0I88/vgT/sjXvynXMd2Nkfe7MaXgzddfp66FocF+/kD63AJwd+73M4dEVZRo02CtQ+mCdj5n6HYkY3GlMDbGYchdfsjUPmkklBIr2wSUZcliPifN2gzDiIhIGCCSr1uWBSoPrG83a8ZuxE8J1VTUxZy2bSSqLmNJw06iKWMUTcyYAt/8xjd4dP+czXqNVoqLiyu63Y5u6Hn0pVewfsYwjVhnmc1nOCe+VHH0DF3Pyf0zqlaGpe1shi4KKCJtUTJmP6GyLKkLmS3sd1IffPAB88WcdtZinBV/nKoSoaEXa2ZxP9WMQa6jD56b9S2bscc7Q72YMUWJ2auamuF2w2q1Yj6bk2JiMZ/le0HCepbLpTDsxhESLBbLn1lXfy6Ku3iFO06OZMJtrT4oCCOAl1Brny9K2y4lYEpJiHbyiXEYUdZI8o3RWG0JReT8/jF68DRVg9VFDjnQVE1DUdVcX9/w6OWX6XY7ylrUgLZwMvk/DOcUTTOjqGu63Zaq0ixPlzx89Ijv/uAHPHl2yWzxKcv5ks1ux/n5GYDMBcqSxdExyljWmx3OWFKhUVqx2e5wtsD7iJ88zhjq4yOiElWeVyPb7ZbZ0RzbKigSpS2xpcPGJDTPmEAZZk1DVVXc3N5wcnJOXTdoxK72/NErMHVsxu4Ooz3s0RPkeffeKXG1WjFMI/NZy+nJnNKJenjyYlCVVLbW1YZEyWJhadtj4hoo92E6CTDic3NQg2bpTGa2pKRQShSjUm0Dh/AOpeTfU8TZkHVLCfBYnSidwS5qlouGsnTEFLm+3fL73/5tttue+fyIV197jfPz+zw4P0cpxXa7pSgrEjBNgRgR/QOeqUyMccAbcRDUaLY3grkbbbi6upKGQ2naWlz9xnFkt93SDUNmtoqCtTp/ANYwKoExTBCGTjSKoCFkT9lZ0zDkhUKk7TnEOSa6rj/AMkopUsjMHK1RTtMNHdqWlK445NveFfnEmy+/zD4UJE5T1gFk8Zj6yQU+KdDOYkyJLUsetjMm3xP9SDICL0pgShL+dVFitZyHLguv5sbijBO4L88hpmkkKNClw2mDUhKk0223WKNxzhIrEQ+t+xWFT9RKqJXd0OOMWDuEKM6KVSM24N/6pW9RBQnLsFbx7NlTMYkzina55PT8HLRiNmvZbHfiHJl3O64Ql0ofPFjNLsguI4y98M6VpmwbdIDaORazlqosaZuSuirZrDdYpzHWMpu3zI+PiNmR3jihbKs83dZa42Y1T6+ueHZ7SVk3mELEdLO2lXuz24lttB9pkuett74MIVAWOVQmwrPnn4FRnN17QFNbeME++ScdPxfFHWTlH/v+4Lq453nv7UL7fkdhHcdHC7SxdH1PjAltDP0wSFB20NSlcNJ9SIQpcHp8zMVnT7m+uRF2iDFUdU011hwfH3N7fcPy+Ejwb6XE3U7r7CEtvg4AhSt49NJL9LstyXtOj0/55jfnHJ+dEYHj5THOSUe6WCwIUVJ9XFmLAAXDNPSiNlOgjKIsGkwybNdr6c6cZgojYxgpW6mSZVvhg2fse3Q0nJSn1E1F6CcM2T7UinWptZZu1xGPIrPZnKPjY66urnn48hvEL4YWqzuJv9YxK/8NlXW887W3mUJgNitZHDXC9AmJqSgoCkPCy8IKuajIAFxzt73ngBLE7EwqgzRFwlmNsUjeJXeURqVkof/8sQ8G4TAFVAeAaS/mSDRlQdM0PMAyjBPX1ze8/6Pv8t3f/10WiyVnZw+4d++Mtm4PD3gMYgyGCpQpUZEIyjJOgc9uroW1lPH5sqpEOlcUpCBQV1EUe6J8prbJa15dXlLXNSd1A0bhjWEvu3IxYUOiSJqn2w0Te497eQaESeLo++FOym4M86Zmt92hneGdX3iHMipMkGSeF8v6Ye0m21IkSOztDMgmZT/hAdxfIyCqlJn6HN6Dz/oBgaZEcGXKkpBkJzP0PZvVGj8Fjo6OJOTGaIZJdqFaZ5+XlFDZ5yZmXH5/XrfrDe285eTePXbTeJczgMyixlGYPqMXa+NF1XDkahSRrhdqakqJB/cfcHR+yvL4mJv+ltVqzbNnz0kpMZ/PcdZKOluCdrHAFo5d3+XgEWn+GCRBbJEhJdKdS+deuOWcEb5/NknTVuNTInhxlUwp4ZzFk9Akrm6uKeuKV994jXaxAKPz/EEYc4WzNG3LZ0+f8dZbX2WzvTwkM93erqjrht4PPLj/CtfXlywXxz+zpv5cFPcYpFtUSfjGUx/YrTthPgDzmWK1ueSkXbLdRjbjmtB50umrTDFRtTPK6Jm8lxXVWuqmxmpL2k0olZjCSLdbMU0PCUHCnYuiZJcXCWMNs9mcyfu8sAhkEjNWKfiqeIlvVmtuVitG73n+9DM+ffKMN9/4MtfXl7hS8dJLD5jP55S2pFcabTQx33h1O6Mb1iznc0JITH1PVZVoLZfCOgVOUdYl2inCJPmqhSto20Yi8XqPNXN8v8Nqw/FyzqOXXub65go/RWJQ3H/wgKZtuV2tD9v+z0Exn/uzdHY6gVWat998kM0aE3u3RCxQFuSqKItDHGRw1Q+E6POr3mHE0oXrg+AJwJpEZTOrVqXDuzoAB3v1nVa5E8qUx2TuOs4X3vyd3a+IhlIYMClyPG+YtxWjn7i92fDxB+/yo3e/y2xxzC/8wtcpbCm7AjQhphyYnuj8yOVuw6ATddMwDENmsMiQ3xpDU+fEnWlkmjzT5Nmu16ToeXB+LrvG6NkMPa0rsUmGkfu37xWs/YDX5Og0ob+BGFSFIP7eew99BQzZWTB4T5+gMRWgspbhhcFq7tZT2jNjcoC2yT786vNXHpWyrYycP+VHVBpQ2hCJsvAVpbCiklh7FJVABcM0oRDH1Jgi7awV4ddqhe0MhZM5VlVUxIgU6txEhSC2t1qpu8GjLSick4xjV+QAnp66rA5CwpRE4BdjRKVEn1ktq9UtWmteeeUVTk+OmJ8sGOOUcfaCl19++bBQxhBkxxMTbTUjRbEY3u12dF2PsZZ7y2MKpRmHnnHXUxeOy4sb1psNu92Oqp5RVQ0fffgRD196RGEd22kQLQeIt1K+HtF7rtZrbm5Xkt/a9XjAh0jTNtS12K/crm5l52RtNh0bQQle75xAy0dtSztv+PCD79Nth59ZV38uijsk2raRzsZZlDKyqvusIK1qGl/jdWIdOnTSDH2kz4OXruvpdxuZpudszClOOGvRTUEzn9HFNTF5YgRjCo6Pz5jPj1gu7x0w9pgiu13P+++/T1lWHB+fcH19TQiyA0gKbm9vmMbuIBWetQ2FtUx+out7nl9e0/dblosjXn3pFfzgOTs7YzuJtecnzz5l60fcoqQsSqx2VE2N1U68o8PEvGrRToZvo4Fu3LJeramLhrmJPHl6wXwW+MZXv4JJhs3mmRSicWDoRq4uLjg7O+Pk9BRtDMOwwvHTpQbScXMo5DLC2OPfX4BxkEFYBMLYg7KEsRdLATJWrvZ/UnnIlv8tDzT3QqTD1f8cLy8dPraXy0OZGe05kOELqMK+uwx+ot/1eadgKMqC0joWD1vMK4YQFc3ylPP797m5ugWn2TAxqcgQc0pS8uiqYGGazBWPByOyvWJUOwNjoq3nDP1AMcl9urq5Yrvd8uj8gVj2KkilZUB2RipIAY1KYcqKxluij/TZOtg5UWeHELHW0jSNwBEh4PNC4QJ0OjFaRWEMU1Jor9BeIuFkR2awxhGCdLpqf35Tzl5Nd+daHRYGWZCHbotSvQyelSY5jW1K8IFxCnTjwDCJDUCKQdw2rT04cGpt80IV6XYSZCjwjHTqKUactYf7RSOzNW88CtisNyzLgm6cpKBVBUPfH8zVxmkijgPOOrZTR9eLv0/TNBy9dSyOsYuaySn6OBGIbNYbiqKUrt3JczaOoyykWmGdZdxuKcuS2UzsIAjSjqw3G0ptuby85OLiOZvNCmssfd8BipPTE+6dn7MHSGw2fkvpbscZQ6AfR4FpiyqrcOe5iMv7L4qCWd3w9OrTbGdhs1+Npq4rSJqmmbHtdjhnOTm5x27T/dRnGn5OintK0JQ1ppAtyDh4iuxVXFc1s6KlLCS2y1SO6BVJb/n0+ackIw50RekkjsoWlGUlWhciWkWMUZzcO6GqW7TRTEPPiIgxLi4u+PjjD7l3dsryaM6Tzz4BpXj5pZdJKbC6vRXTn2MlrAgQcZGWzMjlcs6rr7/CBx8+ZrfdMQw9F9Gjo6J+80sieCgs7bwl6MBxfcLLX3/I9vlTpoQsVGPPdtuJvXCCWWpwk0NrQ9OI4GF2MqOpZxAVaVZwsbvk3cfv8fW33pEhlXHUzYymUQzdwOXVJS+/+hpaGz768GNeeXj2088/BpQhpQmUwZMgm33tUZKUcRajsoYzpdzViq/1HZ+cw96/qcRxc7vb4b2oh1My+KDk2iCe3Cj/B+l5iTxI08LPJiIWw/tK9YUOVKaCeYegSATGoT8wZErdkJQoAZW2JK2IOuJToAsJHcX+WWuHzruQsRvYrDfsYwFTEvXt7mbNZruVkGWtef7sOVZrmrolodjtOk7bhUSjjYGpMAQtg3G0xvcybO92HZvNlr7vqKuasixomjo3OIJXp+xbYpxjigljCsoIRXKopAQLd4kYBIPVUayAXVmSur3NrwxStVKUTnxZMpc1w0UvFHitsM7JEDB/1KeAKixWK+rsJzP0HZP3LJYPZTCqclyjLWQuE8XvJiXpiiUQR8yv9guxZOkWmZqaoCxZ3nMorSlqCc7wwdPM5xgt+hWXWUPkQXLZNBirqF1B9AFrNVP0jB7Ww5aLywumccKYTsz96prV7YoUIqen9zhaHmGN5t75GdMgdEitNLoopLsmosLE1A08ff6MfruVnOTJs91umC3FEsEHuWe0kSwFFTkI6QKKYZDFsV44jk+OcWVBt+uk0LdCOQ7jxPLsHsbeEKLYlBdVS90saJpJrk9bME6Rsi5QX4Rav3D8XBR3rRTaOkKcDhDCkIc0VntMUXG1fs58NqMMgUKXHJ3OOF2c8OnlJzSzFp0ifvTs1p1Y8rbysKhCUTYVpXGUTcO27/joow959bVXODk5ZrO55eZ2R9O8hJ9ElXh7c8vRcskwjmx3G4p8w3a7TjjJVSX+z2VJ1++o53NuVisKZ9jtjAx/x4nNZsVs3jAMHSF5Lm+uSBrcZzWFaUgEAolhmkApjLOUjcMunBQ7lViPG3wIlKUMtLq+Qxeak6NTOj/y5PoZysq0XoLCa6ZqZBhHVrcrjLEM40A/DJhDE36XdJSSYrXest2NlG1B1w/897/7uzRFiVIwn8/o+p6mneGnieP5gkcPH6AYICqiEhaGRhGV4XbVE0Li9GSJdcJjBw7c823XsdrsGMeBtix46f755+v0C4eEVkd2u5GPP32MVoE333gthyFndenhk1X2juFQ4GUNikQUfYDtbstZlOGmyiZdRXL4cQAiYZScVlcorro1u75HaU3XCctov63fUwr7rsdPAi3E7JVe1Q3dMLJ1PXNXcP3shhBbgoooE1geL7jd3NJNvdg2G0NRVoQQZO405sD0jJMrpQ7GZNZYvv/hj3n62VP+5K/9Kk1V0laOGCahLyK7MJ8073/wAYvlktIVOC3wDgq6rqdu7ozhXpytKiVQwTgMrHcdu2Fgee9EgphTZJw8650sRuKr49juOoZRIKOYwzQknSoeYE2BtO6e9T2DJ0bZtVRlRV0UhKEnKU10YqGAEorw5D3JGBkOI1YPRsscw5tENW9ojeO7v/8djs7vcdzeE/WqMTx4cB+tJMN2GAaGoefs7OzgQDqO4rBotCH5hLXie+Mzk0kpxABt7KmbCqsVt+styhqKuuT47BQfJsYQZJ4QxPIj855ICZ4/f8677/6Isim5d3YPWzhhwFhhTnVdL5RpBUVbUwfPFAJF1bDtBpzT3Nw8hwjbYYD7BX3fsV3/T6Fzjwm/7qQ7i1Gc4boJq2Ws4yefeb+JKTVUVWLRzFjMZjzbOaaxp98O3FzfQFLUObbqLrJMYY3Yjbrs5rfbbambmiozZLquo21b2rbl8ePHXD5/jnMiqkp1y9j3TNPEMPQUThSYPgddj2PHvdNTVrbg+OSEoetZXV+LTWzwLGZz2uMF7XKBXUjgcIw+D2oUxmq0kZveFkbMkKyS7miCzWoLyzmzVrzSy1SirdA3Q4g5tEEecFFLKrp+4OOPP6Kqa5rlDF1YyWb8wqEUpCidsYoQvef6+hp7ckQKgdmsZpoGui57rviBvWnTYX+f4+SmceTH771L13X8yi//Ost5xd0UVAatKUZClDnIXZTeTzsiMQW6YeQHP/gRhVO8/tqrYF6EbOBQ0r/A9JPPyf/q4ebyBu+FETSNIzkNDasdqEA/ebrQMyWBUoq6ImUL6r1yVJwpTR6sjcLo6HvGYWC+WOCDp20avFaMGq52W64vb4kxcnZ/QbWo0YUV/UaM6BBw2VVRvsdeYStMmWnyhwxbrTUPXnkAVmFKi7ZaovyCLFZ7ykyKkR//+H2++rV3JEKxcOKmKv7Oss/5IrSV/5PCFuk3W548fU5Z1iyLI3z26tnnf4YsutNGAk9sVmB7H9jtOnbbHcvlUrrSzJrZ70wJcW/Of2DbWKWxVYEn0m2F1VU3jQjItuK5tBcl7rZbyqrKA2153vvrW3wK6MIRtMIhYidKYdr0Y48Pon2YzxY4LYlMWsmQeLftSCoJM2ecsrpb0W3WMHqmcYCkuL1dc7ta8+ilR5ycnFCX8j7CMOBDEHW8EarwXiF8fHrC17/xDkVVYpxmGkdsplb2Qy+Gat5TlyWls9j5AlsWXD5bE32gLEUDtFwsAcPyaMHYXzCb/XPwc/8XfSggdgOj94zjhHNFjtWa8ClQny4oqxplsym+VUSnCFoRdSKqyJQm5vMZ2mRrYGQ764qS4MTrQ2esN8TAe++9R0wRH2TQuV6vqapK/Buqio8/+oiXHj6iLEqcMQQvPHVtFH3XMW9bGcxqw6KRYr/dCMbYNC2Xzy947/0PuLq64Pz0Hg/Uy5iZ+EJMmXpotCV4n3FkBTHR7QbMIDOD7WbD2I10O4naKnXFfHksjJL9hJ5MlzMGpzWb7RZnLWUp8JSxlqKV8F0/vYh930EbWsvkX2lNJDGMHqMdzhY4W9DUDTGK/YBRWcmaB677PlkGeQnrDDPdSJreCzi6s06CMFDCJ3f6YJD2045EzCZnwvxQGARY3u8GyAU+wzdf8EzZsz1A1Mfj2KGULKTaaIKSncugE0HDVCsoHB7kQUwFKQasIUMzhuAFgxdceT/81RRVxTiJkrjvOl555RUmrXjw+sscPxi5vr7m5GyBqw1WzbId7ohSmiEMVHWNteawXu3TgPZwxr44Lo8WnJwcU+YM0iEGNBZiOCxWQM4nFcphIp/nDCvKCqj5/MIqi9cUQBtP1TQc3z+hnBdEF8WVMmi61ZCFaJJchjJi7mX0oVs3RsLsp9Gj5zq7oeoD5h5y/J/NDpIpSZi7dg4NuLLIanFDmiaBYV4Qee1DTRICBaWkuL6+ZT5fUGhDayq00ax3G8I0obXidrVDl5J/8PzZc/zoWSwWNE2FRhPGROmKw/Dc6AlnLMxn3D6/ZLvdsbm55fLZpfi2591WSEK4CCGyN6vTewp1nj0prZkvF7ITswplZEcSU5QowqrE2EL8q7TMLYwz9P3AsNvhq4pu29F3PSqHAz199pTjxU+HWuHnpLgnBaosKIwBpQm9sBiqosaUlqauiW5OWTiUFe9vnTRKJQyGOARhz2Q/k6Is0GZvEKWwhSMEcK7Eh8TlxQVDv2O7WqOtPQzMqlKUfw/u36ebzTk6EopkSopxGilKyQt1VSEXIemMGzpSEhhovdkwjSMJUdgZqzg/O2e32zGfN6Akt5UYGYdRtn8JxmFgebygnVeCdY8JpRrSvOVUn0JMFGUhRWHXMwKlK6GBYRyEehkGrDEZAxV+uXGWKX7e8fuLhzYGk4rDoDME8DmRXRmLKyomLxF7xgrWt+/8YoyHwZFKUJYuQ2spu7Pn7e8k1LIMzqI1hwf0px0x46ohSlJO8FFsAiBvOe6+Wuko8Wv5AdvH6+0/I0YZxkmQSkJpxRgDXkEy8hOMk2caRo6XS26njQS3G33oSodhpHCilQhBYMNpmmhy8dq7+U3TxNX1Nef3zkgpYmrHaXtOWRUCiXkRV91c3xwGxxJSY6ibipTI4RAyAN0X9q7rDn8+Xx5TuAK0QZWKFECHhAqy4PoYCTGhozhLxigJZOawGH/uCSSpmHc1Yvtgy5Lu8jl9P2FcgQ+BXd+x7cRDRmthGWlj6DpJFhrHkRgFw6/rRiyBu/5wTcqyZBgGQPD/7a4//PyFk6SlqqpEDTxN9NutsG2qKidoQVVWwpYJQRZTrelixFvNk8cXLObH6DFhjeLIzXh+ccGzm0uuhx0DIi5ES6jGNE1Mk2XWzmgqCe2Zhom4N4YzhqJy9H3H7fU1q82GwXvO7t+XwI75HGXE8RJFzqXdNxORFPf3Y37O9t1OEIirHyQ+sK5raUq5g0y11swWczarW1QvorC+H4hpgBQoi0pCvX/G8XNR3GVOn/DZDL8oZAVXSnBRazRFl7BKocaEn0bcWGCWit1Nh5ois7ohRKGn7UKgLMQzORoNRmV1mWMaoalKwrSjbWrOzh9ytbrg9vqaME20dc0rL70sW6Wy4PbmFqUM3TBgi4KirkF7bOnAJ7EMGIVnf3y84Ob2RmYFhaNMYjfw5PkzbF1wlMB6YQh4H1FJyeBYa9KspFiWxDjh/URIHnSScI5CFquyctigUD5RoCmSKCFHFUFDPXOUhSx21pVMPpGspqwKDoD7547MvtYiXpGLIQVqs+s4Pj0SFz+VMCrKNcm82xx8l8t3yNcRXOlQPvOlk3hjy2A05oGnODJaJ11MVOlzqUBSr3NKTZLPHyePD0Ip85NcW3n9PaMnM3TU/jVeYOIgy0yIgdELJzxlWmKZDHUM2GgISrG6vuX25hqHZt1tCFGoav0QIQrs9OnNZ1nU1jBmD/y2bQ4QYEqJ1Ajz6/b2lg8/+JDV7RptNL/0S9+imdWst1tM4WhnLYQ7e1elFLvdTqA2pdntugzNTDngwR4UksF7YlQ4pXJ8nmBSKaUDLr3reypV0NYSqxgnj3UcoKr9NVPqDtbSSoSAxCCwj9UkDTEhM6EkauU9PBNjZLsZWK3XrFcrnC04Pj6maqqDpcf+GIYB54TNFkLAOimoCp0zbo340iD6EqM0LkNTkw8EJVJ+o+5mEcK3LyhPjjgdPeVM6L9HiwVd13F7dYPThocn9whpxCZojo6YnOwkjBa7gaijONNajQpCJx2iDICbowX3YmSKgaPTe5wuT2jaBpcXep+bGSEiiXo25ZN8pyXJO6VIVth6Cis7CRUjKQ4MU8yUUMvkBxnYO8N2Lffi3uKhsGIbXZr/8Za//8KPlBJp8OiUxBZUICt0Eo+RQhkmZVF9IoaEjhqvEnFUmFHTbyQUua0bbFFgjaW2jouLK8kyNJrC2EMh0ErRNg27zQbOIvN2xvXFBcFP6KqUm7MW7wx9tERrw24rYRd7CCWllINzDddXNxTOcrSY89Kjhzx9+oz1Blxpsw9Gw2effsZ2u+Ot19/k/v1zhqC4Wd+Km51zBEnewlhFUdRYFxnSxDRErq+uQE3Ek4jRjrHvUNrge8/UnhK9ZhoGdJXowg7UjBSFM22tokw1LkRedBbZMxlk5yiddAqSZVrXNZOfKAtRApZVcfAr3yeuJyzoImd6irNiNHB8+ijDKY71Nnv+5HxKYa6AseYAQXyxj3wxY2m/Xd9uR0LUeD8xDiNte2d1ehBNIbMVtHjVSGjHvouCED3ej9ypNJV4j0fFpMSC180rKjWjD6NECGaRUsq2DMMwcHlxlYV1NgtPigNNUqiM6lDklYLTs1Mgcf/8DFtYxuBRRnYdNgtfdPY0ku53gATjeMeUkcJusNaJJkIpCfVQmugTeFl4dUyHYbFWWqyBFaQ237P7+Uc+1Of/ByiUtWhjaZqCN49mghZGT2nEEdQVkkm83WxIKTENIxcXFwIj5ULe9z1F3qVorQ85pHKtQlatyvzHOYfRosINMWKVwSotlthZZn86X1CUFRdX16yvV8ybhpPFkhMncOHQ79htex6ennM8X/Cjd99lt9pIMI91pOAZr7a4xtAua9wQaaNht8u5AUpRLxcY61BBmobJj8QQ0UaM8uazGfXbX4IhonzOdLWGcEi6yrdglJYnKaEZSMfdHxbwopBnqbIVlbFsVmtcIWyiq+cXzI6O0S4ydjsZlCcxY6sqCctpXIXCMp8tiOF/Ap27MO8ixspAUFzfJHuxto5aa8qqZehHlFP4MaFDJE4DbZItS7ftqK2lthqrNSZGbLScJEscJowfiFMHccasqtmNkfXmlq7bslwec7Q4YrO+Yj6fE4mCWReWpi4JPjIOPTqLSp5fPsdqxfHxGbvNlnmAq7Dj5OyU0+MT/DhCEgpmnE2cn59ze3tD4QzWRFLomVUlOjV0pgOl2PY9+nmUNJZ5xeQjaQw8XV/mDrIUG11jKOcNWgnLZvCB7WbH5dUl5809bA1FEzCTxSaH73tC3X7ex4UXHnGV8WQjD5c4Eu7Ybr10jtbQNAJbeR+ysCxv/TNDJqEyXTFRVbPDNe1HQCWc0hgV8/cUCb+xhrxv/dx0T73w/32BPDpp+ea3vkIcxjzMfOHn2M8PkuStJlURc3OwP/w0EVPiwYOHBwaHj4H1NBAM7BCBDpVm5ubSZWlRU479wNgPPH/2nN12Bwn85BmHkUpVtMsGrdWB2TJNE/O2ISHdcjNrefXN1yQIzvu8/miclXlJUhqfaYPjONLMZrn4bQ8zCfEGMgzDQAiGqm3xKjCqRHTiPx5DgjGgg9BV/+iv/hExhFMWQ7aDSHeq5J9MUVLijZKpfEpncC3PVyQrYaIfhI0Vx4kYAidHR3cDZ2WY/ETfi311WZaSh5wXvhCmO11CEKdQoX0GhjBRuoraWVAQCbRNxe36KeVouHjyhGkYmen7jG4S/rcxbG8vaKuC5G/5/re/zwfvf8o3vvE1Eh6tNYvlMc8vLrBac/HsKYvqhOiF9rhcHgk0tO4ZwgZQ1FWDGjybzYZ+GNhsb1hvdiyXxywXC5q6QWsIw8DZg/ts+h27YRQ2lVJEDSn5bCPRHe7laRLh1j4ec5u1Ajc3O8ZhZFqt6YKjPp7juy2b6xXdZsdi3uC0YbfeYLVlu14xny2E6vszjp+L4q4Axojxkfl8JiIDPzGGiUIZ+mmLGrbUMWGjks5PgfIT0/MnzBYOrRNHDKhO+tNoFQUWvdtQGUMcYXt1ySaMME28en9ODDuq+Az6W+7PB0JT0KhPcX4fJhxFkKArZu0tRt1yMve8USe03eH8h5THPfW9is5rSnuLbRLTIqG4J1RiPaF0A+y33lfAFSoUnLgB5pHRK55whveRcdUx3u4wToOKnDYt9WKOKzRN2RK7iTRFoklU8xm6tGg7Uc5qnnz2jFM9Y3KBZQ2XF5ecnJxijcKoxMSenZJLqDr0tvkvmZ7WiQ/H06dPmc0agU1iQifysFralH3cWUqickxRfNvlEDhGawVG+nH5zplPnbNc/wD+q+4wg5TEr+X+vYoHpw/EhCzJ0Pcng0yRqGwewmajLBI+iqi2aebsvVv6cWRA9K8GwUP3EGZdlPgYubm94bPPPmMcJ4ZMi2xn1QFLdc6JlXPOnO26LocsiEFVSOnwE9qQKDF4owQqDIFhHPByapmmidubW9qmwWjDer2mruuDFXBKguXvhU3aitpTA17LEC+FvTc9VKWwWCChkhfIIO6laXsY7EXGU6YaxUgIgqXjNBgL2hNzglWKYhFdFCXKFdm62eT35wnZNMsag9H7IavcEwIrZTuDSRaAEAbRkaTI7dVnnCxLYqUIcSJGuPxkZHv7GculotIwXxZ020+5uRqYzSu2m4mydqQo3z/ZxKPXNMn9kL6PlKXl8bMfUlTgmdEPhtJdg96hak90LT5I+DWpxU+KMW4ZxoApNU0BU9hR1YpmtmKatgROSLQkXfDx44/QNkmeACU3qzV1WUtDFMSOvCprXGEJfiRGi7GamBIyP41M6x0pRpaLiiFMpBRY396w221JMVKWFdaI4dnQ93jvca4kTP8T6NxVjKghotVE07Z4rXFJgzKUWqGngMo4tImaECIezbTdME6d+FsrSxg7lNpP4DWVEpOiXT8SNjsRmZRLmEYKBUl1pF2g2wbm9hplZpRxR4qSiG50IASLsTOKdANo0hhprGKIE42rqLUmMWJMwOhImlaktBasMTgSGm1G/CA3ccKS8jMDBdbdwwZPmgRO0D4Q/MSUEgGoRkvZK1TfEXaWGBTHpqHb9rTNDD1GtEo8PD9nDBPbYYefIqt+hTXi4a7oUVgOkMTh/1IiyyLKEE/DvG3587/xp0haUxYF8/lMHPOKEgU5x1GKtTERjcPHgMpClKT2WI8UC43YMJOFM1VpKEsR6ST2fPVwEGR8DiVISiCG/C8q7bFlmdLow+qUQIkcXbjWhsAev1fE7MSosnpTaTEsK9BYEkFlvn4QiqTSjpvbW67XKxkim8hsvjjg3SDFfbPbUMWKbSfukG3bslwu6ccBxgFbWNlyA6O6K/QpRPw0MgYPWjH2njAFnHGMvbgtlmV5GK6FIFbIZVkzjp5x3FFowa7rusIYjSeia4dPOSAlJHQSSIGQMNGio94vrXezCqSrD0I4whpDra0s9El2c/000Y0yPN51wkUvCofRWhhu2y0pSqeqlGQgKMgRcpqisNLp5q79IMzK72WfE3D//us4B0oHCqeISeOaCde0FGqDDiu6ncAtQz8RYw+pYred0DZIRB9g0sR6t6Vwjn6E3Q6KVrHtEsPUMvkbQGBWib0TvFxHCxqG4ZLRjzR5cFtUEaXBujGTK7ZYSgKJfhfRasvNauTjxxW7KVIV4oi53axJaaKu4JWXz7GFQ5U1RlUSGo+ncCNKrWkX0BQDm2cB9IiaWlTOGqiqWthqRYEPUaAch1Auf8bxhy7uOWbvHwOfpJT+klLqBPh/A68DHwD/65TSdf7c/xD4K0AA/g8ppf/6Z7121JriqEIpy6UaKI2hVhaVNLNkaHAkxEAoKenKiXBxeUlVllgUTsuQMgTB6YzWzNsZt9st3ie096QYsUZxvVrz49+LSBkYWbY1f/yX3saWNaevvIG1C559+i7RdzgKjGuBATCYKQoNMcJiNlIW4pQ4TZ6Jgu34FiY/REJhsATjGLYT49RTzSqUUkTjaOoZSTkaq0irb2MLQ3va0A8dQ98R/EhqLB070jRSGkPYKcKwYxx6prpjZW7YdiOJHuOMdPJoiJG2lcT19XrDvKo/R38kd91KaaxM1VAaKqd47aX77M3AUt6OZxtOZIEQZkpVOJRJDMMEOhyWjaQUJLlexqrMcgESOKPuREjo3On/lJv0gL/sR+6CJysE14xf6PwTiRh8bl4P25LDV8u2+W5oO6rEmCYZByfZEU7K8Wy3wiMF1jlHCNVBXl+UBSQOnu6QB2QxMI4DV5eXh6GhmxyFl6GY1vqA32prMLbG5W7TKMekxuwKCU2GMLTWMjj1nqTUweemqWvB/LXGaY0R/IS98Z1JCpPkfWW6F3tZgCuKfD7i5866IGNBYCMlHupTtvPRSmO8RllHuSgYfWA+m2OMZvIjQzb8GydRUcosQmYQphBNgDUWoxTBhzzDWuHHiaPFEqMVZdnw5OkT9NxRNKUUtpi4+Owz4vSEuvA4C1NIOFNJklEUllHd3qOe1ag0YXXJZAPoDqtFNzNN18T9MwloXeLcEQmB+WJIWKfpdwatC5KqBBo2MPUjrqgzFbZE4YlxB2wFKhkDmIhKgXbe0NgjCltRmhkXz77NbO5580sRZz9kd+vQXjHhGLYw+hHaiX6r0LoiDDu6rSUee64uNoRkqKo5IUqm7snpCZtNx9Onzzk9XZL7jJ96/A/p3P+PwPeARf77fwD8rZTSX1VK/Qf57/++Uuod4N8Cvo4EZP9NpdSXf1aOqkqRUkca4xh1wmqx/C1zhzgiOCLKykSfiK5rwhbauiKGTgZmKGLwjP0gnGxj8kRdBD+RRDcNxMZS6bttqW3h2s4wSlMGWSgusGg1ozFLmdAbjYqKoCUsOxL5rJswA1SlxVjFNCmmHNdGEs5vilDZmmQVH3z8CclG6oVFFRF9A4vZMVfbCzozEWKknDYkB6pQFEpk8sMIaRSp/DAGnNFEDde3NywWR5wen/D84lMuri4x2nB0dMRyMUMrxe31islPOG2EWaHU5wQsB5DmxW55Xxhz53vHjc79fsZtx74jHfjlkZQhE0k3grppsCax2/pMxdxrKPd9o3Smaj8M/cKRkEDtFA2kkNWuGdxR6vOFPQkjoa2k5Id0F1E3JilYe9zYaoszlkJpJqXRKRJCxFlDUpbxhdcWap5AIjFKmHki0s4FrhrHUfz3+4ntdkvTNBjbUBbSUZdFJbuClFBJi9AlG2aNwyjivMTn6KXTMNJlyuHeibCdz/GZLrndbvGFY1k1qFH+Xc6s+GUmBbZuGXY97GGzJF5NWmlMafcRKZ+bvaT8vXfbDVfbDcppzs/PsM5QZiFUDImu26KqBoKwtdj2tIs589mcXT+gtKJxBWXhqOqKD97/kLN7D2it5dnzJ7zy8mts4oqvfu0r+G6k61ZoW/Lx++/z9W++TRi3dNPEOO24vLqhbBtM2RIM8vwlw9WoODmaM+xGlFkwjonaOXwoJAO4OSIZC1ExqZEhQkglSWl2vmZWHeHTDVN0zBrhi+t6IEWFn0Z83LHr1/S9pS4NVb3AulPZ7QePsQmtZoT4lDEKm+Xo5CHHD79KU1bcXN4Q379L+4ooxtFTWUfwG8mFxWONYQoKVGAcI2On2axGPvx0y5e/+jWK0rIad5TOset2rLYbfu/3v8dXvvol3v7Ko59WUoE/ZHFXSr0M/KtILur/KX/4Xwd+I//5PwP+NvDv54//v1JKA/C+UupHwK8B/+3P+h6ByC5GbJTCVRhLcYADFYQoz78SFZ1YdYjayyTpbFJ2zfN+QhnF0PfoKN1q0LDrdoRiydGbxyi7t0oV171n24+JKnE5PKUuzlmvH9PoE+au4mihaV3NOA70Y+TqemS36yS1RilO5op7p5UMm7qJGEA8yyGGxGY3UTQ1r731Fk+ffsrVk0tUG2mOCuqU2IURak1hCjTm4IZJEhOpNE6EccRQUdqClEZi0pTljK4bmcYrVqsVKSZOTk84O72HdUUejgpWXBQFaRIXuc/h3CkxjCF3Byp3iJ4pREIQM7WYYQHvPcvFQnj0orbPcIfGKMVq2/ODH7/PFDxvvvEl3pq1WK0OA1iIdP3AMHqsEdhHIJo/gLxDfu1EpjzmxcXs5wW5I31x+GpUosr2lsoEgZAS9DqJ8yMKm5EKpaBMirkSp0ufB8qfbCWAOoWE0YZ+kEDszWYjWPetyh7kjtlsniEeYRhB1gxoTZgmYhQhinECBe26juA9hZK8AW0ddi4h4BqdC7BE+WkljpSFlS7eZNGQzYI1VMI7zWCEQKDUfrgMgcTW7/CTJ/lI4xw6JELYs4i+wFD6wmIfEdqxVRYTILm9WCihvGe33nDv+FTMOkMgThOh22JdTWnFlGsYNfiSwkV0Gnn5wUOO6pqP33uPd975GljLV7/6NX78g3dRrcZ4xfnZGadHD8ElukGsGC7LfM7MAusCwQQmHwnK4to5w7DGEyhMwRAN22HHrt/hFqegFFOcSGULVYNRlu56hZtX7FQE3QKGyQ/E0LPPF1gHR3IVphIleDCG0Vq6sUdp2fHrYCApNklhywXe73BGPPnLqsKYOz+kvq8xOqFtZL0JBOXw0TIMW0ynuV1LZize4D3sdpFnzy959OqGP/3Hfj0THSZC8Nzc3HJ8/oDl8YwHL81/Vkn9Q3fu/zfg/wK8+Gr3U0qf5QfrM6XUef74S8A/euHzHuePfe5QSv27wL8LUBWW2S5Q1ZUMMANM0eOJGA0hBiwRFYWOZ2LCjwNjamk0lGjIwca7ccoDQME1vZUwiDSDqTJs1ytoIkaJB4TeP+kgRkwhQpjQyaLVgqQM/RgoKxgjXN/2bHYj3oPOIQKf7DZsx4Hz8yU3uxXRB/zoiVE6raqsGYyimDecv/Y65eyIq8+esH58y+yNgDO1QEnkaXtW+qWkiCkQk/CTv//9d9ndjvzqL7+DQbPr1rTNjPXtmmdPn1FUlrfeeJ2h77i5usZZ4UivtjuOm5bKmS/IzuXn7gZPRGG1YkqJH/z4PS6vrqSbLSV4wTrH0O34xjtf515tD532SMAq0CrRTxM//NF7TH7iwf3XONgRHhSxSPhySPgkNsBlKarTn1TeE9BPAzfPbwkhUTnDbNYwb1sOWqb9LwU+JHbTeIAolNZ5uCo8/gFRM8esIVgrn3cPkWGa8D7QB4+zBabQB4vdEATiimI3mb3bNX3X07YtIYnAzZVLSFBqwZy7SYKvrbN5MOqkabES1GAV9Js1wzBwsjxGJ0MwUDjDOExoBQaNswU4yYZNKQkbSEFZVPgYCMbiEqCyFbOPfPKjj7i+WHG0OOK1Rw+yzCHzi3OUirrr29ln6VqjKYrETMl9q1H0U8eAh5SIybPza6bUQRYbDd2WtqkZuzVD7PKi75i6DavxM7bdjr/1D/4GZ2cLjCn4h7/zt9j2I+l7HaofOf1kzeblI0geAxTNDO0Vi2bGerbmarXh1Xtv4kp9KHJHxQlV4+iejxQ01K4ipcAmdEQvO8EYIBLxUZFiSUA8Y0JAMhUweYc9yrnJDJ1x7AUWMy3Kyg5zTDpXS0dSe9pAJNiKqm3ZDYq4vuX6+p9yU50zhQ1F4QnBcP/0VzBG896HP6B3UM0rnJoom3NCHTDVLcksaOcn2MryC9/4VX7x1yxvvfVlXn/9S4IaqCRCsu0W7/fq2pr/+3/8n/+EJ0eOf2ZxV0r9JeBZSum3lVK/8c/6fH4ygPoHnt2U0n8K/KcAi3mTVk6xDiMkjdIJh6KO4GxB3TSEYQ1BusjgA2NMDKmgNRIRp4yM3SQtxzCOgaq04vHdOqZjR20dD04e8Hy7A6Rzj5kyp4GsqSeohHE11tSA4Jghyq8f/uhH/Pi9jzHG8eD+Iz744AOGoedX/+jXqWvDbN6yvt2S8BR1i7aGdnFMapY8HT3ry44Y53Bk2T1JfPzuR9gyYWzEWSdKzqxkEx6tmKmpGHFTIHY9Tx8/k5U+34jaWN58/Q2KyrLdbBg68TxJRclms6MsW9L+B727rlJwlcQctu2cOA0M24GjkxPqtqGuGjarNUkpbCX8em0tgmjn9yjNifB674gugumqu1th70eSgHbWUBSW5PfF9W6B/cI9QiIx+Ykf/vA9zk5PuH9+j7Zt/8Dn7G+ylBcdMR3zeUqg2HUDKUF/MlDUUaIQQxCb+LzrM87SGKHjhikeGBgxCPtDxDRCr3PWojNvua5mAtcI9I1GYwPMU81qtWIcPKPvcG3FOA50k+fkaIlG8fy9T/nk8af8iV//4xSFZbVZo50T24tSuP1nsznjMPHjjz+CPIzU2mLOz6lnFdom0YXE7PnjPdOqZ7eZOJ7ru/FpuvPL/+JjqpWWIXQUz5zNtsNoi7GOZTsjaHn2xmHgZLnAFbJ2RwXWJaIPmEJhlCYkGdDu0bagEpNP+CkRpoHLqwuigx9+uKLejbz0T274tj7n5KUlMe14/vwal6AyLU05Z2xLSX0yBmcKtFIczU8wSrN6OnC0POH03inBex4te9arGzbbG45OjrhZr3jerSlsiVUJo+2Bi06+k/fw4/7OFTy/gOhApZw8lic5BzaX/H233YliPSmeXT7FTgXHx0ti6kkpcHR0IkHqxqCMJQaPo+LtL73FrC55erPjKy/PuP/gJU5PTpjPlpTlDG2ceLzfXLPZbNhtu2wgWLJcLvFTkkXsZxx/mM79TwD/c6XUbwIVsFBK/T+Bp0qph7lrfwg8y5//GHjlha9/Gfj0Z32DFCN6N1IrBTHIAIqEA9p6ztH5a3x2cUEcPTEK9vmDxxc8Xn3Ka8uKr792P7M4FLaoCVi8CnQoTNuSjhqCiex6TxxvqYsSUyhUNtRXSWG0Frm5NiK6SS1WGWIYsK4lEYlxomkMv/itt7l3do+joyVvv32Pm9tb6rpk6EWA4oNHaVBFS310hi4arsaJ7/74U2I/YhvLSdNizl/mpfoVrNoy+A2ukODepBLGKJw1DP2AM46yclCc8OoYeeXlhwQiaM1/9V/+bbabnn/pz/0xlqdLrDZipWudLBaj5+piS1k2pPRFXqz0bzGIcCxlTx7rHInE0fGS3W6LDwGtDP045ZCEu1dQgM5MSuLdgDNGL0PUvFDt3T73/EulOJAm5cPqhVc8jGYh7dWqCeMkRHnPId935Yd6le48tNX+eyH0PoIQt+N+oKkUFRqtFKtxZOx6UXpOEVtVFKWjsBUxTqzGkZQ8xhVYLa/hrAQt13WFcRqTEiYh6kYvw0qdEqw71qsN227k+mbFS6/chxA5to0EU+w8jNJ06wS+n9BDYBzX1G2DcyIeCmHAbweatgKjUNqgQ6CICuvl505RKH06eUpXMasNGpuReKEo3mWu3i3QcupStt6VnePV1SW3Nze8/aUvcXb0CG0tT588wY+aP/1rf46iKLi6uGR1u2Hntrz04FWOzs5YbdeUdUlUkWHouV1d8uppQYiKsV9zsXvC8eKMaBVTmFDdNd1Jw9E6cFV5blfPuPE92sNxc8xqXBGt5tPn7+MKh9aWumyoqpqqqOjDBNoSk8zXZs2SsYfXXv0KwY+Y9Ixnbs0rZ++gFDw6eYtIIKiRceoZfMc49cQofjcxBerS0aolDs1Ivt9VQmNEaL1nnaUgViNTxDjFfFmxuukoZhMn9xq8PULZyGeXt5RFyUsvv0zVVjw8e8BxqSlKz5fe+hW0dlL4k2a3CVw8f0rfycC+KB3z2YL79x9S1zVF9tXZp9T9rOOfWdxTSv8h8B/mB/A3gP9zSul/q5T6j4F/G/ir+fe/nr/kbwD/hVLqP0EGqm8D/93P+h46Joptjy73XWHCJ7HDjVqjyoKkDaqsiF7jA8zuPeLLj5Yc1YZNZRFPcoUqJR5PEwlKmDiMEHYju25k5y/51W+9RVu3eB/psx2un8QaVnBKZKWvLEkJB3kvKHnzzdez8lN8bObzhrat6fteMjV3HQoxJ7saInGj0aonKTB9ZB0LXp2fM/mJ731yw+7ejF+9v6AtWhHstKdoo/FB6ImqVqATlS04/dLLLG0pQi+dWG1uWV2tiMC3f/s9Tk+WfOXtN3n1lXPadoZzlnGcWF198MIF/dxv+RrfmTmRYLvZUpSO7W4n6TFFwWxZMOYcy/307ZD0kznSn39N6agPBgG5ORdWyXiwlvgJdxwvNvJf7Or3Ss4Xv5dSmhQ1Kca7AS17lowsEtM4cbta8+orr0kYhjYc2YopTdzc7EhdTyRwe3XLop0xn885Pp+xGgb+yT/6x9y7fyLD0sKxPDuVrXISg65yDEI9BFlw8jqWdGbax0iYPOubDdvFjLoqUUmzZ40qpQ9FNyXohwGbB6w65DmDSmgjAc1aqZytSi7qCdKL7BeFMZpZO8coWexftGRQL/z/84fsRE5PTzk5vQdZhZ2iKIXHYWSz3hB9xNWO7XrLxdMLSInTk3vsusD3v/MBf+pP/UkUsJk2/ON/+nv8hb/4F5kfLfj0ox9x++kNj07e5Pj8PlMYuV0+44fpxzx45RHL1kGKHMWRj3/0HuWs4rWXFmymEeM0QW2JcaKfbljvnhNSpFx4unDBdH2LxtD7kqJquf/gER9//AGkxDR4nC749LNPKUvH2fkZMQVJgjL7fkNsBEKMhHsegmIzXtD7nVCTY0+IEz5NmWvk5bnxAyEM1G2irhzNAgwDTbvkq199h5N7J+w2FUfLI15+1FI6h9WO3eaWru9QeqAfNozDANphCxF9nZ0tqKrqc5YT+zzdvWDuxWv6k47/MTz3vwr8NaXUXwE+Av4yQErpO0qpvwZ8F4ng+fd+FlMGoFnO+fq//CdAaZQyAn8pckaqY2LH/M1XGIaR5588ZdNvSIUlhIGrrWa86YneE5Pw0xMw+QAp4qdBholorm9uuXd0zBuvvUQXK8YQ6Hth07RtS+E0ftOjrQRil3XBZrNGrLDFpW+aJsI0Er1CG4g+ME4+D6syK0IpFAYTRqbNU54//YSj03Pa8yM0ilV3S7daUU0r+qsLuvuvU2kZqBUJSBLQvGdn1KVjWVUUStE6i7VygpaF4X/3v/pf8N7HT/jBjz/k5vaW3/rt3+F3f9/xxutv8PWvfJn5rOHs9BinNevVwGbbU7e1LH9JZZ8bz8XFJW1TolCs17d0lwMxJZ4/e45zjsvrS9brDQ/vPyAog0kwTIEpGkqjsIjkXau90wzcrSQ6dzsQJs/F0yvaWc181lAsm0zEyf1k3vKmvXl3FIM2nWRnBdLhim/5HcQQ47447pcU9UL9Ugx9YHW7EaFNTCiyoyaSquSHiHOWtp1RZqrhPjgc5bCqRAVoXIHqeqZJOM/1XIlNL7wAS+13G7JpIILVisIU+CGiC4WKSVhfCUxS6BjRKUJm0xR1m1Wd2dZXQVm12EJmSJLZKcPY/fBd1oAkn58iWvx1iTHIn1OOK0TaH2EjQSKnY6mQd0pC3TQoSJ7zkyW2KJk2KyoFp/OGqi6YVSXX1pKSwRSW49mS48URTd2Cgrpp+bVf/6Oc3T+nbmoun4mFb13XnN27x67boSO8/+HHqHYhYrCkCbueH/3wGe037/Pq+SNaJddB721095L/DDMZo/HB48dsaZ0MP3rvKT5M1POaL335DWL03D8/IyYRtKFkkZRMgIhW4DJd09gGFSLzpiGkQDf2DMOQG7gBpcE5Azpi3zzHlYa61cyaGbNmgRprjo+W1EXDFALvbj6lcpoUFbvdxDh1mSxQ47ueqqxZzuc4V+GsO/gI7Yv4nYurHHvNxj/X4p5S+tsIK4aU0iXwZ3/K5/1HCLPmD3X4ANc7y2p1TVWWzJenWJel11Gscau2om41v/+dj/nd3/0ORWFo2pa6XnJ7e8Gv/PIfEdoj0M7mXF/f8tknj9msbvmX/qXf4OVX3+Rv/e2/w/XFc5anJxwf32PTdVTDkHMqU/budgdL2LIss9NdZL/hT0lis7Q2hOwL3g8jRSmUOa31QWp9+eljnKuYDSs++p3v8pV3vsFZIc6SqUn88JOPWXdb3NdexzhZoQsn8udx9DjnKFxJrSMzqymUPgh5UvK0leXXfvEd5m3Lj9/7EReXV5RVTWLGuz98j3e/932+8tZruFnD2bHc2LerNcf3TsQHJN8w87bOPh4BhaT1BB+w1nL0xptU1Z7nrTleHsvgmSTD0ZiwyoAl28vCgVfHH+wPj5YzmrrMtD6xmRAc8y4oet+s38EtmSqo1GGA+sXDWpvTa/Zf8nkV63q9FVe9mA4LiNgPi2WsMUJ3rU1FWYr1a64fWCsGUQCb2xVN5QjTiHElanaH96uUIcYMBx3ea+bmS/pSz2Je3/1giReopFHEQcZIAHMhxnVHe9/uJF5G1rqsDLX5HMcDk3S/f7p/dkykxFqwNi8yeQXYv7M79QAvnJN8vpGCYq1ABmjLa2+8hbNynoqy4Ovf+Aan9x7w3/7W/5dxHHjr7dd4cH6foirFYI7E/QdnIlBTCVc4iqpmsTziaLlgNp9xenzMo0cPZWhvLTEpYlK8+eZb1HXJ48cfc726QWl18HFJWeGwHwq7lLC6YNt3VFXNMMB6t8bYyL2TI156ec7Q90zZeM450SxIJGdCG9mhKHR+vhPGJMZpkLlNipTKUFUtoZRmxFmH1vDgjUcohB6rjMaZEjOzOFszRJimyMnxEkistwFjLEVRUxQWY0vRP2h96MrlWuxZTXcspf2vFwv7v8jO/Z/bcbQ85i/9K/86v/Xf/13my5q33vylu6c733TTNOF95O//nX+AQjIZu93IZvuUMA38/u99l7K4L/ii7um6gaubJ7z+6JTzo5ZSez58/z2ur654/uRj5k2JmkaUH7LAxwIWXydcWWSWnWS7ej8RoyeGhHMFzpYopYlpYgqJUluKsqKq5GJUleBiElbQ8OmTJ2ASb7z2iuRCWktMkYePTtl1nTBSdJIAjpTwmWXT9z3GaAZtmaZE4xSN1ojj+D6jVPPOV97k9Pzf4ts/+AHf/r3v8uSZ8N1ff/SAl48WPL265rd+9BEPX3mFf+3f+N/w5JNPaCu4unxGDJ6yMJRljQ+BzabjK19680DJa5rmc10DACmzWyIZZ5fJmVYwm80JPuSknDu+eG4scUZRz/ICJ2hDZoFw+PVi+dbGMFvOee3NVynKCm3d57D6w1t6EXZ44SGRP+SgaaWZJg8pELLYiT2en6XxKI019jBwU0qiHiXjVJH8nU7AHPJIVaa+3n1fpfTBwnVvCVvXDVUpwzc5jXcWDuRiOk2iUG2ahsJYtqs1nD/IkYTCphKDrv3OJoLhc9CLUopZ23xhpmEpS4vWRpwIs/nvvkSmBCpp5rMZxpWgNffPH3ByeootS9BWdk7551VKU1ZQbzaMk8AZ2hrqtpYuOkyEFIhekp1QsgC9/sbbLI+OiSk7JVpHa4tDsVLKEJOcq5QCJ0dLGiMd9ocfvM/y9ATjamJKoHOoibKEccAow/bmmoubifnRnA/ee5+mfoPSyerWDRqjxKGvKOQZ3lNZ+2ki+MCeGg2KZC1Ka+qiQisZohMR584Ys+lbka9FRGtHUqISXvc5u8BYFsdH6Bw47nJHjoKUAjHlZ0CZfEllNkIgp1jZwzVVSjRpOili/EktzuePn4vi3vUbfv8H/5DHn77HebjHV7404FxBiJGUsjxdR5QKTNOOd975Cp98+inONQzTjugN89kZ94/+NDGJv8elesbzy+/xS7/4Lb761ut8dnEjzBKt6G6umbkJZyYK61GsmaJijInNWglft6poZw3G6GzaNIJWmY0RxVdkkoCBwjiMseKiqEVunVLEOglpfvDgAffunUtSzSRiJbSoHV0h+YvBi3+HRtGPI9Y4yrLk5uaWqqqYzxfsPAwJGmcodbzDnlNgXhf8+q98kz/+q7/MJx8/5bd/57exKvEP/5u/z/2XX6WdVSyOFvRTz/Pnz/gnH/yIe2dH1GVBO2t4sdqKb1Ykpbyd564jPCC2SomJV0g4J+Zi913Dn//zfxZrDFVZUFUFMYtw5Cv37WX2QlEZRjms4Z/vRFKShJ+2bTlezPINfQf63A1N5f3oF7avd8VC/m5zFGGR8ze7rsN6j7aKFGVrv3eqdM7lAax8n7aR+YW1sqC6QhOTl4T7pO6w9ryYqYzHKCX/ZrRGFyX37rVUlaVtRKW8/2mnccw7BOmKvR+pG0dTl3ztq29LklEwPHpwDCphdM5NUqCy+drnZxD5nBwumcYVlvv3H9LmQHcJoJ8Yx4EQEmMrwSF1XVGUFa4sOTt7SDNfgNKEF75B3M82UmI2n/GtX/xljo6PuV1d4L2wkFBakpPQ2THT8OZbb6OFWyissIxlqWwwITu2RNyPWYTtgHECTT1YtDRNgS4LhmGgKgp++O67nJ+d8/j9j1ltO1596QH/9IPv8kf/2K9z/eyC+R/5GrO6RTWOT548ZtdvmM3u0fdbJj8RkQ4+KtnJiuRfCrmzFpVnKeMwcn29oe97EZiRpEa07cHO12pNoSXxba8u3u8uVIyHnanZZxbHKOyiGFEhYK0w82KKAkFlWvT+90QiTR4K8dL6A03XF46fi+KOSkTnef3LrxNj4Le+/Q95+uGnWAd66UiTJyQYr3s+/fQjdGkY/UjZntE0pzgr29ir+F2SksHPJ89/RIxjPjEjT7eP+davv0myivWi5x988jsEtQ8QBqUNNS3l+ADrBbPXJlGWJVoLa2WzXovPtAFrZeDY7TrpLtsZY9/lwYdspXT2kY9B/MQlLk1n7HNPxcrmTmj8JJFuxmhG3zNMHW09I6TA5fVzFrMldVlxO3kMisop0AobwSiFxVAWBV9641VeeXTG84sLvjN/wNX1NfePS+4dLdh2E2XluLm+pKgs3/3eYx7ef8jpvXOxc9UWg+Fe2/Ltf/x7LL9UUx8do7QIcZx12bJXgjuGQbzsC2tplCGS0EbnDlO64JPT87uv1Yq+30me5dgfFJhk9Szqjh2jlGzDTYYdTKa7xrTflt/BPzF/zt3X7rtj2GwHtLU07QKjpXOaQmLqBpq2yLx1lbfHUoz66Y5ZpFMiTjn8WGW8lSIXoJiDwV8oqC/goacnxxwfHcs8SRsZJGdbYlLkaLlgHAecNSgkBSjmzt8YjTI5n1Ul3OFplTHxvnjfJVDJL600xycnOFfiCmkSiqJkNpvd+YonxPUx3nXud1ia/CzGykITUyDExDglofgFhU8jzko49ZtvfRW0JxFp2wVaFzkoWl5fJwkD+WIxEm3CvlNGbKZz0PUURoxRrFdrbq6uWLQN//jZY9pNy0v1Ef/g7/8jfvMv/Sbf/v6P+JqasQ2By9WW4xPPME6AmGydHB9TOUsMkQdnx6QYOFs2NFWSvNgowRlBFVhbkJJmGEd2w04ycodeGFI+sN1sCEEsDRISHjONk4SwRPB44tAdLJxTmGShUEW+R1Xu0uUaGLOntepDHoAxhugjyd3BLvsCb7JvliA28ZBM9dOOn4vivt6t+fu/+7cPBU+j8c936EWFmSxBRzSJpbcoPFMcKOqKb3zrV7H1kcjDs5WmNoaby2s+/eR9FDDFwLvPPuLp8JzjV+aAOBVOwQtyJ7s7bFRYNRPr13y7jePAbDYjBLHrFJaHdBjTNDKNYoRUZQ+SaRpFNZsLlolCsSyrgmEQXH9PEdTWZmh6rxgUnB+19zIUDHu1WeGso61bhmHA+yA7BFeyHiamKTC3itIUGI0oN2PEKEmyv7GKN77+dU6KxPc/fM7vfO8ZX3/rhLKy9P3I0ckZT55fsjx9wD/6B/8dv/Fn/yT9bqBwlo/efY9f/OY3ePXtrxwojXs/971PzR0OmAuv2t+IYkJ12PK/QHWcpyNISVgI0yQB3n3PerOiKKZD55SSzje+OOEp4gG7eZH7keAwzN6/t33BS8Cm6wgpgTb0Xcft7Y0MVXOnf7ScSQeXt8taKTbbHcfLFkiEydOHRFuXaAsheCnwSh6fuB/gcqiLh52DtXtjAHVYxA7BGsDLLz/ilVdePnTtWkuRN9pRlKV4docIjPm1VdY9gtKZwmstzhUUrqCqKsqq4uze2ece/v25OQz8RdiRNRU6Dyc5ROGhFOM4cHP5jBBHisIwTg5tPHFKDHGLM3MqF/CxADOgVC3BMhQC3WUDviefPeazxx/zzT/yK7noJ0IKEs4xyvXu+54PP/iAhw8ecHt1yd/9e3+XP/Mbf4rHjz/m2//02/zP/ty/zI8/e85yNjC7V3Fz27HbeW5uNoCl70YwhjEE0WUYJYthikQCvZ+IccQoT1u0VFqoxGAxTUNEE0JiO3l8Ek8ehdzD0XsK51Ct2I5vxi0ohdGi3RCKKRDEPE2zt7vwMqtJGQLESspUSAfCiFJ32PoeZ4c8Q8p2Ey9i7TKn4vA1P+v4uSjuKIVKgl8mDf2zLf7ao17/Kq/ELavpGafNBaWeMG5A2RKlHMYJVejq8pLbm2ecnN6nXRyLMhFIKvL44hOGoyVTLqIWoV4S5dHXyHbeKkuKlWyh81RpmiaU0ozjjq7fkZDtkvd3XiPWCsMihHjwIKmqKv9YOdVos5HXNFI8QoiSKfFCclCKIpG3Th+61z1FzoeJ1XbF6VIoeBeXF7RNzWK+YIqJq3GiNIa50xRJuv+iKpi3M47Kgspp3v7SK+xCwcOkqYpADAMhzHj27BnGSEhx0864ulrz/vs/5uG//Cf5Y7/5m+jZEdttzyxHBN5dsrtQChk25sFPzDBB3lKTqYsvHnLDJ7QzOFeJFS+Js3j/UHy01pJakxIxTozTxND19H3HMA34SO50LUqJcdeePXGAJZQUwP1gFCJX19dUbcM4jJR5m3x2tszGZgofJmIKnJ8eoZDdwmuv3MdYg7OiFNxsbzDaUJUNpSsOhXovF9pnZ7KHmxCR0R431VriD60pODo65uzsHOsKjFH83b/739ANPQ9eepU333iT4EeGYWS93ua4wSSJSK44WALvE5GUUhhtmaaRceyzPe9dQd9rDQ7n9wVUfr8Y7WP8QoqovNO0upDcWwNKW5LyqBBJMeB1zDqIQPAdpSsRK6CI1rI4hTBROMU0dWxue66vb7h3dsrN7TV/82/+Tf7Mn/4zKBR/46//df7Cv/KvUJWWTz/5hM1K0p36Xn6W8nKDv+nYVTNiCpSVIxIorJF0tRR5eP+Mr49v8dL5Of/mv/6vMq8KjAoYmzgqJ4aho9BHJMRVNAFTCkw+MU0xEws0R8sjjDF0WwmpLpwjhZijFX2GjsS62HuNNS6fSbkXldGHc7/vzmP07ANMVA5bf/H8H+jIis8V+v2/v8ia2YeO/6zj56O455UpJUVlCl5+8AqP28h3YuR+UsyJ6P4pnkCyMrhDJZSR4uIKR9Msca4kRfFgV0ZjjGU7bDiJlTxcWgv3/bAFVajscV3rFqacPo/KwRRSiK6vb4QCpaTj6PvhcJEkbkwzTdlHfo+1atnSyg0g4dqoxDj4PAiSrv0wCc9sBmlMlaQHBaFpGW1QBuHFVoqmqRnHkdvbG2azGbZwDD4wdCONVcwKhwOqoqKsHGHqUSngjGFRWlbbkT/267/CeuuJY8flzQo/TVxfXzCNL7M8WfB82/H9i+f8999/l4cnx/zpP/VrbDdbXn/9tcN73ncOKVs+SphzXvS0Rhd3MMWL50ZYL3dOhnu8HPP5G14pgZuMLnG2FMvm/P1SxiYV8PzZU1Y3VwevnxcZCFGwGlJIJC0hHZvthvV2TdEKo4MkfHWlFdZYEhpKlQfDmuPjZs+VyowXg0JiEvcDYeAQ+EwexFlrRFlpnWRutjPpBouasmlzDF0ecCpFil4GxilQ1C3t4hiTUZQHyBBV8Gz5mHmhc5tyjq7WNtsvj9lil3xt4h1WfqDXpczGiIfCP2T2WCQx5QD4uq7wU8xAmM7h6S2Fq7FFwuT0IpW92se+49mzC46Pzxi6NRfPn5Fi4t0f/oCb2zV/7+/9Pf6dv/LvYIzik8cfs7q9pq1bdusVUz9gmOi2vVyLKL5Gnzx5yu9/9/tUVcmbb77OYt5iNPzar/wRXn5wyjfefoBH0xY1b73+KioFjmclKU6kJAywN165L7bOITBGx+g93dAzhYiPOjPlxKY4xpT919OBQVO4Au8lGSspgemMLbGF1BqtJBN4PxzV3N2Las+gyuZ3wXvUFxgyomHQRBU/F9sId8V8zyr6F81z/+d+WKM5Klr+/o8+oI+G3zh9m+24Y6aOUOkRU/qEFBPz+TmbXS/4qdE0TUNb1bLNMjZbq0aCv6Ng7B9ElEAXKndVSikcBhsboSOxp8AFUhTORNd1InwxKgcXp88VkH2MVl3Xh4s1TaN8X6AwBYWzzGYtUzWy3Q0SbJEhHoV0hCnFXITU5wpmjB4VFIUKDONIP+xYtHNmTctms0UpsTc2ztEHz9iNtEWB1QUaxawysktJA85oZpXitZfewGjNO2++yW//0+9QNjNUnLBa8+TxpxyfnhGmwDhOtPMF/+R3v82PfvQef/nf/Df4/ve/z7e+9U2apuHABcfgveS/ppRI2URJG6Hb7YvLQW1qLEYbrMmsjcRBQbk/hId8t2FQOlvmaqEv6qRRWrNcnGCUoR8G6jqitcIVNtMjE88vbqR4O0NKgWEY2G23nC+OUEkfOCP5u2SIaS+BusNJjZY8UW00IXiMc5w/eBlXCMZaFiXOFbSLhWDJSsnia4RGyn6AjEYbB0i3hpL7JCaZ5VhXi+VFCqSQAMmxVVqLEnu/M8lYrTVGdKgZHgve03c9iiTv08jn7TtIuX/vtvf7MxyCFBUfggwFEapo4SqiSQyTaB9c4Zi8EAMKCgyRv/t3fovTe2d87Z2vcHVxxX/+n/0X/C//jX+N5XzBbrslacXutmPoOrbrFZfPn2Odod/tUEBZCGNmMZ8hSgmP0omqKpk1JcNuwy9+/etcXl7xi1//Br/yrV+kKgr+xK/8ihicackf1cmI+DEFYhwZRy/zlSkyTIHd6OmngEdsJrQqMVY68MkHVIg5llEYVdFPct1DPAz8tdaCA6RIDAmlLNa6vPvbW1MDWjIL9qwcpxXionoHf5lcqPfXB6CwYma3zw7Y1xmBaHLM5QvN1U+tp3+Imvv/lyOphDOazfWW9z++REXFkTnCvjlnOTshxDPe+2jG0H9Ee39BNwwYEzGFIYaJGCU4eZwmiXRTe7tY6bZMpu3J98odo5EVtdRz1FRgrHTX+/xWrcgUTI9CS/BtlJPeNI281gtdbFEUWGtzqvpEmCRgd89dlgAQB2mUUAijiXmb7nJg7546orWs4CDRbdoYKGVBismz3W7wo+fk+JjNZseTp08PYRFKO27HCUVkuVyymEn79+arZ3Jj+QodE1YnXGH547/yi3SDZ978RW42a2ZlgY2Kk/mS7mbN1dUNZe04ufeIJ8+v+Dt/7x/y6muv8Tv/5HdpKssv/MI3STEQYmAYRrnprdDuTNJM3ucQjbuuse97yqogJpdZBHsmEp/rWowxubhKcMeLhSklRfSRum6o6+awgEyTsEAk6SfwysvZGlVrPvr0ibg+xsgbr7+FTiKT71/wZ9+HYIBiNnlMvq6Fc4zDwMXVU2IILI9PeOWNL2EKJ7sVI911WeaMV5UyxKfvaJcxyY5DycM8eS+uhHFk6HrGEHnw6DW6YcsPf/x92lnNYnaC0QVVWUt3rvLOlL1fT8yLY0JnKHDsB3yYZIHVe5ql4Ns2UylD8HkOEPPwMzs/KuSahURd1SgUH3z4IWVV0s5bfAz8V//1f01dtfzmX/wLgOLxx5+yWfV89ctvMw0Dfddxc3VFXTrKsmLnR2aLOYWSAfW8bQhhgig7SkWiKgqshvlsxp/4o7/Moi6497Wv8M0vvcl7H3zI1956iw+spS0LylKTfMBgMFZhbSVGb0Hort0QWG86truOwQeCktmEsbXEXwafee89RVEQlWKYRK2eUsLtzdJjOMRrxgxf7nY72X3nBs/HwOgm2TXloahAw6Ji9zFRWIOzhhjA+0xxzCyYPba+v/dQAsWGHA3mJy/zFWMwWmpJWZafCx//ScfPRXFPCpLVMrwwiT/5pa/AGIjPtvzKH/9l9PEJv/X9Nde7kiHsEF6IRifP1dPPePcH38fGxPnDB/zohz9CG/BjR8y0OaUzuq4gqj3LQOXOWmPSjBgMyu0pZiK5lq1WftBTNqJSiqquJdBgkk5V7R8YJav5/kLEEEXBOooZ2Hab4YmUB1x5J7HH2vZbN1JCKyMdYYhoozIPWyblPkRSnPCDx0+esqxYLhfc3Nyy2aw5Pj6hnbXEGDk5P0dpWEVH7UpKI6/vwyQDHRJJaZq64MtvvkI37HjrtVf48LML+mkEJrpuzWxxxgcffswb/z/q/jTWtiS778R+EXs+w53f/HLOLNZA1kBS4jxLpCi2xBZEaoJpqSW0AKPRbX+T2h8NCNCnBvqjBQNuGbbcUrclS62BbKtFSRwkUiRVJKtYWZXTyze/O997hj1GhD+siL33ue9lVhlQG6ldyLrvnnvO2XvHjlix1n/913+9epf51hZOKb729ttc29/lzp2X+dVf/Td86UtfYGd7C2fB6k0MVxqDyP3WVc2//lf/gi985+e5e/MOTkk4anxSNHiYCrBGZHC1lgRWFMc9Zz6EzMFgKc81y6KILC+Yb/kuQ36z6Kzl8OSMVdkwncy5+9JrPomNaPR7CKBtO+/1i/FF++KhKKKtK0nyWstkMmV7a1cSqlo0elDyvJyCrq1FibALtMOOtq1ZlyucEibW2ndxEupdxme+44vcuH6Lslz6DaGh6xxWG7RufdI+wqkI57z+UNOKcXCGRAmFuKzFc1dakWepL9QL+QefG0H+bY04EdbP3ZPjc/7ga1/nS1/4ImlaUDc1v/hLv8Tdl+7ygz/0A3Smo6xKVsuai/MF1lrOzs5IkozTs1OapvUskowk1dSdYbGM2dmaEOs1kXPYpkZry5uv3CWPYGuS8Zd/4c+zt71NEkf8xA//IF0rPUZRmrvX9/j9k/fI04SyrEjiqX92mtJY2qqirEqWi4qqFf54lEbEWUGSOVTXynWXa4yxAxtJK9blmq7zXH3PJgoyF52VKMZ0hqZrJTEfCRyrlOj5i3EW6eqevuicpzR6GMc6qrLGGITm7RO/m9i6w7mItjVYZ7w4nW/G0jPDhnNcxeWvHp8I466QSNN0DY+OzvnwK0dUVcP67m3+8N415ge3sW9/hVfv7vL273k51WXJO//u1+meXJA7S5TlHJ4oonKH6Y0jVnGHyYS3LEY8cOaCaZAwN1E5yqRo1ec3aZuWuqlI0kR4wB5P77qOLM9QWlE3NWW5BpCO5p1ICNdWDLrAN1qq9RR01tKu5f1RHA1enR6y4bJoDXQWaQeHf3/sYSCFs6JqZ7wCoHOW9XpBWcL29i51XXN6fMR6tWRnf580L+hqw9m6Y51o5oki1VKaHnoaOWd7/D+JErYnGbf3dzCm5XJrwv7+NcqmwRpZsKenp5RlhdIR167f5HK54u1vvMunPv0pOtvxO7/9u/zQD3wvE8/nBu+ZI4JfSmtefekVJvmMtrMCHyjJfYRIyBiDM5YossJs8snr2BqPxQ4QTl/ooccVl2KoZBH5xKoPjCaTCcpJ0jlOc4x1pEr1mGbqwtg6z8QZsGqNQkeRcLiVpusqaltjHJTrkrZb05o11jqayqAjxd7OLc4vnqBVQZJqsjwnTlJ2dvZZrS4kGtQxUZSAUiRJilWFf85BRwRaY1hXFUkSYYyE/EWRcnl+QZJIu8ckKqQTl46wXYPWEU3XEfv7qapKeOepRExt2/JP/skv8uqrr/O5z38Wi2NdVfz2l3+PT33qs8y2HBeLBcv1movLBReXlyjlWFwuKPIZVbWSqNQa4kzqHcp12a/rJEppO4N1U+JYs70944/+xA9SpJBnBX/2T/+syDNEsHttxzcNF4zb+C+xaOI4JYszdrcOsC7morTUpqVuL2g6g7XS1zVJc7bmKUkivXRX5YqLiwu0llxc0zaUlbTYm06nJFFCnMQyV3ykl+c5k6Kg8TRfB9I0p5Wua9p72WmaglK03VDLEQ7nm4xHiW8+37UkSUYcK+bzLdq2o2qafl4F1VRjLIoWnELFEZdnJzy89z537r7EbGcPEwXtJfUfCSzjQLWWBsv5RcnR6YUwFXa2mO4eEKGxdcX1/QNiv0LX5ZqHDx5wO91jPp9SqRmL4znrGurzx1hniBPtYbLBaCilfEMg6TwfqxmmRgqPEKy97SqiSLG9vY214mFZa5lMJkLb8kmnLMsBSXBUVdUbsij24bIzIkhoDFEseh0OwYSn8ymd6ahbg9YKQWS8UUFhjRQ4JDoV3N1YOtURR75k2be7QxmUdjRtw8npM+bzLW7dusnJ2QlHR4/Y2tphPt0ldjFd23DadORpSh4pikgaXEjFaeCFO6QoKufNW9d54+Z1iukW77z/IamOyZQD05FECmsMjx4/ZH9vj0kxYzabcXx6xDvvvc/3fs/3sFgs+c3f/B0+9x2fZX9/F59FJolidj/zKf6tavkB55gLlYTOut6QylPrmdd9+OoEfxDvyDNheoq3byASnrPtbI+N6iRltVoBQmVcryp05J+JZ81EiHDdWKxMwndHU5e0bcfF2TFpXpBNJyxWC772zu/SRg03btxhXZV0pqJIp0QKdna2iRPNwd4NUB2RKogTQEVonRDrnDxvpdjFM2GUEsps1zQS+bkaraT3LiqiqkpwGW0LOE2eJVRNjTGKKLYo11JkGU1Ts1xcUkwK5vOZNOE2lv/pn/xTrl+/zo/92I/hkKbX5+dLjo8v6DqLU5aLy0vKsuHycsFsNmEyndC2DVmaUmQ5TslzSJKINNPUlS9c8gnfOI54863XyNOEFLi1u8PycsnufIfr04S7t/Z89GqlmY5zOONQTiSGrcIrN1rfNCbBJgUvvfUWTQsnZYkrK+I0J01n7Exj4jj1ejsRiacUG2PpuhiFo64bDBanIc0yEX3TMVninbW67plu0pBachfhUFpaV3adrGWlpYgvSmLsShwPHWlfNyDzUZxWqVJ1bsg5LRZLwdm9w2Ktpa4qgRezlK/8/m+ibMTnPvednB095fe//KtkxY+wc+1W7/iEaOHjjk+GcQdwsLu1w/d+6U0efPUfEjv4tju3ieKczjraZk0aSbb58vKSzhga21EepMyu7+Lalq38GLVcsFgspK9hJCMcdLat537jue6JTYjdDKsUTkdBzp04FZnVNI0p1wLFJIngqlVV0XRtz/cG8X5ADFB4n1YaHSFeQTR4Sc7zbru24+btPR49PMSoEbUpKAomFq0ijHa+mrAjVREq6tDKNxnAYZxDZLtaHI6LywtW6zW7e3toBatVSZZuCRc6z4XtUTeUraNOFJMUEgWRC348GGc9vUx6s1gsn37tFp959QYXyyXf/52fY3sSi/SAMxRFwsVCxt12hp3dXbJiysn5Bb/xm7/L3ZdfZnd/l/fe+4AIxd037nLZlfx6U/PFYs6WVlKKbzcZNRKJDga/T8gywAlKa2zXoiMRD9M6YpycCvmQspXn5pylqQVW6Kwhsq3PJ8ru4HAYX/XZth0OQ9c5quacJMkp2yWf+twXSXyxUV6kdLbi+t6rLJILOrMmjQqUNug4Q7TzIMsyTKewtsUYh9aWLM2lV67pcM6gKHA0FLmhKVfUTYvWLUk8pe0MsU5p6saXwYvwFdZycvSMLInZ2d3CqRVttaKsS/6Hf/AP+OEf/iG+49s/h7HQOVg3LSfnl5RNS6wci9WKi+U5e9UtVuuKNBOKJihm8xmzmRcws5Y4gjhSAgMp0BicaYm14/u++0vs7uyQuo5smvDn/tM/QoJQZNN5wlfLBWfnCdcmhRTpIClrrcWYOxStUXQKqq6jrGoWy5qmNdRti4o0cZaRFDGpGrZ9geRSn+eQ4i+ZLzJnIt8lrG1baVESiTHQThOpiCKXPEbjq4SVisjzAo2jqWuRdUDhNFjtxX6VwjhL1Vbs7GwznRV0nWG1rjDOIKJ0yleqRmRed2q9XvsINNCH8fk8YVopDG255OkH76BcxGc+9Vlu3b7Bj//IDzK/9QpEEZGfz1GUEJrHfNTxiTDuCsVbr34bf/gz38fq3PHP/9G/wnYt09kMjwqzO58yn+SkScTW1hbJkTT6Xa0uWN2/IN/SRBPY30m4me2Rpdf4xtcfoLIYF2tPm1PDjooiVVNMJWF9T/OKhZlgjCVJUk7LS2EQdB21T7bo4IW7UPAhbAodCnmMeJVZmvUGSmhqwvaItCRmHj96IiX1Qe1QaZxPooo2S9DoDswRwfFcEL9ykTxkA4xKuJvGcvjslPnWlO3tfaJYPL6yLNne3iYvMrquY9HVrEqYpxHTSBM74d/LFei+vB4sOpHmFNezlD/xkz9KbRWffeN1ptOcCOWjFGEMnZyccHl5QV2XzLa2mEyntMbwK7/2a8zzgutv3mbeGm6VJc5AN9tGOnCrns1xVThpLCPQ43jg4SxN27VoFVGWZb9RhgIQGTcltQjGcX5+xnJVcbm4REeiBmmMqAUaZ2jblul0QpyIJn4UOWDGdLLNcrEiSUW9zzlNksR0rkaRksQp1tVS0dnU0Dmca5kVUJZrFBmEqmgkVK/rGtO1BL1w46o+PLfG+oplKZh6+uQJ6/KSLJMS/qqqWVcRv/zLv0xdVvyFv/BnsVpopVVdUVU15+eXmE742U1bs1otmUwkmemcJc9ylNLkk4ytrRnOSa4JJ4bcmJYo1uRFShJrIgyZ1vzkj/4IETAx0g/2B7/0Gdl4TYdVvmlHK71ztY7Z3s5pG9GOGTj30lWqMVC3HfVyycpHAUITTYmLhHgqyd+mqT3lWKLlyWQiTbh9AZDUlUgEoVQoalN9QVDVNiitZW2NqopxIgYYci7ibYf1JPkJ4xPWYU4Kn92yXpc46yTqIdBiAzgoTmGWpbRt189h43McaFFRjZQ841g5inXFT33ui8KDNwv+X7/9K5zXltcuWn76CzN0sY3xczpNBwfzRccnwrhPixk/8p1/nMhqSnfGtWsHzOYzksnEQxKOT718i739Aw52c+JYU0wyXnvlZVbtBS+9uo+NjXQD0p7/ayLeffeRb7XG0EkFX0jiFCkzGmtJQ1GNtiIQpvxGQETdlDTNJofdGUtHK8bYb57B6DtRGiaKYpEdRvDe0ExEOaGngcLUPmwLyd6eIx8Jtmc1VqqtcA6McV5b23oPI2c+28JaxXp9SdPUdDZQEx3rVUld1bz++hsolXJ6esR6vWBrNpc2XdmEtm1ZVC3ryDKNIzJlSSPVc3Sd77upnO8IqWTjSZzlx3/ou1FEHJ2e8MZLt9iZFawroctlmTTWOF9ccn5xgY41Tdeye+0uU6uYLWv+0yenxPMpbO8gKW+N6RTOdX3FnlJqUDx0UlgWpzGNNcQ68lAW4mkbSSy2bdsv6CRJcE400os0xzlf+q0jVsslOrIUk0LGFo2xDU3dgmqIk5wkTiUK80Jok8kc6wyOjrZ1tF1NY9YU2S51W1JVa2Kd0plKDAxdj3U71xFpL/rkIiaTxvepFcMeJYqudnxw7wPm04LpdE4USZFQpDX/7J/+U87OTvjf/qU/T5FlTPOcc6+vvl5W2MbR2pq2a8FC17Skcc5qUZLnGZF2HhZLyNKELE1ZLpfCUnK+vaRSJJFme74FzpJEimmW8At/7s8QYUhdh44cO7evo6zFtJWsHWN8wVnnWSQJKvGbvjNkuqVc1TRuB+scdaspq4batAJJKkiyjGI+65PjXduxXC1YlUviWLSbJtMJbVNhTEddV0IyQNZRT0NUgQHtBc6yjPlsBuuV1MAohW2FIdR1HV3XeEaXRMhN06DSuE+WSmQvea62a7GdbEwtiq4rJYJSQnrQwcp4g53nUr3edea5Ggx8FCqOiiYvV5hf/BWS954RTyeYP/5Fjk6OuV85js7O+dKd29y5PSVKMrI0IY6jj7WrnwjjXqQTUiMGLYljiiJjZ2ebawfXCXzvl+7cQumYNInIEs3O7oSX3rjG0ua4yGK8x6uQvpnaKZJEqEg9LusJKlopYptj26in3InmC4Q0Y5KkZKl4uNaKoqAYCjdAAtGmUJXxyT7B00QZMWBx1knWX7sYY5rnEjDSYSWWCriuBo2nVAVxfsEoA/OjyAuuX7smWiQW8jzm/PyM1WqFteLZ5HkuxvtyQRzHXL92jcViwfnFBev1mt3dfSaTKc73Wj2varI4pUgiClovmjRI5zon7IHOGJRDSrIjuL67w1/68z8HGt798AHTaSFUVBzGdkRJxM7uNkkcsyrX6EWJ/a13ufmrb5P82R+mcsI0F92OYYy1XwyTvKD14WugiyZaorE4jmmtIYlilJPFFwy8SEK0BA9qtVqTZZn0Bo0cRZHjXOfHVgrUuq4Rdk5nUSpBIRWLxhrybM5yuSKKBdZrmg6lNE1Xy/V34l06DW3XEMUR1nUeJ5XEsfLXFmkwnSFP8x5/TdOEBw9O+L/97f87f+ynfpKf+Zk/QZJIYdHl5RJjpM7BGsfFxQWxltZ/q9USrRQXl5fM5xNSL1GslCZLE64d7LIuS6LIKyEqkbpom9oLil1nOi3EMNmO11+6wX/+F3+e7SIljxzTKGKyu4tpa9qqlC5Yvo4jcuB8AwatFCKs6LXkPaOn6WB7d87ERDw+XYv0QBSRpBlp5hlQo14IIu+QgApkAkXno5zFckmsRQajKKaepQLOmsHII3AhiN1M01TYSFHs+88qnBImV2C8BZqorG0jLQE9RdHisAEyRG3QFpPA0gp5GhecNIii1MsL676QTZhfsXcWArhkUM7SrC5ZHx2zvVhRr9YUJ5d8992Xqe8/QaUFrihoqwXz2VZPFvi44xNh3JtGeN9JEmHaNfOi4Hu+84vs7+3h6Ajl+OCYTlJu377OW1+4y/3LB4JN92EQKC0epo0Ub33xZeJEQnPlx16a4sZkbou2acnTwkf50rRZ4aS7fRoL9cl20kNRjwoYRhSkUOknVLKOzgoWniQZk6IgSVIc1lOwJME68InFS59MZkxnW1RVJSybRgyNXLefMM7SWINyjjSJmBZFX/iBhiwrSJIVxi4xTrrB57m0hevqjqasWS4u2NvfY1pMOT455fT0mLJcsbW9Q5rlRIkYnouqo0lTCq0pXIt2kq/ADZIDkfaaLj5xnMUJxhneuHOD/8N/9ufIJlPuPz1CqxbrWpwTz2h5eYl7eMj6vQfoakm2quiBMp80VVoWSBonssC8fC597kP09LGOtjVkeUZXC7QRRdJuLcsy6rr29QyKuqrJsgTjOpzSVOUFJ0eHzOcTrJV8RKJjmtrQNQacpu3A2BpNinXSc7eqGojEOJVVQ6xjuq4FK1LCym9UcZySpSkQUa4XAtEhukO/9Iu/yNHhMT//p/8Ud27fYmtrS7jQaQpWaHdlWYu4WmVZLJd0naEzLc5aVsuKRINLFdvzOREOHcN8PiWJFGkS87QusbajrWvqsqRIMharNfv7B8x3tnDWkCca07X8ws/9CTSKRAMIDVinOZ1p6VpD64uXPD4oev7OSm4CwCkip6QZtU5pOzhbWaquEfaYc+gspUhz0jTzDJOGsqooFxWdMaRJymw681CDRNBNs2a9WlBWa+IopuuEwmg9th7kiyE0WB9XbQ7Okzg6E8qqpvHQTBzLc2tN3DfaEeqhI44VeZYwKXJKpai7DuVrLmJPiR0beOWZVkFTyqeLiHRMEiUSlamh8NFYh/O/S9QZ0ZqaylTEb96gc0KoOK5qvv2lW8xIMNEON+Y3WF6ckW+VdM5yeXn5sXb1E2HcjWlZLs7Y2d1jb2+Xv/gL/xsm0wKtoKlrQd29Mfz5P/nH+drTb/D+yQd02qC8TjRO8CuLFLk455jMJn4H98lCXyWoXYyyCTDg4BDwW/FT0ywVLqnX2g74XEjujbFhrYO3IJMsy3Jms62NQoM4jlgul+J5jbz2JEmYTids78xI1orlUkJQjXimoTgmnNcYw3w+I8vyga7ngopgTCiFFyXAFIWmqRuslSTj4bNnpHnB7s4ObVtTl2uelTXz7W2mU2nK4WxM3dTUjaZKMnLVEjt5DpHyEQWhis9jm34ckzgiTaYYG3GwM+Pn/pM/ymu3DlCmCx0juHjnQ2k6ksW0ReSr9ZDybe+xiwREi47jHj/HY7VZllDXnVQNx9JKME0STCdtALMsoywrL70Mbd1S5DnLcklZrkVKAsiylLqqcEtD4qbpDgAAhcJJREFUlFa0naUoElIdMckKtM4x1LSdQHEyVw0Ki1UiVSD89AJnO5I4ZjoRaWLTddTrBW3T0qzX1HVDmmRkaczy8pzj4yPqqsK0LW3VUDUtJ+tjuqbGth11WXL/3j3yvGBra06iI+ne5KuRiyymLNdYY8SYOJhNC+pyjTMds2nB7u4W02kOGLp2xe4s5c//qZ8hjiMy7YhcC5ET9ceQhPZ1A5GGtjGSsPYGmmDMfcGCcZraQecUde1Ylx2dUaAsKnIkScIkLYgT2aSrqqJaXNK0DQ5FlCSkeU5sDaY1vsJ5WJdKybqZTqeSP7Germo60jT17LMhBeM89BqWV9DyUWjyLKMoCqms9bmMUF8iTV4cxWRCkWVEOqIsK6qy9WqoxguJqZ4BE5yc4D13HtZxnuqr/PwQZ1DeF4T/HBrtqc/g82nGkBdzdl7fYno3xSr4tXc/xHxY88u/9htUdsLtNz7L3Zt3uFheUtcVIzPywuNbMu5KqXvAAuFydM6571ZK7QF/F3gVuAf8GefcmX//fw38Ff/+/8o590sf//2Gulxht7dQShoN4MN0i/P0PHlwTxZHfHD2kFaLVKhTQbQJHxo670H5qkDP3xbKjHR5KdQM20YkUdJPZoHNZPGYtmVaTGlbg+mMPGAU3Uj4B4ZdO+A+AWebzebMZjPyPCdJpGsOapu9tvWUMTnatuXi8pw0K3DWMZtNmE4zzs4an2ADUKQey2tMQxyn5GlBHCU4N3DDZSHE4tm2VsLeJBHOveu8aJFM5mpd0tS1yNHevMnRyTnn5+csl0qw+MmULJ/SGcO6bamUIk0mpM4ycS3aAnqkLuiGhKrxHrdWmp3pjO/90hcwXUNj4KWDPdIiI6kgu30D+6zkoquZaAF/nIEkialrqRo01mHbljRJsV4jPEkS6qpGawmxu64hyzK6thHmBDHluiTNUoyRDSBJhS6YJJnAfB6YreuaREvf0LpppELZaaly1g1dU6ITTVZMyPIp2il2trZobeNrDiQHksY5l+fnpJnHhOsGEljac4hgmhV0TeeT9b6ewlmqquTD+/eZTeconXBwsC/RmO3Ikpj93R3iJCbPEmGItQblFHW1ZpLOSOKIpm6Z5BPapqYuV0yLnHK1ZG8+5z//hV8gjTVZLHMppqFIReoi9GMSHn8nVFuvYZ/6JIfAgjFKR5i2pbOKymqatqPtLFXdsm4EnoySiGySk3kY0VpHXZecnp967XZFURTkmYh9tdayqlY0dY1zljSKyLKkpw5CoAeL8QvrNElSdCLJ1JAwD/cRjLu3QQOl1ol2UBrJ+livpZDJuVAIJ4SJxWJBW9cUhXTK6mwnEZMbdHmwjhY2nLugta48tVZ7Vk5g1Ml7jM+bdTii/npD444kS6GqiZ5+BdbCDnqt6/idkxmOlPN1yfHpCfNZLh2iepv40cf/L577jznnjke//3Xgf3HO/U2l1F/3v/81pdRngT8HfA5pkP3PlVKfch/TR9Xajmkx68P+4H2KVwp4xsx7T97jy/f/gFa1kmhEEn3K047Cw42swAWSJHX9jTrjSJwm1UIty/Ksv4YxIwVAOcVisQp7iuCM42IWH2LJAxLPZGd3zrXrB+xs75Lnk8GwI1i+2JTh3qy1PHh4n+DUKhOxt79LWQ6e9iAUpHseblFMBuPuBnU/aUiRYrG9YJVJDDX1MJ6ef2SN5eLinK5ruHnzJpfLNccnhzx58gSlIm7fvkNRFMRxQte1lHVDR4TNcnIMhROa2ODFmN6TMcqno1VE4mmbKfCnf+Yn0VHExf/0a+RJxP1c8W1VxEVnSOIMYx1t2/iQ2VNQY4FhkiShtcYnVBPKqpHcSRxL44Y8xznHcr0SY+8LkrIso26aYQybti/g6bqO2XzmOwWJkV+XJVkmGjEaMch4DZFyvSZCKgiTPMVqmG/vooG26SimU6yxtK4h0jHWBCE4//yt51H4NoXT2Yz5dMLMVxO3zRrTtuAEv+/ahqpc0+U5dbXGGUsSxcSRYrm8ZDaZ4CLLn/zjf5RIQa46YluzNYmxrfGVjV7uwGnopLbDezLSTlK5ABVjfHLFKg+76ISm05wvW1ZVQ9U0vmoZ8iwnzWfszhOclzxYlyVVufLJY0uWTZjM50SdSHhUTctqtZJN11+XtUbki5USOqBfH1rHWKsoq5KmazzWnQqFORKpD8mraJ+Xk0Op/p/DWoZ+rqRJQomiaVt5xlr7NSTzwSVJ77Q5Z6W5jhrWf5ACFvlvGUdnLTrSvU0Qdc7BPoRiuIHAyfC6c31eTScxbb2mOWmoWoeLHEqLY5QmCWkaUzclzhlfIPW/HlvmZ4Ef9f/+20hv1b/mX//vnXM18IFS6l3gDwP/5iO/ycFsvtVrqQu3WRaDcoKx3Xv2kC9/8O9pqHGhgMeFEEl2eu2kWzyIoz6QHkEZRWQUaTTHtTE44R9b7/VavICTc9jOkmYF3dkK57sjhY1HKFq+I3kSed1xePrslC9+5+fZ29vtDXdZrijLNcvViqqsqOqKspImAFUl/736ymvs7u4Ji6JraSsosgnGtZRl6RO5GVFkaNuOPJcwVyndTxS5WeX5vgUOQxynQEySFkRJJe27CGPix8g51us1yw/vsb27x41r1zk6OuLk9Iz333+fmzdvsrcn/VbjWNM2HcuqpoqgSWNSp0itlwZQUkFrPdVPRw6tLKYzUrKtpAxeK80CxdbNA3ZyxdbK0GjxBp3SEGkvfZwCRvIHaeY7YTniKKYqSykMMdKcvJgUdE1L23Xkvu+tQlq1VZV47FGccnFxgbEGazSLxZokyWk6S2stxWTGuqwwXYtKcpbLFbPphDhOBkfAOfI8JUnmNE2DBpIokujOh+GtaXBIKbuwoizGOToLibOiruiMUE218h6dlz0wFut59521dKZhvV5S10vyJOEnf+x7MdaxVcQoY8lUwyTTkBVeCM/QWkfTOdoOzx/XWCJC927l6XcamFjJnUQRGKVpnRQNNY2jMZaqaWlMJ/mALCPNEnZnheDGxlLXDZerJWVV9XhzUWQUkykg3ZZOT45871O1yWhxFuXsyLAnxFGGQprdCBssI14llF6YT2sZ51ZpH6X6gj4V9Q6hzGtvH0aHQpGmGXnXUSUVXdeSxhFZGmM6KGNf25JlxHFOFCkPczaSUwsFdkFAzN9H6HY3dJPynZzSlChJPRPI+V4BDudzeNpJstmbP5TWpLMZdrrDbLulamqcg3/39nucrg2vvvYa86Lgyf336Molr77+Jrdu3v1IkwrfunF3wP+sJHP4f3bO/S3ghnPuib+hJ0qp6/69d4B/O/rsQ//a5mAr9VeBvwqwtzMTnMpbq9B4wXmP+dHpI373g9+idGsJZ3xCQjrID02TBXOXUC22QVfcbxi+433KjKYxnqfs+t0XF3oXOs/YEVnd2Ida+AcgLcMSycBn4il/5Stf5fDokM50vP3227z77ntcXl6yWCxZr1es12vqusIYK4UxbihM2t//Gn/6T/8pbt46wBhF0wjHN+p53PSeaJ5L0m0cfgbvJHB6JYOfiEywjzCiWFr59Unn8H4/cKaznBwfk6Yp169fp5hMefzkKc+ePePy8pJr1w4kWZfGRFrRtA2XVUccRUyilBRHYZsNPDIwFsIzDJ3mO2NYxB23b+5w4+4O1R88oXCWJE4ofeMDpSNM1xGlETpSLFcraUqhNVVVkqZpj3FmWUZTizc5KQrW5RqtFFmWUpYlaZoTJwnnFwveeecdaQ4RZYDi4aPHXD/YYzotqOqaum6YTQvBy7tW2DStb8CgNUtf4aqUoixL6XOaZJRdRRxL0td0LcZIYl4UGaNebdG5oCzoE/DGeoEzSQ5WpfDrf/SHvp/b1/ax1YppLIYwtS1v3jlA6xiUQXttebz3d3R8zqNnx3RpTpQUxGlB4uWotRvcHKV9Za9SrLpQ+SuJys4qqqbFGdkk83zCJI2J4oi2E132i4vzvhgnimPSrGA2m9I0jahtrld91BQ82RC9Xp2vzpMPYt/0O3DWQ34rrLXIr8G+AtwnRKWptJ/PtheegL4BzvNHlmbkWU7d1CLJnCR0SvmOa7rPVYHtdfKFjuwplE4cljDXTWDfjO4tXLtQmv01qcCyGfJk4DxdUiISpSDaukbcnhI1mpwcq9dE1Ny6dRvXNrz/B79H4mr2ZgUvv/SZF95jOL5V4/4DzrnH3oD/f5RSb3/Me9ULXntupP0G8bcAXn3ppgsDE5IP1reiO12e8dvv/CaL7qLHvCTh5tBOhR43wtoIF2BFNhc3qBBqpVDxFFyGsw1RFCAZ8crHmXYVJYIrNnUvSpVlmbBEvCJbXuTs7G6xWld8/evv8Prrr1CVJX//7/+/OTo6lsKn1ngxLA8hKYXW8l0SusKzp0f8i3/xr/i5n/tZ8jxH65ookq7zSZTQtA1JJKwAZ5WUojvVF2tcPeI4xrmkZ/Ws12vfWMQHhm4QuA0bqNA4hYv96NEjJtMZr732GsfHx6zXax48eMB8NuHGjZsUk4IoEeXLpq5ZmI4iiTE6I9UWZxTaSXWt5FhFYyOczzpwn3mF9cEWR+tLDq87vj0CjfDsiziiahuiPGXRGFwneGnbNFSVJJMFu7QUeUFdVSglQk6rcg06IkliVqVoqOg44uLyguPjU/7O3/0fcJEiywrapuHf/sav8b/7q3+Zt958nXK5IC8KUJp1uSLxYlut7Zj4LliLxQWTYkLTNqxXSyaTnKYuqZuaNEmo1msWl5c4OpSzmK71Ldr8+CtFHCuKNGeSZmRJjNIG2zUSGcSWeVbw0z/+A0QdKIyPZgHVSX5DiW6RQfTTTW24/+gp63XNwd4+TdvxG7//ezx8esRka4v9vV0O9va4cf0G05k0lbk4veDho0ccnRz7jVeqMm/cuOn7/e4K1bNtWFcrJpPpgEl3LXlReGE1aUQjjovZgIAD5h2wZq3j3lNVQ3PXniwhTtQgQxwcryRO+pqF/ru13sDlYTi3QhEl0mpQHKnNblRKicefZZnIDMQp+PaGcTSmNsq5daRlrJGoHef6XAuIZnu46CB4Bz4fNx4QJ+wZpSSK0jpma7ZNnueUpch24zRpMYHtFlpDbqRHc0TE9vYWxXzK9//A9xAvTlGzGY7/AFRI59xj//NQKfUPEJjlmVLqlvfabwGH/u0PgZdGH78LPP6479daxO2dHSoTcXC2XPCbf/AbXFYXUljkW1hhQ0JIyP8W8WCsE6Meecle76vIFLKQMcNaMRZaDSp4UmjR9d5vURSkSUqapaSZVCEGHYfAH9/e3mJ3f5uTkw/I0oKXXr7LV7/6NR49erohqi+VgAPbZzYTj1K6qChMZ3n77bf58pdf4/u///uYTAqyLCFOEhaXpWDxKhYtlxiU0r7CTQZpjOGH6xPNZ+HxrlcrmroaFg3DliDXJWX71iviWWt58uQJeXHBzZs32d7e5vDwGRfnF6xWK/YPDtjb2+vljbu2ZVU3lFqTpwVJHGFsS+6sbxoRKvqGnMjB3ZsYpTjY2WJ/b8f/zfbVuJlyuK5lojRRnHK2XGA76+mNnWdQzKirCmsdeZ5Q1zU48ZjWZSm6H3HMar0mTgRLb9qWtrasy0oSdArOzsUTBf/Z1bp/dqv1CtuJ8Wua2muNON/Q2hJpTdPUNI1IAlTlmvVySZonONOKRLQxPZOoqhuS6YQ/9lM/DtawO01QTgmVsa0oIsm2xi5UWIrXqMDj9+KCW9Nhleb84pL33n/M/t4Br716C9O1LA9P+PDhAy7WNSeXl9y7/yEO2N3d5fu+7/v44P0PuHfvA5bLJV3XsrOzS54LS+rR44fcunWLL33pSwC0bc3W1rzPVxg75ey85vziomeayBwMM+ujc3yiChrYLP55+xoW7ZOPIbkotykzNc3SPnIFwcXjKCVNc/C9F6S4zpGkjih2IqvbekmLjauQiDJg70kixlZr5SME0csP1OkQMeDMoBnjX8e/DzUU2cEQuY4rXMOftU6E464i5vM5SZJydnpGmsZoH5F3XUOUF7Suo0gst27cZLF+zJsvv4TRa9w0Rl8YJjszalXxccc3Ne5KqSmgnXML/++fBP5PwD8C/iLwN/3Pf+g/8o+Av6OU+m+QhOpbwG9+3Dkir2WBn8gQsaxW/MZXfoXT1TNRSvRl/vidUvvCCYUSpcfg4HgDbYPh87oyscuI3IR11TDtdSikq5NUEysfHsbMphO6rvV6FVJ+niSpNIaOEoo8Y2trSpxERHFClMDrr7/Bf/ff/T9Zl2V/X85ZtIZQADWZTCmKAmvn7OzssrOzw8XlAq1htV7RmY48z3j27JzFYkVRzKXSU+Y8STxusCDHIBUsh9aRn/jy3iRNqauSvpITr3NP8K5CUxA7hL7OUVclD+5/yPXr13nz9dc5PHzG6ekpR4eHVGXJ3v4+k8mkz0G0jaGsS2qlKNIMtAhgaVp5Ti60mINCQ6w0sQKHtGZwCoHQHOArF7QDXMveJKNuOtZNx3Q2B21ZLRZI9WHa4715nlN5uKYo5iwXC3AQJxlPj4495S1MbDnV02fP+NSn3qQoCuq6omkbppOQ4GzJ0oz1Wjo3FXlOXTcsV9JgYrVasVqtpcmGdpQryaNITYRFlEgM2sEsdqTakZmK+f6UWIFpO7BIdKfD8zQiJ+FptdrT+VB+NFvL09M1x+cXXJ5d8PLdl7C24Te+/GU++PABz46OWbYGMwr/LbB/cMDXv/ENvvGNb0hE6xOJq1VJVfqEO1CVNW+9+Snm8znbWzskSUzbNKKmWK6Evtl1ns47RNtyjeJwbXrwgUQwNv6DsiE40khyV8oz45xyfS5MuOJx3xIviiKKbEYUJT4ShjSVLm7GWJrS4Ww08tjH5t1HT4n0nE2iRPjrCpmzSqGJ/EckSo/iGBWgVE8YCIiAdFTTgyH354p0RKQCk2eowYkize7uLm3bsV4tuWhb4dZHqUA8naVJJzigW5a4THFwrWBxWbIf1/zr5ZJkd8YXX3mJd5qK9PAeH3d8K577DeAfeAMSA3/HOfeLSql/B/w9pdRfAe4DPy8Pz31VKfX3gD9AVJP+i49jysigiNa28zzbcr3kN37/1zhcPMW4BoX1Jb6DZoMNHoPyTATEwPtCVc8K8Vi7UiTxHGdjrMT5vXazVoqiyGlbaT6bpAnTSY61xhtWJcY9TXzVnyKOfD9EhEL3gz/4PTx6+Jj79z+kmORMp1Om0ykH+3tcv3aN27dvs7W1JVWoseB7s9lMVCZ9GBgw8q6tOLi2T5rmWKsB4w26IYrHIa0c6oq1F88h6j35LMu49Em70OzCWhmdseel9RBCg2jaWGc5fPaUxeUFt2/fZjKZcHJyQl3VPH36lMlkwsHBgYeTEqI2pmlKVnVFncRUUUziHIk1xMoSa/xG5SQp7kT62Fjj4bhho5LGBFKgopxFRR1ppsCuqVvDNMtpraOq6j6aqhopI5/P5r142CSfYIzl6eGhl6GQ+RNm3uOnz4izDB0Jnp94LDdo1CRJxHK1pG0bZlOhHLZtw7SYoJylqmqMseSxjFmaRBTagumYZhGRdhhTkScKpQzaGrQVimHYWEN1rvFMDOXCM9EDVq4irHWs65qvvvM+j58ekeYZv/31dzg7OxPZByAOhTGeUuiA3e1t5vM5v/M7v9OPi2j0aKq6IU9TkiRhZ2eHu3fvkiQpq9WaBw/uk2cZr772Cs6vQTWaZ2EcRfjMojQCHXonYci9jCJyBqOrlBi8NEmItKIzHYpowxPWHmZTndgJq32xF3Iu6yxlqUNW0s/dgLuHawVcML7i/AkMNEBFcVBYdIOhjiJx9lQ79L51kZVGO1r3dTPhXi0OHUUksfScDTNdEbx5gTPPzk7975EICyrlG/zU/Pr7R7z2ypvs7EbUecN33f0O3nrlNllqeVLMuE/Kb0aWdpbx8uX6hfY0HN/UuDvn3ge+8ILXT4Cf+IjP/A3gb3yz7x59wk9ITdmW/Oof/DqPT+9hMKBsP+FDUwQ5VNiIcUq0H/BJHIfzVXROui1FCQlbdLUhjjT4tnYh4ZimKUpJp/o0TZlO5yg0xWQiyaC+0YQDB1meSZempmU2zbn5+i2+/O+/wh/9Iz/Myy+/zP7BPltb20ynU9I08ZIEXgdB2Q3vW0qm6RNDURQznc6BiPPzC5SDOHJ9I4uwWL7VIzB8pAHAQMvqx08LHS5RkfDKrZcV8J6/dEJyPH3ymPlszkt37rBYLjm/PGe1XFJXFdvbO2xv75CkCXEyE5G1pqSsKyZZTqYTMg0oS+pLhZUTfoF1eOU910cSQTHPWNMvDnxXmzjW5LHGIIYySkQzu20rIqXY8sm9pqkpsgwFVFXJ8fERPqgbMhVOcXm5JE1TqrLEGkjzmLaTphjz+bxfeFrJZug6S4IjURZtW1JlSRJF2jWkyjLLlMQi2mFV5AXrtCTWnMM4cU104nrj4LyPr4wheCyR8rrmDiCicRFl1XGyNFy7/Rr5/BrHZ6dsmQhLhj079fQ8X3rvxBNUkea111/nvffek1H0Dk0cx2zNp+zs7HLn9m1uXL/OdDr1TBjZANIk9RvdmtbLMgRDHqLoAEE4L1kdJndPVgiQW59ItRtGP47iXhfdWYtToc1hP4NJkpwokpxaKFyT5KbrnRFvRvp8teoTmfTrRs4POEscJ/4DAboZYJRwnZGORLmzbmhdR+wTvl0rjT80kiuIfOK3s0JVTb1MiXWmz9E5J7LDof2hs7KPhKRtz5nPr7NWc+bXbtAVMTfyfV7am2HRHJwdcq9esI5SnHFs79782LX/iahQlcNhO8Nvvf3bPDz7EBLRW/Dz1IeoopeBUr1GhGXgkCrfzswARJrI7/TaZdBF1E3FpCg8pieTMMtSptMpxqQCYyQpSSIJzxC6y+J0eO0AvvGNd4l0x51XXuXll++QJhE/9EPfN/I4hisKhju8HhKYIcMOAfvu/L2JN5sXOUVTUa1adg8crTGcH8c427ufH3mMvXmlRFvDdC3G+fJoP0694fSGR/pZOF82b/s1o5BE9uLygroquXnrFrt7Ozx9+pSqajg7PWVdrtnd3WM2m6N0RJoVRLFwta2DLk1pk4TWGXKnANM37kgTkc81NoiqeSE16JU2YdCVcb7AaxJ5PjY1RRJjnaOpFyRdRxZposhStR0Rhsb36hySDnL3q+WK+nKBs5Y8Sci0tGDLY02qHcrUpBgiDHFbEWvNfJaTxBpo0QnSwtEIHzqMa/DIrRXhrB6GcAikQIDFZC5qP2+NsRAlGJXQWMeqkSR0YxrWZU3nNMV0Rj6dsX/jBiBdpJarBednp0JlPTnh4uKCtml5+eVXqHxR2B/7qZ/i8ePHtG3LzZu32NndF6zbz8Gu63yi3/XzSHI4IaoLLJSxURVDLZLLUigY5nSo+B4aqbveU4ahg5b/Yy+5PT6/UkJh7BP/oz6wYYMYFyzJd42hoWDYh85T489YzEYU0n/Kny+OREIgdMsiirBFQWtEIC2OIiZ5IZtT10rxoGfx6EgRJ4FpZPo8jWgmJeIkjrjwSsd81x/6HpQ1TPOMREdo63A6IkmnvKbOODVrSltRG8cbKuXXPsYOfCKMu3OOdVfzu2//e9578DZWt4Kzg8caZc6oJHBjZBYYBU6L4Qn2zik8FqZASYhamG1v8YcWVZGWZElRTEgSSQ4qrA/V6JOWzrnByPlJ8+Uv/y4/9uPfx927d0GJdOt4WW/ifCFDNITg/fdeeWdg1TgsKCc48Krl+JljOs+I4o62HiosVfj+K5N78Jr8qYk8VOMnrQ+JA0SDT0w7LyfcLwYn+QLx9uX7qrrhw/v32d7Z4aWXXubi4tJDNQ2Hz45ZLNbs7e6RFzkuNpBktHVDVTeUdUuepjRRTK4UxtRExkDnsy0OrDMo5fokex/WByXNrh1wXKW8CqZGaYtWUCQakhSc3E+cKiZpzl/42Z/hN3/rt/n3b7/L5WLBpJiws7PFG6+8xDxSZFMpgoqUNGZ2sUZZaWS+k0bYNIhjQawBZ3zSz9E624+l2AnP1cYrlAbqrtdDUWiELi3J7NZCZyMaFdNqRV1bqq6ULlUuiFmJYVRh1mhhhDhrSZOIg/19bt28wWc/+znaqmLr936X9+uG5pVX+ODD93nrrU+hlOaNN94kz8VYtq1htVzS+P6xfbWlc75X6Iq7d++wo3aI4wxoieOOLjRNQbxs1a85i3YD1i8etuuL8cJnwhy1VpEmKUrHQNQ7GiGKG6+h8OvVvqHyvQPBwHljofx8xg1zffx9g2Nl2cCBNg4lmH8irQuTJMX5e+m6TlpfJqlv9i58+zROKYoJO9vbGGN7Ib9QnCnUx5wkyaXfxJX7iLSSaDfyJG+lUCrBGXjr/Se8fn7KKpONcfbBxUdctx+rj/3r/x+P33/393j70e/R6VZgEKcCQ9EnlcJO67yfE15T4lHrAVtTVjxCcEQuR5vctxdLe29AFlpMmuZSLOUNnPZUJdMZxgZY7IxcQ9t1RJ5B0/lqOzaM9aAWGbDGq9j4R0ErgUXgrMW6Dq0ddd3R1ik7OwlnJzVt0y9xlJaGCGNvZ/z98lPLmPUejdzRcH9a8EqH7/AEIakZDLsMs4TUEZqLi0vquuH69evcuXOXw0Mx8MvFinJdsbOzw87OFlpHxGmKirQkLLuWpoMyjohUQqYiCu1Fq2yDJw7j0H31pBj7+IXjFkL0MD+CkbVe+thagfLeevkmn3n1T/AnL1ecnZ+xvb3NbDaVsFqDk5pJ3/1INnQVaWH8WNk4nPPNqa08Y629/IPy+kRK5p11Iuur/cbedcKTFn2clJaY0kjeZ902lK2hbIyXPQjerCSPutaM2FH4vVyTxqHpuuk558p7gbfOz/nL/+Kf8+7dl/jbn/88O1/4ThRStd22bd8msWtH9MLRvKnrmq9//eusViuyPOPGzZsoYpSyvqtQ7SVswVrJFSnrx9+vACkyin0kNnjhwzMMG0NEFGcCTVlvdqPNOfyiY7wRQTfYArwTNnKi5GuurL+NX190Hp/AjROSJKOzhjROsVra8LWm871n8VXDUjm8vbXN/t4ei8WCsixHa8yDP1qT55NhnnrtKqUUeRSRKlC2xRkNOkb4WYq4a5l8+R2K9x6yVpZERaT2ozYlOT4Rxr2sS/7g/u9TKwNRCJt0gMywClF39GGv9Z4QDpGlDfCMDUprUrihHWRsAxGdMRRZ1Pce1ZEmjjVRpMRThuDmjmhewxE8+FCcMZ1Im7xA0bo6PYawcfhdeq6qXrsivD54NRIxPH70hGfPTlgt17zy0h3hba8qnEuxRm9M+tAsZPO8m7+70dV5ZjHeRdrwjsMUbBove+t1p5XSOF+VGGnpMIWz0nDk8WOKYsrdu3dYr9c8ffaMtm04PT1itTxne3ub+UxyD6FLVdd1tE1D2baUUUKZJN7IxkSxJnGGSClihddi6TzIFXIqiEaPl1a1anw7atho/b3La+KhHexOONibyqsqwrjgscqzMp3toyJp0ycLMPbNWHQ0zEuHdMJqfZMHrTTWmD5R57Tg5jokf62jLg1VJ+qhbdd5obuIKEqZZQV5lhFFEffvv0+eFzKXowAb+DvcEK3TnkIomHXbthw8ekhW19w8OSarKs6UYr1asV6thFnkay6kSnaATMKcf/r0CQD7B/s8e/aMb//cd/TRnvbNQMKc1Z4xMjgTgyHvtV9UaOYc1lnUR19hczZeK0WPNoGrP5+b1/05xzDM2IEZou4BGx2u85sdwWGI45ioFQPutCaOYoq8wOEospwsScmLCXkxEXG+oyORPxkuqX9+QRPGeRhKqJaKLI3IYoWt6l44r79HrWnLGnW2IDOOFkMOpOgXX7g/PhHGfVWvaG0NWKwSSAJlcWhiHaOsxXZWPCjjE1FJPNy8gshJww0saAvaGbRK0Iimech8S6MLSaimWSI0SIzs+s7TmEKSgwGbG2Bz8ZKEe9v6Uw4bwXjSjbvBoIQZ4Jwk6IwxtG1DVa1Zrdc0dcfNm7dZLkveeecDTk8uOT+/4Pq1A+JE6FmrpfGQ1NiayzV95NFvHsP1+cC3N3we5cE6ME664lgrBk0hUATKorRESKFcPmCVy+WSe/fe5+7dO7z+xmt88ME92qairTuODtdcnMXM5jtMZ9uieKlj8klCYmUTbbqGsq6ExqqkQCtNUrI4RkeQWKHCRU5yHjKuiggljdxkt0FZuVarxflzzhKDf95e98NDXiCaRqFJQ/+cPVYajI/MCx9W+4VpvPiYs5pOQee0GFwt56mNojUCsLXWUXU1dddiPfaqo4R8MmGaF1LpnMqmV9c1VVNTrtccHx+J0FY+RSndJzt7Noe1dNb2FdoWn4B2jq+98SZ//yf+CA9UxAcnJ30j5nAozw+WnIBl0yFwXFyec/v2XZqm8nNDCd6MOERlVaM7SayOC4/wYx0O8fIlJyA5FiluU152QanIOw/B6/ebg9mcz0O0vWn4B/lt3T+74S56DPKq035leYzG5UoyOPxNay3JZS3a8VmaSWJZwWw65drBNdJUJJVXq9WVnFe4Xj82fi066zDWSjerLCeOImzXERg/ciEy94wCYk0DGLQoxiK/f9zxiTDuIPrleM+A8IAtRLEYbDpL5MMrB2AN2ntuEhobiLTH4CUMTtSMRGWUpiLyvTXpvQ1Fmib9JJB9VVQRs7zg7OxErmwDbhEfv8gLEbTqREMkbDC9p+4jDGOkN2O5Lrm8vKCqaqqq5t69ezx6/JjlYom1kOcZe/u7/MRP/DjvvnuP+/cfkOcp3/4db3Ht2h5VVfdGeYxZvuhQvZcQRpZ+oxov741Yw7meSRMYMtrnJIIUhFaq5yCHMes66SyEUjR1zb17H1JMZ1y/fp2urTk/OaZppcnCujwkOr1gOpuyNd9ia3uLVKcej42FO93hNbYtputYtiEoFQ/eeow6S1N0FAu1UoF2kb8j43vBql6+IQpGGknOKz8eup9LCUoPiW/nF5Nz1rNZJFfRWUOnHDiBD1pjUC7CKIVREaYxtF2Lc4amEx0gNN4oSGOKbDoXpUArToT12Pbi4oLlckFVlnTGkHhqp1aae/fu8fbbX2d7a4sbN25w69Yd9nb3SOMEhdQohmeHv7eFUvziy6+Klo7vIjY2Vi+CtqQ1Ycu6LFksFpgbEsEkXmlUCEzifUc+kWgsPmfjayhGRk1rRRxrFBFdC0mi2dvfYr5dcH625vhwjVKRZ628GBgZpueQBO0jlRfcx+CxD3N/czUM3/dR5xn/OxjmIEsQzhvHCWmak+U5d+7cBQcnp6e0neGjoo4xjBSoommsyJMEhRWT5cR2OWUxYb1qidRIE1yeCniYJrjWSXfejxm4T4ZxV0AsE0X47FKurDqG4qVI3mi1wmnpdKSc6kvbcaCdk27qSuFchDJzOtthupbp1pa8zbl+IQcNieDJoqQdXtNIH8zncDrAqYj5bAvTWL7x4XtcLhbEsZQH37p9A2M6fv8rX+Xehx9ydHTC+fmFZyfcZDopmM8O2JrtcPOLd2jahtV6xenZCdPphMmk4LOf/TY+/em3KMuSo8NDHjz8kGsHN0cTdfDC5RiLJDmc033yFMRDCOXh4q0NJd/Dsck+MGbYRHovxJdcOx2JwqDz+hrBi1XgnOby8pLT01NevnuH1998i8PDZwDMt3aZzrY8e8ayLldU1ZpqvSaLE9IsI0ozsiJnMpuActhOrjE0QsAIP75uDdo4StuKF6+8F9qBM8I1ls1JKj1heJKdh9ySJBHWgpKchXGGEMJ0XYu10trOKcFzh9614nG1XsY2iiJfhOe5+XFEkcB0qnsNouCdWisJtnIlyokrb8yVkn6l27tbJEnC/fv3ccbiNEwnU+bTGcdHxzx5/ISvfuWrfPELX+SN11+XylqtfHJ1aMRclmXPmtne3u6peP3T1sO1aa2pa6myNbZltVqyXq85Pn7G9vY2+/sH6MivEScLUakIhWjCWJRXMO2GDTaKSeOENNFkk4SDg5wo7rg4X/LBO+fUtTCikiTr52K/OVyBETfWXx8Rb+L3V43yxqHw9uCb4zBjg/6iaCG8Hsdz9vYOMMZwenrRSyP0GlQjg3513EGqjXXsyNMIRWjk7STtpXyrQqUlnxZpnI9MoyzBRo7s5et07z0hvXkDnhzyUccnw7g7KQBBacHEnRM4BucnrhjzzllPBZQwGCfypFY5Es9XtVrcucLOSdyMpqtBhY5B8vAi740oNW5V5dAa1mVJXZc+VH8xpvXqK3d5+OSIr37tIVVdMZ/nvP3OPb74+U8zmWZ84xvfIM1y3njjLbJ0glKKO3fu8LWvfZW2NVxclPzyL/9L1us109mEV197hU9/21scHx1xcbHggw/u8Y2vv8vh4RE/8RM/wsH+jf4a3XN+yCbeuPEXpTxk5JPRgdURvmU03wW/HbDI5xPAL/CUvGENRq4oJqR5QZZl7O1skyQxd+++wnK5YrVecnp2SlVVtG1H2zZoLd6xDtfuMf40iUWFMMk2VDjTNOk9vf6afFKqswYbSZNjSVyGhW96jnpofiIbmMFpTesClVZ5vRBL14nhDoUqSisiInQSONjWY8uRL0zzqqR+zIKxLMuS9XrN1taWRIRZxmq1Zl1WtE1NnqcUU9Elb6pKBOaahqqqiJTmwcN7ZGnBj/7oj7JarXj69AmLxYKbt26wXCxYLpc0tuvHKhTJPHnyhC9/+cus12tu3LjBW2+91T+j0ECmaRoWi0WfMwqFdffu3evlM5qm4ubNG33P39AEXuAW1U83qfRWWGOI4oj5LOfmrT2KIqNtGo6PLjg5u6QznfdDFKhNfF2c7sBc+WhDHPJhAx0yzIXnP/NRf79KOhgfAaJ7Ec6vlPLt/QrZnFerfuMe5L/1c9/XN/Hw35vGXonT57X6qMqvMesciVLSkzmKeti0zWPqNCIuYlpatj73Fjz56keO1SfCuDvou5c4BxjPcdaaQA50EpcP78HvrkZETUkiLAK2RgoUObaFpukoisJvBr6AQkGaZaOHOAy+9CkVqdZxTjWAIlop0iwnLzLOLo54+vQJ+/vb7OxuUTYlN29f4/adu/zqr/y6z5gLzWw+n/Pmm2+Q56Jo+L3f+4c5ODhgPp8TeVmBcl3yT//xP+PRo6cAHBzs8+orrzyHiT5/bDbKvTppk1TYCMZYohjiNCaNYrq29s0DAiVyqIzc9NyH3EGkpNBrMp2yt7dPUUxEnTEV9sZqXbFYLnj67Cmr5ZK2FZy58zxp2STkO6PIoZPQZNyBEY+4rRyLy0tQUY+rWmulUUle9Dok4oHGvlGweOx5kZMX+YZWjjFdDy9ZK5WWsd/chVMvkJMxBkdIpivfGHswItY5uralaaVc39qG1WpF10oCujPWK0A2vRFSSnN4GFMUIrx29+4dXnv1ZS7Oz6iahsPjE549O6Rtm94LLSYTTk+OefrsMZfnCz7/+c/xbd/2Jnme8PDhQ8pyRawj0iwmUTFOKS9rIUJeb7/9NnmeM5lMODo64o033mAyESdjvV73Dd/TNGVnZ6fXCUJZvuu7vovXX3+dtm3Z39+V/gAe/jT+/oIBtMHLdkL5zNKMu3cPKKYx63XL6sSA0TSNwDNx5CTJTILWjihJPM7ufIQltNarBUXP2YsXeOsvwsvHUFX4d+h+NMztF6+ZqxBWGM+mabi4uOibZ1816GGujj/bw0jGkMSAsXQd9JfiHQzcSE5EB7aaQIjKKqoipqVjPpvQKoXa237h+ITjE2HcAd9tyQ7hiGzucnNW+R1f42IlEE7QsVC+NBvxa3VnwGUolWNMjfPNk3vrjHhpUpU6lEiDtPSK44iQgHw+xAvMZsfe/pSf+U9+lK5tUVo6uTgLZ2dn3Lp5kx/90R/po4I8z9nZ2WE6nfW/d13H7/zOv+ftt79OVZd8+tNvcevWLX74h3+YR4+ecPv2Ld5443Uf8lo/QT4+tByHrePfw2Qr8hxjOtpWeqrGPnE44PkDbOVcoG3lZFlGUUyYTCbMZ3OSNAUttMDjk1MWl5c0dd3j5WJAfR7Dj2Wc+MbUPpnWtDXGNHRNC0ixkkK8P+PrEKJkYIWAwDPr9donR4fq4qLImc+noncznaFQLC4XNG3DyckpZ2dn8qxB2hxa0Yh/6aW7bM23cc43oV4sWK2WAsvZbrQZWZ8UDL/DMKECFAayyTqGRLq8z5iOxeKS1eqSBw/usTXfosgLJrMZd+7c5fr165yfn/sG52vapmF3b4/v+Z7v5exEtPWXS/Hcf+3Xfo2trW2+43OfZWdnh64zzOZzkiRmvRY45vT0lNffeF0EzXyLu+Vy6ed43EcRSb/BhSsV47e/v++lOVxv2CPfjCKKYroupWmqPkHsnCX2DZsfPzxFR5rJTISxtM+jiU+le/UoaeUXD+d3gdm0OZfHa3DssV/1rq++L7z2IljkKswyPtdVyCd461mWsVgsaJrGOwyytseRRCj4ehEsI46IaOE4i8gfqM37tU6QCmn6rXqqZJDN0N92l/b3vkHkFB2adV3zcccnxriLddb9bq6UD32dpnUGF6vewCk3GFmQSaOsCE2pNmIS75OSUnaiDhhYBABRLJKRcRz1E3cMawQOvNskwspfPTZorOXD9z/kN3/ry1is9x5jtrfnvPLKy2gds7O7xfn5JeW6JC+k/drh4Wkfyl1cXPCP//E/o66lS9C9Dx7yfd/3PXzuc5/h7t27PH78hH/5L/815brkp37yJ9FJ1Cd1P25Si3a29I2VvyuUdhjbUtUVgxcuiUjtq0EFGxZjPptteznUhCROpZ9qVbFel5yfn/dKiH2CKNL9IsZaYi0a8sLZlu7v1hnapkRZ6V+ZJ14JD0frNxxjHDqOKbKM2HeZMaaj6xqvw54ymUyZzWZMZxM0iul0wtbWljRZb1vuvX+P5WLBaulpf0oMmvW5gbJcYjpDE5U8sJ2oe+7uEacZN65fYzJ9lZOTYx4+fMhyufD3iB/TEMpdZYgEY2IYDDweuglJR9kEmqbm+OSIUGSXFxP29q6xv3edl+6+wuXlguVywcXlOevVijyfib582xEnGZ/99s9zfHTEvfv3+b47t1gcHoI1nJtzqrphubhEKUWWpkSRYr41Iy9S2aR9sV64B+h3Ko95W8HAFaiQc7JucIqUApQobkaaprX95t1ZXxnhaiIXs1pe+g0hrDOp39Aq9BdNiHTS9831q3OAZ3ixh34Vx/4omuSLjl5Th83N40UbiVKqb5NpjOHs7KzPs4yPkL8ARg2yZWw1RhqmOCextTFgVS9Z3hde+mtIdISKI9AiygWgnMK2IiI3efkNTua/QXd4QRrFcLD3wvsMxyfCuCuUbyigcE2HjaRBr1IKXKC6efFH4XyRODG2NgKdaWmRahxaxVib0nRikLa2d9A66gdd6YEd0NMUkQEOrbuq6qOlNMMEe/zkCb/yK/9GvsM/8C988dO8+ebrnJ0t+Je//K+4d+8BbdtxcG2fO7dvs1pJR/twrs9//gvixRUF02lOlqc8ffqMb3zj6/zO73yZOE74Q9/93QIvjCbhR3ktoRdswNivFlKFI01TJpMJW7M5k8mEyWxGHGdU1RJjOuq6ZbG49LjxiqZpR1WGw3cHDBccXdf6a/OeGni659qX4AuNMfEYYtvVXk5C1DijJMWkwmhqu46mbYnjhCxLmUwKptOZaP5oTZEXNG3D6ckxp6dHlKVsNs454b872eijOAatRqGy1w1Xqo8STk9PODs7JStyrl+/wXQ24bXXXmN3d5fj42MODw+5uLjwnns/4ldmxaYYVsiDKB9dhhqnq8/EWsNle8liseDx4wfs7Gyzv7fP9Rv73Lh5na7rWC0WHB8ds1wtKYqCvf193nj9dcpyxWKxZD7f4v69Dynrlu3tHRaLBXVdc3h4SJolpGnC3t6e5BVHc11gkAFyc6PbUgzXKsbUjqKTkFSUhLXzSe++GYmi7x8cXpeWib4+pdeZ0Wgt3cZCBHEVr76y8jbmuhsZxj4Z6/8Qns6LsHU5/2YydrxhKKX6hh1JklBVFWVZPge1AD4PlG5Ah/J9fh44iJQD5TCu7bXfnXOeKDLMhSiKvDzt2GkNz0Og5C4vePyF76B6cMLrk4Juf+tjxusTYtydcziliOzY3WGQ8o21TwuCsrZnjCgFERrbGL/baxI9JdG+hyaK0ADXOVF5076xw4sefAjBXvT6cFiMNdy6c4tv/47PcnZ2jo7g1Vde5vt/4A9zdHTC//xLv8zl5YKdnR22trbY3d2lKCbcvr3FZDLpMWPhvcri13oQVHr11de4efM229u77O/tY53nWHtu+lX4ZTyOsiEqHFGPS08nEVtzzWw6oSgKJpOcOI5o647F5SWHT4+omoqyXFJ5jXTnK+esHU/mmCzL++KmcLRtOzxH50afGUSjRMpbMG7jN1XZrIVpoXVMlOWkWcL21g67O7ukSXiOhqqqODp8StfKBlk3dd8RB3/PVgFRTOwbmrseQ7Feu1tjTNsbLV8biHOOcrXmww8+4MnjZ+zu7XPt2jXeeOMN3nrrU5yenPHgwYccHR9SluvR3AiJVf9snLwWLsk6BcGYjQxj/7x65pMkLw8PK46ODonjmGkhOY1JPuWVV17BGsN6LTzqs/Mz8kK41qYzvPmpT4FSPHz0iPc+eJcoiknSCKUst27dQikp3MPDb8MljFkkYnBl8+4255ZT9BpE/h60joijCFI/ElYEBJwaCqtCkVJYU4JTyxxN0wytI9+9aT0aG0estWwefiPWPmnps0A9A2aIQqUOpAdYezs/vjd5LtIYe+DGjz135XMXW1tbVFXF5eVl742Pvy9460NOx2yMizUOjCHWwoKqa9Gc0dEmNh8goT6pygs2Jv/slHPUOI4+9TJH16+zPrvDW5OhGPJFxyfCuAPozqKMw0TCWlBO4A9tQXVS/q20wkUag/K4pgTBSmt0FGOdJmWONjFtW5Fl4j2Mkyw4R5IkvfEKh1LS9mz8MMOxaejBOMt0MuHnfv5PEpIDzjnOTs45OVnypS99l5cLHiZ4iD5gmPjWCvtH4StyPW8jzwuKYkYcJ8MDd2La5SI2rytMhDiOfRIwZjqd9m3KnJMuSxfnZ5yenlLXJU1do4n6LjdlU+Jch7V+n/TJxCxL+4kcWCaNx62jKB4VkoR7gAE6UmjtvTUf3gdsMU1T5vM5s/mcLMvJs4L5fBtjDWfnp6yrNYvFOednZ1R1Q1XVdE1Jnnlood/kHVmaCw1QC6YrnPlhwQXBK1nYg/gUI6Mr4ylsqfWjRzx79oxHjx5ysH+NLC/47Gc/S928wSP/t+Xy0m8Uowfi7338uwvXgHvBvLpqgOT3pmnomo7FYkkaZ2xtbbG/v8/BwQF37tzxxU4lh8dHHD171jdrvnnzBt/+7d/OvXsfUlUV167tc/v27eH7h/TS6JyDJyyB8vCGMYwxvq0NmqCfkForaXARJz1mPE7KJ0nSM3OCvkrPcfdjYK10r+rapp9nQaEyePaBEKE8xq21JlKD56+1sJuuGknJ+44L+jafRZZlbG9vb0AwL6pSD/LSYf0Gxt3ms7VEkfU5C0WSyPofb5hhQwgVuuH+w7gKu8v5GgwZ22kS8/23b/DBbMXRjR1eT//Xa5D9H+5QQARGAzgi44bwyk8a5Y1DjOheO0SDXMUyiaxxJCbD2pTWSJi+s7uLfKPPwWsp5Ravc9jNAZSHCNpGEqPi/Q764kNIrTg/u+RXf+V3cU68kTffeout+TZYw858ju0Tb270OREyUiros8tiGsSDQiIuPGjnQ9qWJIlA6eE6/SQOUcA48SNJNCkOurg8p6lr6qZlvVpSrpdi6DyLI9KKrtOCcxcF1nZ0nfUNghOMbelMRd0YrHF9pa8YekMUDQvYoTFOfqIDdioWQSmRRS2Kgsl0ynw+58aN68znU7rOcHFxwWq55NH9c07PTlmsF76M33PVnSONFHGW9pv0eDG1bSN1CUpC2575gxfydHbDkG5GPKHK2Rs/63BWDOyzZyueHT5mUkw5P7/J9evX2d/fYzads1qtOL845fz8nLoOGiLivQc235DPsQOO0M83we11H10EU+s1yZFNtmlbjk+OOT074/79++zuSuek7d0tru3vszXbEkpk03B+fsHnP/8FPvOZz2KN8ZDByKJvwBNh4YXNT/emPvQDcD7Ssk5hkXUoj1sTRRlR1A0cb8T5iuMMraU5u5xHDHqI9qxt0TrpO5uNn4fUDEQkaYrqXRnXd0FyTmoMgvSwNdA1LcbUG95z+K5AZ43jqBcKFMatQ2nXO15pmjKbTrHGcHF+Ttd2qFEnpTFjJjgzVw0yzmJNi7aSfMbZvmeEvM/08PCYuTOGo67CREor77WrHlIropRPb0egFLG+Cg9uHp8I467AhyyR5xpLmI12ON8YxdpQfqNIkpQ0ykjjlGleMM2mZNGMZ4eX1GWMbRt5CMZ4CMA3MVCKKEq8cQ9Jx6DvHnmMrR0wM67idTK7u87wla+8jXOO7e1t3nzz21BKo0IVnxtgI9jEyOU5jsXEgozqJo44hIBSxZfnObu7u6JM52C9XiOqloVvxr24gvsNG1fb1r33GjzsAX+VsNL4ZGwURVR1TdeVWNuAaomjFEXEiz3P0UNEoi3XwXSSszWfezaL0BcDE6lpGh49esTZ2Qmtr2AN0Zq1dugor7zuj/OhqdoUCOuvx2uYO2sxXdhsBv9ZQt8hpB57WsP3OKx3LsQoezFpp1guF7z77oL79z9kb++A69ducXBwwMG1faqq5OzslMPDQ9brlTcyYWy9U+DcxlwYz/uAllyl+GovmTBEnZa6rnj2TIrCkifC+5/Nt9ne3uHOnR2SJOHp06dyLasVbdN6h0K+147GTTbOaEQZHXxZ2VgG2rFE0M5Xj8vIiiGOh+vtjfEmVNjfq3c+xn1GP/oYPG9QfQ8HsRNRD/NghzkQ5n2IzJwTZ8QaQ+O9/xA5AKhIeyfjBjjHhz7aCbkkHWnfq1WijKIoeqE2GKDIYKBRCu066VHQhUrvmGFUN+fdVY89HBt5tWGVIqKG0tAEJ7pZVxv3XD0+EcYdxNQqbSEKTW8h1gl5kpLFOfN8yjSbMCtmTLMZk3hC5ku7FRFnFyWHTyu0kj6EkuijjzfFN4E0zQiqksPAK7I0Y3d3n+Pj45HRGK5vDO1cu3aNn/7pnwbo+08O7wOIGZp8eFeux8MJ7pE/gXgT0hQ7piimnlM7FWMeJ73H3HYty+WqL5AJNKyPYw/IhDcoFYx78IlGnqaVsqbA0bZWnoHUiane+AGYzkDsMWWvD5KmUowjm08icItvKXh2dsKTJ485OXnGel3SdS113UjUooYCjhDijxPUYUCdV3YcDFNIPMmiCirFw70Mxn2ATfSwiJQYr5DT8fbKt7frwYR+eoTLaZqaZ8+ecnJyynQ65caN69y4cZOd7Td49dU3aJqae/c+4OnhoeeSy5UYa/rGy9oX34nh91WvOFAimaH6JGcI0W1/r7LEJX/R1i1NXbG4XHJ8dMx8vsX2zjb7+/vs7OwIlr1asVgspN6iKrE2OC4y/60NMEnwLkfGQoX7lgJDa8N8lesLzW3C87P+uY3lAcL8gzHFUCpcQ75i+E767xo+9xFHD60M833sQEWxdEFK86x/lg6HNdJDIEkSbty4gdaa5XLJyckJTdv03npnjW9qbpnNZn3SdOxcBDiz61rarsI2FdoaTNuhvY5V5yXHQzs+B1hnfQJZ1s9wD5sVsZvOhw8q/WYWRdEG9PRRx7dk3JVSO8D/Bfh2ZMb+ZeDrwN8FXgXuAX/GOXfm3/9fA38Fsdn/lXPulz7+BJpZPmeSTZlkU3azHebFnElakMc5aZzKhHADzhqMgbLgnOLw2SFVVdM0YvDyXPS5GVeO+UTOVe9Cvk/7npir53DQ8fvCd+3u7m54Av4NMulGSnkbZwoT0mtVTCZT8onAFDs7O1Kp6BUZ27ZlvV5TVQ1t0/aJG4GKnp/8L0oQDycVZkbIM7hgXUbFT8GzD5Mr0sP77EjIKU6055XPmEymZFnB3t6e9DZVipOTI46OjnhmnnJ+dk5ZLkWAahSKysIeNtfwLG0wzG7wGsfezdWFv3GnfryDqJe8Fv4Y5Bj8d/qkXL+Z4OUU/OY7dAvaPG+ItLqu5fLynMvLcx4/fszNm7fY39tja3ub7/iOz3P34oKLiwuePHnE+fkZ2KEwavDQXV8EZF3QurEY6/21XldDfvbhvYOYoZTYOWibhpOTE07PTnn8+DF7e3tcv36d2XzOzVu3UEqxWq14+PAhJycndN6jD/clHqXPY/mo1ffEYWhqPWj/j6OQIYqSQqaQaB9HROMnJdhzgDboN5qN5/pctDx6zP4Z9UYT9dx7xv1dez8KiJOE3d1d5vM5WZbx9OlTlsulb44dbRjVUOMRuOshFzfevAQLt6iuQ1vRQ1JKerIqZ6RiN4poamGbqSgmimOsl68I51GjYr0xTDP0NIZQbCewqNp430cd36rn/t8Cv+ic+zmlVApMgP8j8L845/6mUuqvA38d+GtKqc8Cfw74HNIg+58rpT7lPqaP6naxzU9++09L5xGliaxvyuF8ybixfam7taIBotHSUFlBWVccXwi/t2tbcH7CIp5cqH6No4gkjiTUDx6TP4wxLBYL2q4l9Gp1I2ytT4BuQAJh4kPvgWxg9HLeLMsoJhO2t7aYz8UT2NraIo5jyqrk7OyMp08fc3l5yXpdSVs3jdf/yEnilD6R1OO4wxG81X7hjTzfsPDM6NqVDRN4WFwDRDSUQqMgy3KyrGBnZ4+9vX0pLoojlBIGy3pd8t5777Au1z6iqDCmI01zz1oOVLUBphjGy5egOzvcU++5+8yunwM4b3AYDEfoh6pwAud5B3jkdPtD6pzHUJt0R7K+clmophIBhDIbB2qgNo5LyBnlYhaLCxaLC+4lCXt7B9y+fZudnT1ef+01XnvtVc7Pz/jw3occeW8+bGrBuFonypPO55GU3/Osx7xCV8kg/Omcwyg/GOB1yeVD1jrKsuThw4c8evQIrXXvOOzt7XH3zl0O9vfp2o6joyMWyxVdK2JnsgYCS2ao9xDueZjTg9MCwgwRqKIDBXESi4T2qHmG5Jrk31EUkWc2IP2eQeXhr37KDp48bEai/bpTwztdgDXHEIUb3h+Ooih4+eWXmU6nPHv2lMePH440YUTLKjzjACUG71ze4yO/UUN523VgjSg6kvg2fIrUJ4p7Mb449vmIBD3a/GyfS6CPBsYGW4Vd1qm+hkX1a1SPpFNefHxT466U2gJ+GPhL/qIaoFFK/Szwo/5tfxv4l8BfA34W+O+dczXwgVLqXeAPA//mo84R6YgiztF2MCqy8BTKA7DOiE5a0G0PLdrQ8Oz4lFbsNaYzFEXBBu4sWTXpNK5V30CgH0CGhI/AJ2PPI3zFJs9V/r7p7cpkFzng6XRKlmVkmbAdxlhdWdU8efoOy+WCslz1bIBxBh7feE15nmwQrhqHbuDhhTCJlPINTjYjk2GhAv2WJjRHpWXAHc4XMU0piinz2ZYvfhFWi3OKpmk4OT7mcnHBei0CU84NYyMeuPOd7OnHMqhSojbD9T4E9fdvx4tSyeIP+LNsbINn1f87/O73Wq02C9ycC0JxfkHaAR5zzgoU4w28PHevxxe+cHSu8XwYwnT5e9s2PHv2hKOjZ0yn21y/fo1r12+QFwWfeuvT3LpxhydPHnF6dkrti8mU1iKpwbBhOMIw+Z0sGC0bnAXtja0a3aMvDhrdd8CYT08l6fvg/gNmsynbvrfvyy+/TNdZqrpiuViwWEjeJmjpyExROCRBLRDc2MuWORTkscXYxx5yGRhKfgYOm7qHcALnu4+mtF/dTvnveLFhH7820AnHeavxhkJPPLh27Rpt2/LOO+9weXkJdEOvAhciFJhMJj1DaLODlN9YjcW20lBI46Tvrd+4wlzowlpE47Bor4101XDHsWYQ7RteH7xyWRNdJ3Km1llpHdp1qOjjmTLwrXnurwNHwP9VKfUF4LeB/z1wwzn3xN/0E6XUdf/+O8C/HX3+oX/tI4/wuMaLKOB9SkmprtMaixVPR9F73peLNY+fHknLsNUaHWnyIocNQymLPsuywdC44cQhMRmy2f6e+uu7+oAhdJqR0G0+n/vPx+ReOCtJEmFUnJ/z/vvv9xWUwcgPm8MQikmSRXj0sVc2DJM32DEJDUe0qdE1ed+vH89gdMOmIxPZYr0XG2cZ87mIWu3t7ZIkEUmSY4xjvSqpqjVPnz7lww8/ZLUqfQm79YlROW80YhXIsxRPQ6IJ2yeFQqg8DuOtdbieKTCaEE42cBeJlyaa6444Tn2nrKHN2+YzklGQuXR1lo11czwHHTGRhMhAiZzFhtvvPWmtvbY7m4ZmEx+VzWOxOGO5uuDxk0fcuHGDne19cHDr9i329veo64rT01NOz87oTN17g8GkSn2L4KrG4r33gMN71tXVS7Sm9/qVt5sCxYEk81rOTivOTk9Ik5Sd7W1eeuVlXn7pDlEUsVyuWFwuqaqak9NjFotLWt+NzBpJNktS2g1AiwOlYs+aEu/XOe9wqPHm6qMT5+g64zdrxYZImBl775uG/EUwjbqyvsdzKHw2y7Iegjk9PWW5XHooVe7AeMPsHGRZwmQysGGccz3FVNZn6GsgmkimE7VZTVi70ZXrlByOUtr3B9iMRoLDFXIgQ3V52ESkWboxgRkIGuUT0tFGEdRHHd+KcY+B7wT+S+fcbyil/lsEgvmo40VndM+9Sam/CvxVgP3dXXlQ/p3D5BwSYD5Wlay8AiJN1TS8/+Ahq7plXTWs1yV7e3s9pBIectBjTtNUPH7nNuaVeI2WclX5/pBDuDM25pHP1Guteemll3yCSq4xiiKOjqQxsVS1VXS+EcRVnC78DAqDAUsTPizeKAa2xCjR5fekAd4YXg9GiJHRCddvjBiMPC+Ik4RiMvFc+oI8y5lOp9RV6WGhIy4vl5yenFHVa7+gVR+2JkmMc9qP0ZXJbAfoQ4VkpdYCc43Wrnh7wfhs5iWC4ZC1770woOla2s6R50Xf0PlFBv6jjvCcNpKGgPb69MHUC8rhA/6woyrnOzDpzXEfXcd4zEPyuq5W3P/wHk/TZ8xmc3Z3d0U6YTpjNptz4+Ytjk+OOTs5o6krPx6GUDBkjIAOsXIeQhuNj9s0bD1U4aNO5SGvUBncb17W0TY1J8dHnJ0eiQDcwQH7+wfcvHWDrfkcB5ycnPDBvQ85OTnFQZ93UX5xOi/LEEVJv+mFWg0x/JtmYIxlh+f8nFnoN8/nq0GvHs87YUNEEbjo8/mcpmk4PDx8Qf1KyH1I4ZI4Z5uRZegcJuNsREfKb6KuE2aMVOoO3ve4gbfyOjFSUvH8hiW1Iol32J6fx7IRaXQUEcVSxa91Imst3OzHHN+KcX8IPHTO/Yb//X9EjPszpdQt77XfAg5H739p9Pm7wOOrX+qc+1vA3wJ49eWXnCTDJEQN1Nyriyjg8KBoreP9h485X9d0nWO9WveGN2hAyESUhTmZFH7NeqzdbdKtnHW9AY89xp1lmRf5GrS7m6ahritOTo5YrRasVqteZyV0ezLGbTbYRvUblgruFSE5Il6hbACRwCRuCH+H7whXKvcQPPbeNI42KhAoI0nTviouSzO2t+YoBZ2RBOtyccnxs0OqqqRpag9XaYxxNG3ntUGGEFHwVIdwlzfV95zr/N4iHlmkvQa66XxzmaGQR77Te26jSM0xKvaxSOMVHEE/3NrQycgNmLOnSYZ77yEiNuGZMJ49LINXNXSymbowN3qXFO9PKIbORWE9DdGI8yJnYcMdxp/eGkvbQZE5mM1m7O/ts7+/x3w65frBdZq64f6DB6xWS84vzkYaJd4BvgKrWWs9nBbWxHDe8TyJNAOs6eEQRXAsZOxWqwXL9SUP7n9Amk04ODhge3uX6XTG7Vs32draEsG2ckVVlbStyAE774yN4YZNT3tz4x887s3frx7DhjV8x1jnaRwpbR4yT65dO+D27VvUdc2TJ096ivDmesKv55jJZLrRi3aY07b/aYzBmca3fBQnM/F6RWMWjcyvwamUqNb6/gj0Rj/AO9IgpRklU/VobOT74mRoHC50cBlErf4DYO7OuadKqQdKqW9zzn0d+AngD/x/fxH4m/7nP/Qf+UfA31FK/TdIQvUt4De/6Xl8RZb2OOTGruRXlWisKOrO8O79Bzw9PadsOxbLBUor5vP5hsER5TnNdFqQpDFDokegiiCktL29zdbWFm3bUhTS+qwsS8qyZLVc0ZlWJF29Cp61HVVVsl4vNzySKFboSKhvkW8uIg/eEcc+RNPCtQ+9J4fKVP9++Cbh1jA2PZzlE1uC8efEUdLLuMpmVGON4dmzQ1arS8pyTV1VKPCa2sF7VQRGUpqOy7Of96TG0UhodSaGQ/sEdgjTpdxbPEiZtCGBGPVtx3yor8Zc74CF4qMv4Qz3XhARxkc9Fkd0xcAHSmG/9/WX7jdO5yEYZAOw1qKioOoXhtlvFmoY7WAYHAFqUp4mOPxNhiVYMdvXblgHi4tzlpcXPHv6mIODA27cuEmRT3n15VdIs4SzizOePXvGs2fPvMaR89htgOBGz8F7h2JQVD/fns8L4cfOt6YMDUxUEOLTWGepyjUPHtzn4cNHJEnCdDpnb2+P2XzOTraDUru91kpV1zR1jRkxxgbPN2zKV+atH3/1MfN72KgcniDNJqvrxYY9SSK2tvbY399nsbjkyZPHowbVemNclBLW3HQ63YjEAgwjBlucEGstdBXaDQ2tI+WbeY8gyXGfgPgKxh6w+yF6xNun4O2HBt9WoGEcnel8hCuRnLKinGpcuK6PN+zwrbNl/kvg/+GZMu8D/xmySv6eUuqvAPeBn/c3+lWl1N9DjH8H/BfuY5gyLzqcc+PVODwU51hVFV//8EMOzy9ZlQ2rskY7xf7eXt+Qd9C2gOls2pfip2na89LFAGY9Dn54eChqh20LzvWG3I0m6RhbDQnYkAyNokgStpHuIZWwqw/Vec7j6OHONieuHEOx0YsRLvE48jwn8V1+pjOREs6yDNMZqrqhaRsuLi9EzbFcUZVrmrqU0N/7+7EWvq3SwYP2E1Fd2VuvLKiw+GS8xUhYZwjd7IMtDF7iVSgk+NW9d6qkktC4wTMZ4+PDwggekuqfjX97/9wd0vx8XJW6iY/3KkWj65BrssY8N+Th85HWfi7ItdmgUeLAqcF7G/cUVW4cKYxCchxlVfLg4QMePnrIfL7DrZs3eenll7l79w63bt3i9OSUD+/f5+j4SDjzfcQpi3wYkzE8NRgQ5TfKQHEENfIQ6W2t/D1sdgMLrGka1utDzs5O2d7ZoSgmHFy71lfIhkj1wtM+g9heMKKqT0j7DeTKnPpmRx9BMfwcnt1mYjLPc7a2ZuA09+/fp6rWI69284FqLf1og7BZj2/DSLte41xH17bYtvQ8f/ku7ecqBPG38Xi7Hj0APIPLoJ04LspXT+uQMPf31us0eQy+bVuZw9Z6B0SeX+ekriTw3aWPwUcf35Jxd859GfjuF/zpJz7i/X8D+BvfynePj97rcqHK0xsQJIJfrUvefu89Di8vWa5qlssVcZqyvbsvsq59AlH3XPQbN2VCTiYT6rpGKUVd15TrimfPDsWrtdYbp/5KuBpW+vvqJ3/wlMfsFR0p75nLx8ecXwgVa88/kM1wVj48MHEGoaI0TcmynOlkSppmxHFEmqW0rfCcT06k4nMsxwt4DZQxe0HuUTzQES8ch7BFlIc9NjnNXRcYBgqUJOvEow4RgHjloZI4VAk7zyEfwl3rlRmHccVaqe7zxS3Wyjj2njRj5UEFeI84wBFKAj7tecnOKq8/Yzee3+CRKd/Vy7NynBqc+pGHF6Ibae3rF751RNqL1lk38qYDRdOzIAjX7Y2T8olsHyEEEavzi2MWyzOePHvEnTt3uXbtJkmScffOS1y/doO6qTk7PROmTVX74qNBQE+m/VhKY0xMCPTFzTqBYDvHsKELQn39hmdxrqOpS0zXUpZrsrxgZ3eXPBNRt1dffbWvywgFQRLRhshA5tqmsX6xw7D5ms/TKAd0foyDcRd5gvl8zvXr16mqNcvVkuVy6Z2tIfIbH4HiKHBItyF+B4OxdtaA63CmxrRdH/1I8ZDGjqLncHS+q1LPVVcaZQ2Hjx9QVQ23Xn4FFYdnYXrHT55fKFQTaRWlFKE/mfMZ9YBMOSewmELTfROX+ZNRoep3zz5c8567UhL6GhSnZ+e8f+8hF+uK1bJmuVgR6Yjt2VZflqtQPZ67u7vrGSAJy+WS01PRUg+CQNYMHtVVXHbTCG4evQFT9F54H8r5oopIX8E/+13jeU98I1xEaGBxFJPlQnWSrvdRb+CbuvG66hdSto8VbZUrVM3NcwzDKv/wePRosct1aByx/3vwBP1iGXnRkpjDY+LBWAzQhPXJPtmfBobMOBy31vVNrK9cLYFfbn1yUSnRJ28C3rsBN8gTlIscPPhhbBn+I+DNkj8IhkwW09BZaGOzDZFNv9/LvYbo0jFEDv15vJcqzoqiM8ZTNC06UqJdogdvPohjnZ0JbTFN32V3d59bt26xtbXFXE25eeMm6/WaJ0+ecHR0yGq5ZOzBhvsdY76C8eJZYINzon1XM9RoIyDQ9wLE4Gek78drHWAsdV3z9OlTYYh4z12SxFN2dnZ6llhTN1S1yG5bN0QYw5a+6UCN5+qA2TsC3DSOZOMoYnd3j1deeQWH4+wDITIMc/95bz00nQlHECbrnRX8+nMWY2tiBCnorLB7ghxBXy0dNkQ3CNENSpGybtp1ydMHDzk7kU35zc99vi+qlDUw1J6A712sQhJ2BHmGjS0gfc4R6Y/32uGTYtwZQm9rPX8UUNrRuYhHz455+OSQddmwKtes1zVxkrCzs+MryLz0qhZ1yNl8SprFLFfS9GAwXpthq3gWg1ywaFYPC3vswY0NYQhxo2hghwAoIgYpUUZGJtwjjCd0oD+maSoqibMttBYNFqVgsVgIu6FraduOqqpo2np44PKtvNBGbhwhlA0hs584eNVNrXFK+04wGmsQ2VJZ6p7KFXmjpfp7lGy+LL7QS7XrLMbUpHEEOkQu4mJYy4gyttlXcmPCDy69GCC/EeRZ5u9ZPLjgEffLf7SBDAwGwZNDMtFnBjzeObB1lBI2Qq+/4oXEQlFOMNYwEm/QvlI0eFNKIjOlpFBOqJHIpumLUbAK64yomfqrVwijSO7fUNdrnj4tOTx8xN7eHjdv3mZrvkeSpLz8yl1u3LzG5cWSo6MjLi/PkdxANzLo8oy7zvXzI9Aog0es+7ng6yt8oWBIMiuliGOBL63T0iDHjTd3S2ut7yB13muwZGnhcz8FRTEV7aCmpm1rqqrCdJsRsQzpJtV4YGINsKVEXI7pdMru7nWyLOfx44ccnxz3bQNhDAv5jSCOmc1mfZPwvsHMlUQoTlRpaSpiRATMWoFU0jhGR4KFu1icACEfDOhCWOttK82tI63Jihmf//zn0abi8eElxgZEYlPkTKAWi3PSlF2N7qXX0UGiAxN6BI8+/1HHJ8a4Kw/KjRkPq1XN/SeHnJ4vWJcNi+UKYzvyImc2m12BYqR13mw26/tJjr3YsbEevxYgkMFb8KbCDR79JmwixxhHHrzJgDUOrwfvMWTPw6QKDTOuXbvWY33OwunpGW0LZbliuZIepNZX24ZrUYM16438xz3oq8mkYOQH3NX5pN/AQOkX3pX7s26oQRAD7wuQ6KRArPMUx2hTAS9siqGhNd6D7Ec8LErEwApW7RtCeF63DYU+3kOWXIF3Qq2S8PVFkQujAjHP/unaMIam9/hlDm4+7/HX9fBa0AmRF0fzSJ6/9+0BmZfWec6/Gl67CkNszq0gJQuHh4ecnJySpVP29vbY29/1EF3Cq6++SlWuWa2WnJ6ecLm4xHlu+xhuCd+5MX/c805LqCF0gFaRx/bp+1ZbnPRTUM8rGQIsl0uWbon2kOV0MiHNMrbmc3S0TdM0VGVNWZY9HPriKHk0l/2Gm+cpt2/fZG9vn4vzFY8fPWa1XvaR84ueu7SHLEaFVmORLn/fHtpzbY1ta5TvZaAjRRSnYCXysUJal8pmAtVUo2PdD5o0JZH2gdPJNpnOqC8t5WLN3TsvUVrnG7e4Pj8ozcjlngPbLmzQ1toe7rkalf1H47kPXhMoC8YpHh4f8eDRE9Zlw3JZCj6J7Nwzn0CEQMVSJGnMfD7faLZxdcGE18eH60NGy9CgdxMrD7jvZhMDD+mMvJkNL957BXmes7+/z/7+fu89rNdrlssl8/kcrTVPnjxhvV5T1zVtWxGKm1AKZ71HLVfC4IEPRvi5kuWN+3NeEGxcbbeBU8i4q6gvegn31OchLBgM1tieXTMkCgMsI1z6zrQEkaRwPeMht9ZKRapWGLRogIeo2ypCcbpSI4Pk0wIW4/WtwxgM0hI+sPWKfEPiVanIV756Zg6aKErlOnvMUuMZnP7ZGwL9EWtHicZwT0ELwKNBvVaKFT567yhIZOjsgLFqvUld9MESbixsdmWeWmupqxVPn5ScHD9ja3ub/b1rJHFEnES89sbrXLtxg4vzCx4/esRqtfSdscKcHyAbgQ00QWZh7OU6Px+SKEV7frbMcS9R4CKMiXrDNJ5zw9yS6LssW+p67fuP5mxt7ZBnBUU+YT6fU9d1T7HsurbvpBWeR7CYWsfcunGD/f090izm8PCIZ099kjloTbC5VoPsQpqmPeQlhneIbES0rcVZ6FqDshUKK3UuWMmb+MYjkRPHzBqpEu8dyljgrSRJQIF2xkMyLc2qRKcZ0+KASTqFeEpsG5brU4wbNOplE7f9vBhf6+DZC3SntCJWL1aTfNHxiTDuLriJWrO4vOS9h485vDhnVZYsL5dY65hMpuxs7/QGchxapVnG1tZsg0e68d1XfvZeXHBhNjB3tfG+8O/xghzeH5gAmijSJElOnhfs7+9LQ4Wq6lUSJ5MJ6/Wa4+Nj37at4/Hjx15AaIxHh5A0YG0BhwRCwtPv9ENm//lqvhdHLaNNQgWv1wokYwJ0EnBOtxm9+P/bCGUZfg+JVK1jFEPxVZDOFVGpxFP3ov4ynG8A3iffvEceJFGVUl4JwNGaFufwIbESjRs9XHtYtOMNuC8OURaHGChrAy2zvwu5T+ewRlQFN8drOJwbd5oaZk0v8kSIeGQMu25T/XCARgaWjneyN3DWzTkul2KtoWksR4eHnByfMpvN2dndwTpHpKVL1ksvv8zWfMbFxQX3799juVxtOB3WOrSy/TS+6vUKpTdG+RwEynP6Q6WsC47QcK0DqeDqWFmapqauKxaLc5IkpSjmYuR94dBkkpPlsqbPzy84Pz+nbRsUmiSJuX79FtevX6dtW772tbdZr0ucDXmdTVhPouOoV3IM9yXesYzlwKIR5XxMR6KD0XYCVXrp6zAGxnZ4+Zz+PGMnsg10UF/wl8YKW55RmYQozVFqRtsJ1TJSGiLZDKy1nn45bGZjWxPGNly/QGTDmn9OuPDK8Ykw7gDrpuPR0yMePz3icrXkcrmkrNaAI/e7/Zh6GAZ4MpmQFzlBO+TqcdWow9UdLxQMDQvzRQZSFmG0ee5iynQ2ZXt7G2edtIjz3VyapuHi4sJ37Vnyzjvv0HWN56fKJBhXpQ2haDh3+H1c3j+GV8Tb7v/mnHiuzlcm+kRoSMaG5Jqs1wAbhHvWflxj8PoekqQcGohrJ4tB9d6SFY/fY7HyJjWSJgDnQ03tI4Gua/rrDbRQ0fuJGWh+wluXIjBJLoWyfnwz7ySJ6ItLPCwUsKrx5i73HMJez57Qw1yQjccQqZggYCURyHiDH4+/4ypPdGxc+mejPeMpaAFFDhV5r9l1ft/00QlB4nroUhSM0OaGoTauw9qOxeKcxeKcZ08fsbt7wMHBNfIsY39/n5deepk3Xn+Tp8+ecO/ee5yenoph889RIi/XQ1YyQopYa7QyWOdzJFGMxUgNgq+chqADHzGW7JDxHyezw1wO5fwlTdNxwblvxD7DOUdeZBTFhDyfsL+3z9nZOVVVM5lMcA7ee/9dkUPo2znKOrkaESY+DxeSpONoPawBkVxW2M7gmhposaYlyCP08sdd5zdteZZWKTprsaYjT1KJxqK4hwKVWGs/ZzVEES2Gykgl67qtWV0cUeQQTQukGU9oZKL8M5XoL0SCYeMPkbtrZU60TbcxNz7q+EQY96Y1/N7b77BclpRVxdnFOU3bEkWa+dacIp/0NyxNAjR5XjCdTv0Ou1kZBs97ruOfz+Odg2c6eK309lahiJO49za2trbY2dlhOpn3eN56vabrGu7fv/8cJXHwdmVhjjeZsbe2+bAG+pjwxzc3qKtHXyTkk2e9x4fodYdqU3Fc/P33XyXXJmPgYRfTIbhFuD6DtcZLGcQ+WtmUSXXWQr/YFcaGaGBU6KJG3qkvVou0MCBE+G3crCPqNwLZfHzRkmcjyAY5YPuDB/k8ph2iizAPBEranB/K33swBr3BVoEZAWFihOc5UNqGClA7ih6iKBKaZQ9l+WvxXOXOiW5OEg+aJlefs7PuSuFRmBfy7NrW8OzZM46PT5jP5xhjmE5mPrmneOONN3jppZf6ht9tVW+siT6wcDLX5WZHlb+EpPKABcdxSFgP3uaL1tc42nVhjqBYr9eU5RqlFFVVUhQZaZpx/drNHq5USqp766oaebPDOcfniaKoZ+uMn2mQHhlrOinAmJrYP1OLyCYHvNtagR/9cpDrd8MGEjaJAJXgHQXtIUiFI80ybCPv6aylMy35JCWhojMdVdtJxOW56v339ZG4j9+te24+B5hm3EfiRccnwrjXTcPh8Rmr9Yquk8FI85zd7e2NrHZgl8xmUybTQiYddqPDTDiex9Y3F/rV18T7FQOI0sTJ0IfUdIad3R0mxQRjpePPk8fPMPYR0iGnZrVa03WbfRdfBOsoFY9+H+uMB8bO4Jk7N8bQA+/9Kn/X9gYDFQ2Iy5XNazhHmICKACs51/nEX+sxdcHMlRMKmHDZRVdGtC6093BcX8wTDLgzg5ELu4cIHZkAeKGAOCwEJ5FCZ0z/PLWOPFQTxs7QtR064jlJhLAQROMj6vukjkvJB5nakWHvwxjZDIcecmLgx23bjN0sTR92RZ8j8J64QB7KVzBaT4AJ3rGwdhhgYgl2/HOR+1WMi576uTBKMI6jr+GZytG2HScnNefn50ynU27dusXOzg7OKWazLabTLa5du8nlxQXHx8csVxcEfR9nFSryuQeCKfbjpyMIlEgr0Jtzcf9swjhtbEgj4ztWTw2w2bBetVeklOd4fHxCUUyZTee987C3dwA4qqpmXa6pqvVzkMRsNpOGNr6xzdVk8cAiUnRdQ9OuMM56WrRQU7NMerESDZz3nvvun2mkZfOQ+eFxeC3FTV3X0RlDFqVEcUKiNdYqjFIkUQKqIE80l01N2xkir0sT2C8BSpJN3nrRsEHHfcyS6XvbfszxiTDuXddxdnGOtZY0TTnYEwaJGi3SJBFMUfC0hECfCtoa4bhq1OXFK79eMfRxHFPkE2azOdZa3wlpQhRFdF1HXdcsF9Lxpm1b2raVdldswkAvSmbCZqXl4P2JRxaEdMZdieS9mx5lMDzjROZwHg+l+NsaIJjw3fTfGSoUgweoVKDhjbp3KodWEVEsyb4sy3w1nKc6dh2mkRZmTgeKqf8OHaN9QlSqdDejpih4uqONT6H6qktnLbZ/YM576xYdhUhnXPgxwGmSONtMsA0GxBLHg5fTb7p4auQLoyIfffhE/hge6eePC28LUZmE0H1ry/Hm4qkowznc4CVq5TtN6Y1r7t87uqwANwzRmeqhyjC/Qm+C1WpFlmUcHBxw7dq1HsaczWZcu36do6NnnJ+fs1wuJMr0UYoM68DsGuA7tfH71fHYjFKHMR026RCxbjYvH69Hkf2oODs7lUrsLBMJ6vmMJEnJ8wxjJSFblmXPJimKov+OMcMkXMPQHEMkc2PlhdlsgM8EEw8OpLx3iFTqtiOKY6ke9Q5QkEbGR21dJ12Y2rblouz48NkhN6/fZpJmRBocMUrVWGvI8rzXXxo7hOH8wpRpCXmuML7jKvxvdnwijHu4ufl83kMtQN/DUEeKrS2R1fUF4z68G+CY8fF8eCheao9ia02aJmxti9ztdDolTaVlX1VV0s5useDs/AJjOppauiPZK+eRczx/3hfd3wvhFDXc+0cxXpwbiiR6rYvR+8QgDMYlfGbAiPHIytjTDdn30KGKkRGSJt5xTP96Va399Tm/iSgUlihJEANo0NonFXXs7Z1f5MrhTCuGTgE6tBsIfTe994z2DVmC96yFReJGXZucIfIMG+dkI1JeilUHxNx6+KWHdpz3guQaIhWLh9p1uD6KGSh5Az0vFKqJ7G4Y0zF2a61QHDsb2PMWrWJwkU++DZohm4frrytswkJtizGm8aFX3DsC2imcuuJIsJlI35w3EgVaaynXa+7f/4AnTx6xu7vPtWvX+irNre09ptNt6rrm4vKS84sTmqZCuPpO6h/8PJJk+WaruTDXrm58zztbfv2p4IAEZydElcNdjedx2zYY07Farzg7l9aG0hQ+9ms47R2wMb4+7m869nYlwVvRVWtiX+HcdYZIK3QU9bYkbA5hPlhrSWJRbR2v4kGkDlSkRWtGwbozVOuGew/v8+u/9fvs7Wyzu7tDEmX8oU8fSPSOBU83HV/3eMO2zhLriDgKlEuBywgQ4YvNTX98Ioy70ppr1671O+YYP51MJsy3Zhu64WE3Db/3h6M3LP13e8880olU+3kaVpzIwwoFEOfn5z0OGMI+CUHHRnfzujdD9OF8m39//t/jC74K3XzUe8cb1ovuPRiC57Dmni2ingtP5XNWjJEae42Bqz0s5HGXHogEL0SgpTgeNVhWavDO+5Dc/805utDZpm/8IDPVWSsVr2qgqoUK4MBzV6PxVf3/je519Jp19oqtcN7DMjgXERD3AeIYc8HDFw0r6Oq4jp2KiAAp+U1t5Hxc3XQ3vV9Pw/USBtZ2DD1Oh+seGnSMGDYMVMarBlXmrPVJdTlX27YcHx9zcnLCZDLh1q1b7O4d4CJpP3dwcMDBwQEXF+es1iuWy8VGTuiqYR//HB8fZfgDHDh6UlfGevMYRwNhvZ+fN1xeXvTt70LFaYBsA3wR8OvAEw/8cWsNXStkgjHdUEdxH10MkdEmQSOJY09UGKKTSA8bgu0jPF9IOdP8xHe/wbvfuMeT8wU7kznr8pLzZoaOY+xoEwrXH/4dzpGlKT61hLUIfIRQLxV8U+/9E2HcwwMJgxtF0nR5Pp+T58KEcbjnBnyY0KoPefUInyqKCUWR9xhcmqWsVyuquqZdNBsNNIaJKCFxb+SciGGNw/3xsQmdDK+90FN/wTFe8Ju4Ls8tpKvnfj5xxXN/H/976N4+tJJzTqN9der4fEp5mVsX6J7h/Mp7deCU87xzheq9Vb/ReIREQd9hydrADACn1GASrWHQstkM88VLjvzmYQc4J4yXZmjOrKTS0jrbs2Kc3aTpKSxaCx9del76a1YBNvBzQEl3I2MVSovkcI+FB72aK3uwwEvORz8hyvGer9J9tas4DeLNgulhMSl0GjjPcr5IxsaFcdyktW7OAaD36IPi6Cgn4697ubzknXcuyfOHbO9sc+3gmiQdrePg4Bpb7TZ1VXF5eUFZlT2+HebT2Kh8VFR6Ffq86uhchW6uvv/q94SfxhjfAUwKgabTKVtbWxtrJPytj67cAO8qxNkzoULa0bPLIq0xbnPTDEnUkJQN39n/Z2SeoCHNEp/sl/lv6zUvXd/m1bs32Z5POKkbqjBmI3s3OGyqh4oC/h5FGq1ijDV0nSFJI4yzIpdhPt51/0QY93AEfYbZbMZkMhk8BTYf8HiSiRqj9Brd2dmhqqp+tw6VnxcXl1jX9fj5i6Cc8TH8rQdVP/L9H4Wzf9z3v+h8L/rcRy2Q8US+GhKPPfvxd4Sdvp/o/v5G8l2j+xnwXymwYISdi4F2atO7Mn5BKQRTDcnEwNcPRnMcHSjtISn/jIV+PhRmDYvSe9e+g09ohRc0X5T/X8DGlZKuXc6q0T2Fu7R9NCH4TtgoRjxtvymFRKBWkfeqh9J1RuPfj70DO8K/xzRKoeqKCRe5i6sVhp7CyhCFORee6xi+CNd5Be5xGrQN8QPOgekQTRQVYK7A85b3VFVJ/azi/OyM2WzGjZu3mc1mGGPIspwbNwu6rmW1WrFer5/rJHZ1bMevX/3biwz8i/599f3fzNCPq09fmBfx75f3ddIj2XS4kWqkc65fBcqBGlGurbU9tTl42GJ3PHRipHWmUw7rI8DQcu/07IIYTZ5krNZLGqdwkVeIdUMEMKZ3h+vuug5nJYcVuY7ODgnYcSHWxx2fCOOuoJcOmM1mVxKQg3cuEEBEHCdMioIsz+i6liRJaJuOqi6x1tJ2Dat1Q9e2I+leGBuwQSYgGLMxlSucX/n/XuydvGjyvnjSB1d2bDxf7Nlvhu6jgDVQovTzkz58DnihYe/DeK3RzgGRTyKNoQq5b4EHBgMohlUP6Vbni5MQQ+aslx3AoRPhUZvKCTaugppfME5jlUAfa4anoga6YRjLkGdwpkMr4bdLw4IE5zqCoqNDbBsolE7Q+H6zGtkIvHGVK/A6Ksbj3YByDsUAAYUimX4AgnuhhbMf4A6lNumswcMeHlpg6sQYI7BL1Jfjhr8jQnNOnpIizE2/0J0BFYXdpo+etBen6xPsyvWRU6ANO59wCcYgXGfnIxblISxjWs7OTrlcLphOpuzvHzCZTlAqIY4SDvav0W61tF3n+636RvKj+Xr1+CijfNWIvej1j4pQr34O6LslBa96LAQGA6wTNiVpptNirBWVVuOjvz5qFGeBMGed9s1Y3MbGFl6zzmJwpEnqn6jDWIvtWo7OL9HE7McJ62qJ2t5He2JCpFXvvcdeydRaP58iYavFaYKzjqatidKEJE2wpvumzmk4PhHGXUe6z+bDMBmCrG5g0Yw7pkynM1D4LkKNiGp5XvlzxUwK3HgRylkQgzuScOpDRf+xKxS6q5jj+Pg4eEQ2h6EUPEgcvGiyjr2P/gNu/Pvz53z+fOPXB072GO91HpIJjqTDjTrGBM1oiS/FnkQ+1PfWK3CeMUhzaUeUxRifeI56DDN4i5qBEWQJVawiszDc6vOeKv4aLQQv1HkII2zMgCMCzzXWUYyOxMOXup2h4MWFzkoolBLROOccUso+eLfDtQxY9wCx0G9EGwqUNhiGgfYXTLYLuQMVE5qAbMwZ5/rIY3j+YbcL3OzOF9UESmvYSYIQmqexuiGy3Yz4hEgQkpDDWMt9WdtSN2sePX4oTWy2dphMpNG7NI+H7e0d8ryQph1VSV2XfLN5+NycDuN1Jfr8qI3io6Lh8XvDcwtd2EIiNSRbQwQIsiFE+E5IpuupFrYLDdQdeA9ZoXB60H3poR9fpxFFkTTE9jlBHcZbJ+zcfo2uU3RmQbdcMpnv4VxI9CpvgQIFdmi36ZwTEl0gW0SaJNLihIxQi/8oMPc4TvoMfgih5nPpAuOcJD/yPOf8/JyjoyOcc1xeXvacc+/2fOwxjgbk8Hgmgba3OfHGn/u4SfVxXkWAdV4wX/treRH2uIl9O7/GQ2Y+eu79zy2KDbYIBNVL5TQ4iWKcc4Iv9pHE0ERgWPB478T4ZKaTghwUOMn0q2DE8YqCSuiOWmtUz/gYpB6UEqVF8Xo9nBLO1Wuvh2cyQDhaB72akOxl5CU70YBBSW+5gKugiQJn2Y+fMBJDJKMIFVNhsQZ1y3GCeejHG3RsTP9dIdrRSvkNIkAvMLCYBiO3Of/8u0cbCCpAYcInj0KFpB3GEAaPtF/f/ebl+uuQKEd2IpEVSIWYoKSjmWw2/rtkhnj8WAGW84tzlssleZFT5AV5kRNFmixLybKU+dYMnJARlqvlRm3A1QjyoyCTq68//7dh/P6/7Z1rrCVZVcd/a1edc2/3naZ7mnkEgfAISDL4AZAQUGOI+AAljF80YyRixOAHE18fZCYkJn4gATXEGBMNAQ0oDwmCGhIjihq/AIqoOAgjMw7CPJxpZrpvv/ucqlp+WGvtvevcc/sBQ997O7UmPfecOqfq7LVr19rr+V9jkjwPNdWVvTGOElA1F2GS2PgSfduQmgZx5a93HKAuJy0MLDvzrYdbRLHsGvV1Vfv3axfRsrNMu82tTc42GxxqZihqEN1e7Z6aqHpX34hKw49BldQ0bHowN9ZZrMldBYvTvhDu8/mc5zznOdbW7tw5trYMAW+5XPLII4/kLi8FSa6+qbXaV665Xtju1M7X0W7n2nnrMwTWnVc0/9X0xfW/WVNU6NXaYilJ3jm+sZbkZn620wGSad+pM61bQDBExNVgVHR6CdPfNFGoLZxI6MhpgRViY9s0hoOxtFTBSGn0M6p5hLqRctFEwYRdjVsi3iRh7LoJX3eASBWHh2XyqJZnQNW2hUHD7WIwq6USs9yLvL6iUlNsUxgGszSSP5j+FQt2qqdmhh9XyljqsYW2XeZBKWBZvj8hCBZItqYlO/2r4RrS2Ei0BHsDmtmuY7EKiZQ/n5So7m3c1deI+CYlGaBtGHrOnz9njTrOW2u6ra0tr33Y4ML5S9x883G2tgxKYPv0SeszsE7piBWwRmEq/KwT/gUPxj4qYmsEKwDZBx9ulNgUM7Jin1gultD3qHYsPculEQx3P0U1t93boTO/fq8Dy64nJbvubNaiyVZOdLxbVfqO33IcQbl04SLNkdvoU0ObrPkQaiic/dBVPnQyDxbX8bRHIYetzA9vKZf9Fbp1XFG4i8iLgD+rDj0f+A3g/X78ucBXgZ9U1ZN+zj3Am/2u/JKq/s3lfmMYBr7xDcNlbtuW7e1tnnjiCRaLxQjNcKdPW8Mbis3XTjNwVauuv7PqcqnPXTMPO46tLsKdAhdCGOf2cyvX3M3POPLlZmERfUV3bi6ja0hV0+gvhr4DTGs3H2VH25Bz50MLNMEwTrWUJLkJtGneYzxp8UU30rJd0Jjbpff885hvK46qrZZ8G6W+J55rXA5TsqYCfiCymcyC67qF4dFQoHWHAXRIZaNTE5wRXC3zWQpuUAtwGnaIWRh9zkuPVolD6V4Ue6g/tGFWDENkFFHxFfcLoKHvrOF1tiDFn2YZPEhbr3G/1sh08WyyPEl+bR08K6ln1sxGGq0Bs5Wgdd/3LtSbvOHHfMS4L126xGKx4PTp09x000253L9tW/dl97SzW+i6jgvnL3Dh4gWWy4InVHjYmUq5asGOffbhRw9FZ7w51h3PVutFQthb8NV98s2MJjW5fSEieV3pYJbToL4JCdajt21pfZMogdyO3BPCF3CdH5/SQLfoSJJoa5dztcmmykIUxIuhemazSBKwrK4B2XVT3I2upkH2fcBLfLIa4GHg48DdwKdU9R0icre/f6uI3AHcBbwYa5D9dyLynXqZPqpd1+VOKrsNPsyealzxanSzd6NYTPUE7SYkVxfXlQT+jo3CTeHsshDrqxq5ySMPyi5jgXGaWZmW8ls1/kn9ukbLw7XNQZVeF+bKctfK0Pc0qSW6tEehUoCblQfcCoUCC32nWyrcFu5KwVoldr0J3DpVsfAd3Ph7QDxv2NwxVkEYpwyjtRFWgltB3kJQXdvvOoulaHLtfFDUkSiltc1LUWunBiDJDQjTflMjjtXjvxPxCgz+oO87hr5kzZivP7mFU74fxUAMYN6OnQrEMHR0vbLRzDHgt4FeO5I0iKe8UVk0qjD0CXwzUCQDUOE+d4tveNB76ECEptnMGmHJMNGMO2TQEjYX4fcNF8fqM9n3PadOnWJ7e5uNjQ2OHT3GbLaRFZKtwzcxn23wghe8kNNnTvHYY49x7ty5Ucrx5VwzZY3EMxV87XRxjjq4+fuSQmu8XLx4seTEpwRNS9KBthm8qhnms1n2AA0KKgMXF5dybGJeyYQSZ4kOaVVRm5a1MnQdqj2D9swONQXpNJlrrO+WK0oOJIcQ6brONs4qQBzXHoYhwyxcjq7VLfMa4AFV/V8RuRN4tR9/H/CPwFuBO4EPq+ol4EERuR94BfDp3S9bujDZpI1LmFc19nULY8emoIw1WHZfRPmUNQurPm/1uzuFXKQWiqXhpXgo/fcqF8jqNWvzsea5BopaHc+6+Vp3zdBgVF3DcdO9EescVbs+as07zoMSnCsLO5Vrefl2vkeUzINAcww/kaQhN4EILJYoDmEobqiS9SBEKbYVNXmWQRUgs0q+ZBlFKebGgqm24URg0YK/hm4ZghjXdKOi1jSx1GDWxhC2YWCxx4ZbY/yMXUtF2fANL4Xbp2RphSAIfuvVGPwZFIO7CNRBGbJlFXNsQcCisUbFc0Oge4a1Va+RkqFR1khowfG9GqNl9TmMvxfOG1zAbDbn8OFDHD9+M8ul1Y88/vjjPP3px/muF9/O2bNnefjhh9k+fSqjU65K6vraIyVL45jPj99THQaWy46u66sMJhkJ2hJYXZLSHHM1WXA6Ks6HrgMXvJY605MosL6RcRfXXRXyq8fjHtq6Vgy7aadVUuPDFDesRMYv/RBw2WZNJSmZT1eC+4VrF+53AR/y17er6qN+Mx4Vkdv8+DOBz1TnPOTHdiddNVfHwnxsohVcZnvQd8ufTZWjCuqsjKCrEfK7CeP43uhzLW6U2L1LNU/Rvlb5KcJXdyySdWNZNT/r69QPar0J1PDCEibeYPndEb2PcZTFG5Cn4zFbUKmk/UkShuWSpFElKIi2tO2c5TIQCB1YCyE1uAbi95rInR88VRNiM1NfG4Obyxsb5oKxoKVvRjG2vMFoPj+akGQlANuQQqDbEfdtek7+MLh21Xia6CCWFVRluGg+P7IjvCky4FHZyqIpwt6ETl/WiCRSijiSu6t8VE3boD1WGKVK34cGS9mQCGTKlF1VtfBJjQmL8X0tayeExOozV1OtFI3XZ9Go+37JmTMLLl48x3y+wXy+SdvOOHfuPIvFkrZtue222zhy5Ajb29ucPXvWMluS3ZV1z1d5PsXdXuEjit9uWFxasrWl2SqYzWYjN01YlIvFRfelt6TU0C0c/tgDl5cWS2bzOUm8AMotMLsvpb6h3jBW56/2/VuigCWLDEPPLDWO0mmpklI917OmZTl0OTInyVyGvq/ROXBdEnOP7uZJWKWrFu4iMgfeANxzpa+uObZDgorIW4C3gGHK7MRMufwNDy1znSYvIrmApR5WfjDze/ubf0azwr/ymyXYtXNs5XzxAIv9bxiNs4xxp5Zt5n3l0lFGWjLstBRW/ZU73UkxrqI5N03rnzSgveGVqC22Ji9MwcC6gl9rDOxceJs8wMGuLANHrWmGWhFN284QTSyXodUEPrvmeRdxbcWny4S8EOmWxbWUQHqaAfOFDkJqQjv1LlI5E4os4MNSGnRZrmPGsmm1y8FbpuEPTA+x2ahpXfZfa24fKRvNqqWjg2RrxJ1DCHURUgj2wn+xjsi81JDElnkipAy5HO69gFK2QLLEZlBtJLZ2vOClCWTPtGO9QMkTDyFaf2fVHRDHi4D3e5kSkTJrVd8d585dYLnouPXWW/K5m5ubqGoW9GfOnOH0mdNcvHjex1Ceh5H7JrKm1PlIZlEB7maE2WzuVsyQC45CCM9mMy5cOOdKjM1b085AB+h76HsudUsGbxzeuK89xhGZNquWbLh9yoZvbrtIvxQCm0YNx6mx5jKNFKiEwJDBrfQsJWIjFrHNwK3MQS1zx/zzT10R0+uAz6vqY/7+MRF5hmvtzwAe9+MPAc+uznsW8MjqxVT13cC7AW6//Xa3ji+f57pDc/Cbnxx7w763Pqsgyuh3aNuQhWkI5fEQIi9ayVE9P45rblmc5rTF9X77dVZC0a5Nyyzum1KqX1MNUbCqqa9eU6RoFABNM0fVMluaNnleu1+jaapdTUlN8qKKROOgXiklNJUUTftrqXrLPvKC1brNqKU8WuOL2DSSwwUMlukfG4r29F24dmL8DQY1bCl6ojNg4b/ZklLkpyeW/cB81iI5XkDOKFAX4LUVparmHuo8zxgLsJJKKh0aiIGuDatUm0i4CLyYSFLGANG8TmyObN15TCALLyEyQEoa5OBpjUKjhj3CAL1aExVJUW7uz4JftxGyeyGlsAQSs1lxYUlqiSylWC81PlFWIjSsMfENe+faDaUj3g8OnVAyrEqjjDNntzl77jQpJY4+7Ri33XZ7hgbZ3NzkyJEjHDt/jBMnTlje/IULoxoDqQRsbIhmESsFehMuXlgwn8+QpNkfXW9ms1nL2bNLlsuW2WwDHRK9zGlSZ2t7UKRpURxK1+VIVLrbGOIZdZfJim8/ecJBCfDDoD3JNe6uW6CSuLi4xGw2zxZxWFS5XaQW4LKsJjhcQUlUoLJSd6drEe4/RXHJAPwV8CbgHf73L6vjHxSRd2EB1RcC/3yli69mvRQXRBFSOzV03J8ppeuNJFZhcde5eCRU7LCBq+s2TbWgxDvliD3ItrR8p/Y8V3V3BJU1UZviwcOqwPdf9F171d1iGqFWbgfjw7Q3POgozkPd2T6bsqGJafFFrkKGjufJ/pbPyItK0tj0FInXrftQHQ4iWT59wtq1mbba57ExclOEMLfK44HYvIyfch9atyS6fK8H5zM1A4y6cFWZQ265DIOJ8HEAyteBz9MwDO6H7h3XPh7qGpVyvE4gAnoRt9C4dSVzJVttsaaLkhJjyJW4WlwAtQsltH9fXm4N9YRQzes+bzgpr2NIfg+F8fq3v3XqoMZ81ErLSKGJdTLmBVWvvK2ftaJM9X3Pk0+e5NSpbQ4fPszRo0c5duwYhw8fZmtri83NTZ588smsdW9vb3sFbLmnTWN2TFZ+tFg6i8WC2WyWYz/z+WzUNzjWam7P2DTWWarrSWLrtBmqfA8huy7jXoUwtqBokUelajUyZ8xSMCvclkzbGgpk2zRZoYJxjn6tsNXPaWyY+EYXAd56rnejqxLuInIY+CHgF6rD7wA+IiJvBr4G/IT/4BdF5CPAf2FP4y/qZTJlCnlRCeFLLAzUAr7WGhTbwG2HB3DtZkfu9IgX+5uKVI8cYQtkVBjWIewaX8yD95XMY0ueFxyaf8lDD4E6RJ50dhkMYx78/sbDFwvW+BV31wQv5LFJaI2QTdQYVy3Uw50gJMtnHqyaMTIsYk7zb5sNVQkHo1X41FzlmUrgN1wBMjSINJ5BASqCOJ65qpo7SIRBhdYR+dDelbHwi4prji1oZ6b00LrgHww3Jc+jZi0qfM8BfAZWtFJXG/sMMfg9teczmhOHoAr/eKw0S0kc3E0Q16sDZareDNv7b5bYUNyblO9ZSi2ihh1CY/cGzIdb9/wc+8LxnrEdNA4wRol/WIykVAEPg9K0dr/D0lp9Dsrr8sxlxcoXX35mPIgsvm5wAUZ+BkzhUTSv21qXGYaBM2fOcPbsWU6cOJGF/HJpTW6OHDmSfz8qzuOzUGyS10yEcmcCtsuKXkotAb8Q//q+Yz7fsGteusjhw0cgJZZ9z3J5Kd+riO3Y/S+B2ZTaPAZTAoqgL5lFNt8ZZE3NKuz7DvrBLQKzIvq+VpLG1cqBFBnZMrZ+vbhscFecWGOQhX93N7oq4a6q54Gnrxx7AsueWff9twNvv5prB41cJRpFJpdPc8yLjNCGIs1vfN11v1X079CqUzZDY0OxLIRYROXcVaAi8sMb15asQdebVPxW7bMcXaN+6Z+vc7fk36nmbDXrIX4LImMiUslKVk6ZdwFNtE2xGqQSFPG98l6sviKspyzsfZ4UpLHcXgVYGJ4LLjAGdf985SsP66RphLad2UUSlp8egay+9TkyBL9hsCCs0I2Ed6RTxmZvD/1QPcDFJRGyu8xbVIgWC2ec4ibuslLMjZZIYjGL5TKCbcVNMV53oSE33tHHcfrbWQ6aBthdaJ3jLJewghISWEXJ+r+GC2M2m2XhHhtDbSWsPg/ja4/rJWq3X17zyOjzoOyzT431aJWqBsAVNu0jVpJYLBacOHGCkydPcvToUW699VaGYeDkyZOolsDo5uYmy+XSCxj7ohSNrFzT3jcPbRBxjNpCFWk4dOiQWQbLJbOl4SHNNjZYqKOkejBb+2KVrJsngwiflYpX/yw6k2W8mKaF3twqfT/Qacdsc57HVN/feB8ae7h8QmEJQR+859qf4fI+d7mSan89SETOAPft9TieYroF+MZeD+IppImf/U83Gk8TP1em56jqres+2BfwA8B9qvryvR7EU0ki8rkbiaeJn/1PNxpPEz/fGqUrf2WiiSaaaKKDRpNwn2iiiSa6AWm/CPd37/UAvg10o/E08bP/6UbjaeLnW6B9EVCdaKKJJproqaX9orlPNNFEE030FNKeC3cRea2I3Cci94tBB+97EpFni8g/iMiXROSLIvLLfvy4iPytiHzF/95cnXOP83ifiPzI3o1+dxKRRkT+TUQ+4e8POj/HROSjIvJlv1evOsg8iciv+nq7V0Q+JCKbB4kfEfkjEXlcRO6tjl3z+EXku0XkP/2z35N1xSzXiXbh6bd9zX1BRD4uIseqz64fT1G0sBf/sD53D2ANQObAfwB37OWYrnLczwBe5q+PAP8N3AH8FnC3H78beKe/vsN52wCe5zw3e83HGr5+Dfgg8Al/f9D5eR/w8/56Dhw7qDxhyKoPAof8/UeAnz1I/ADfD7wMuLc6ds3jx+BMXoWVSP018Lp9xtMPA62/fude8bTXmvsrgPtV9X9UdQF8GMOD39ekqo+q6uf99RngS9jDdycmUPC/P+6v78Qx7lX1QSAw7vcNicizgB8D3lMdPsj8PA178N4LoKoLVT3FAeYJq0s5JCItcBgD5Dsw/KjqPwFPrhy+pvGLgRQ+TVU/rSYV31+dc91pHU+q+klVDcD1z2DgiXCdedpr4f5M4OvV+ytjv+8zEpHnAi8FPssKxj1QY9zvdz5/F/h1xrCaB5mf5wMngD92V9N7RGSLA8qTqj4M/A6G4/QosK2qn+SA8lPRtY7/mf569fh+pZ/DNHG4zjzttXBf51c6MOk7InIT8OfAr6jq6ct9dc2xfcOniLweeFxV//VqT1lzbN/w49Ri5vIfqOpLgXOY2b8b7Wue3Bd9J2bOfwewJSJvvNwpa47tG36ugnYb/4HhS0TehoEnfiAOrfnat42nvRbuV4X9vh9JRGaYYP+Aqn7MDz/mJhbyTWDc7yF9L/AGEfkq5hr7ARH5Uw4uP2BjfEhVP+vvP4oJ+4PK0w8CD6rqCVVdAh8DvoeDy0/QtY7/IYqboz6+r0hE3gS8Hvhpd7XAdeZpr4X7vwAvFJHniXV6ugvDg9/X5JHs9wJfUtV3VR8Fxj3sxLi/S0Q2ROR5XCXG/fUiVb1HVZ+lqs/F7sHfq+obOaD8AKjq/wFfF5EX+aHXYDDUB5WnrwGvFJHDvv5eg8V6Dio/Qdc0fnfdnBGRV/o8/Ex1zr4gEXkt1k/6DWqIukHXl6e9ijJXkeUfxbJNHgDettfjucoxfx9mNn0B+Hf/96MYLPKngK/43+PVOW9zHu9jD6P7V8HbqynZMgeaH+AlwOf8Pv0FcPNB5gn4TeDLwL3An2BZFweGH6zZz6PAEtNW3/zNjB94uc/BA8Dv48WY+4in+zHfesiGP9wLnqYK1YkmmmiiG5D22i0z0UQTTTTRt4Em4T7RRBNNdAPSJNwnmmiiiW5AmoT7RBNNNNENSJNwn2iiiSa6AWkS7hNNNNFENyBNwn2iiSaa6AakSbhPNNFEE92A9P9XTB+88NJSMgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# draw overlay\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.figure()\n", + "\n", + "traffic_world.overlay_trajectory(cam_id, trajectory)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "b1f6fc81", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(121, 4)\n", + "(121, 4)\n", + "(113, 4)\n", + "incorrect length: 113\n", + "(58, 4)\n", + "incorrect length: 58\n", + "output video files ./output/trafficScene_cam1car-1-a29b573e-70a0-4b6c-b19d-4f453867ce4f.mp4,./output/trafficScene_cam1car-4-a29b573e-70a0-4b6c-b19d-4f453867ce4f.mp4,./output/trafficScene_cam1car-14-a29b573e-70a0-4b6c-b19d-4f453867ce4f.mp4,./output/trafficScene_cam1car-21-a29b573e-70a0-4b6c-b19d-4f453867ce4f.mp4\n" + ] + } + ], + "source": [ + "# render tracking video\n", + "filtered_world.get_video([cam_id])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f8ae640c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Times are: [(datetime.datetime(2021, 6, 8, 7, 10, 30, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 31, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 32, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 33, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 34, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 35, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 36, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 37, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 38, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 39, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 40, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 41, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 42, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 43, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 44, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 45, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 46, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 47, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 48, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 49, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 50, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 51, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 52, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 53, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 55, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 56, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 57, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 58, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 59, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 1, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 2, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 3, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 4, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 5, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 6, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 7, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 8, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 9, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 10, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 11, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 12, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 13, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 14, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 15, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 16, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 17, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 18, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 19, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 20, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 21, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 22, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 23, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 24, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 25, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 26, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 27, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 28, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 29, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 30, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 31, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 32, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 33, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 34, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 35, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 36, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 37, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 38, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 39, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 40, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 41, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 42, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 43, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 44, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 45, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 46, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 47, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 48, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 49, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 50, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 51, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 52, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 53, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 55, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 56, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 57, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 30, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 31, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 32, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 33, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 34, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 35, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 36, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 37, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 38, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 39, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 40, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 41, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 42, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 43, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 44, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 45, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 46, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 47, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 48, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 49, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 50, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 51, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 52, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 53, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 55, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 56, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 57, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 58, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 59, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 1, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 2, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 3, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 4, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 5, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 6, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 7, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 8, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 9, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 10, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 11, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 12, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 13, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 14, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 15, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 16, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 17, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 18, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 19, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 20, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 21, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 22, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 23, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 24, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 25, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 26, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 27, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 30, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 31, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 32, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 33, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 34, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 35, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 36, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 37, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 38, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 39, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 40, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 41, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 42, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 43, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 44, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 45, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 46, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 47, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 48, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 49, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 50, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 51, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 52, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 53, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 55, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 56, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 57, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 58, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 59, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 1, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 2, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 3, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 4, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 5, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 6, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 7, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 8, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 9, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 10, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 11, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 12, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 13, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 14, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 15, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 16, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 17, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 18, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 19, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 20, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 21, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 22, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 23, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 24, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 25, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 26, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 27, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 28, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 29, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 30, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 31, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 32, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 33, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 34, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 35, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 36, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 37, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 38, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 39, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 40, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 41, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 42, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 43, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 44, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 45, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 46, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 47, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 48, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 49, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 50, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 51, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 52, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 53, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 55, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 56, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 57, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 30, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 31, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 32, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 33, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 34, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 35, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 36, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 37, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 38, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 39, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 40, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 41, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 42, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 43, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 44, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 45, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 46, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 47, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 48, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 49, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 50, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 51, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 52, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 53, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 55, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 56, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 57, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 58, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 59, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 1, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 2, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 3, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 4, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 5, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 6, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 7, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 8, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 9, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 10, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 11, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 12, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 13, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 14, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 15, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 16, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 17, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 18, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 19, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 20, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 21, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 22, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 23, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 24, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 25, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 26, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 27, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 28, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 29, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 30, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 31, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 32, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 33, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 34, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 35, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 36, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 37, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 38, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 39, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 40, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 41, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 42, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 43, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 44, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 45, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 46, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 47, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 48, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 49, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 50, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 51, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 52, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 53, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 55, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 56, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 57, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 30, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 31, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 32, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 33, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 34, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 35, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 36, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 37, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 38, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 39, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 40, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 41, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 42, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 43, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 44, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 45, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 46, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 47, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 48, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 49, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 50, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 51, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 52, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 53, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 55, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 56, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 57, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 58, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 59, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 1, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 2, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 3, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 4, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 5, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 6, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 7, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 8, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 9, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 11, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 12, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 13, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 14, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 16, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 17, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 18, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 19, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 30, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 31, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 32, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 33, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 34, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 42, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 43, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 44, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 45, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 30, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 31, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 32, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 33, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 34, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 35, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 36, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 37, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 38, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 39, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 40, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 41, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 42, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 43, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 44, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 45, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 46, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 47, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 48, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 49, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 50, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 51, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 52, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 53, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 55, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 56, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 57, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 58, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 59, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 1, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 2, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 3, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 4, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 5, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 9, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 10, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 11, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 12, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 13, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 30, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 31, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 32, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 33, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 34, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 35, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 36, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 37, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 38, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 39, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 40, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 41, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 42, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 43, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 44, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 45, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 46, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 47, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 48, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 49, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 50, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 51, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 52, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 53, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 55, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 56, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 57, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 58, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 59, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 1, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 2, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 3, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 4, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 5, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 6, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 7, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 8, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 9, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 10, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 11, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 12, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 13, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 14, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 15, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 16, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 17, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 18, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 19, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 20, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 21, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 22, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 23, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 24, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 25, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 26, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 27, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 28, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 29, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 30, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 31, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 32, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 33, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 34, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 35, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 36, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 37, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 38, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 39, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 40, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 41, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 42, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 43, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 44, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 45, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 46, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 47, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 48, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 49, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 50, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 51, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 52, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 53, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 55, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 56, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 57, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 30, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 31, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 32, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 33, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 34, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 35, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 36, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 37, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 38, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 55, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 56, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 57, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 4, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 5, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 6, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 11, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 12, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 13, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 14, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 15, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 16, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 17, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 18, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 19, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 20, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 21, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 22, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 23, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 24, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 25, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 26, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 27, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 28, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 29, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 30, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 31, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 30, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 31, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 32, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 33, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 34, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 35, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 36, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 37, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 38, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 47, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 48, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 49, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 50, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 51, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 52, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 53, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 55, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 56, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 57, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 35, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 38, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 53, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 57, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 58, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 59, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 16, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 17, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 18, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 19, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 23, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 24, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 25, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 26, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 29, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 30, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 31, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 32, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 33, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 34, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 37, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 38, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 39, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 40, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 41, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 42, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 43, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 44, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 45, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 46, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 47, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 48, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 49, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 50, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 51, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 52, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 53, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 55, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 56, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 57, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 36, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 37, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 39, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 40, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 41, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 55, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 56, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 1, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 20, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 21, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 22, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 36, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 37, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 12, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 13, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 14, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 15, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 16, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 17, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 18, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 19, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 20, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 21, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 22, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 23, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 24, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 25, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 26, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 27, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 28, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 29, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 30, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 31, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 32, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 39, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 40, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 41, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 42, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 43, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 44, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 45, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 46, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 47, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 48, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 49, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 50, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 51, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 52, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 53, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 55, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 56, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 57, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 37, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 38, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 39, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 40, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 41, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 42, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 43, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 44, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 45, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 46, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 47, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 49, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 50, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 51, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 52, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 53, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 55, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 56, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 57, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 58, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 59, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 1, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 2, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 3, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 4, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 5, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 6, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 7, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 8, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 9, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 10, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 11, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 12, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 13, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 14, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 15, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 16, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 17, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 18, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 19, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 20, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 21, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 22, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 23, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 24, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 25, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 26, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 27, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 28, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 29, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 30, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 31, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 32, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 33, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 34, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 35, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 36, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 37, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 38, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 39, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 40, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 41, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 42, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 43, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 44, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 45, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 46, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 47, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 48, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 49, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 50, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 51, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 52, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 53, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 55, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 56, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 57, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 40, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 41, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 47, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 48, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 50, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 51, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 52, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 53, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 55, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 56, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 57, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 58, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 10, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 11, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 12, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 25, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 26, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 47, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 48, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 53, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 55, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 48, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 51, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 52, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 53, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 5, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 6, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 7, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 8, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 10, 55, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 31, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 32, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 33, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 34, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 35, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 36, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 37, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 38, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 39, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 4, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 5, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 15, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 16, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 17, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 18, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 19, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 20, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 21, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 22, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 23, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 24, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 25, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 26, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 27, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 28, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 29, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 30, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 31, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 32, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 33, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 34, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 35, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 36, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 37, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 38, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 39, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 40, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 41, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 42, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 43, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 44, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 45, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 46, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 47, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 48, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 49, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 50, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 51, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 52, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 53, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 55, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 56, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 57, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 29, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 30, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 35, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 36, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 37, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 38, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 39, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 40, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 41, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 42, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 43, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 44, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 45, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 46, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 47, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 48, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 49, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 50, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 51, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 52, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 53, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 54, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 55, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 56, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 57, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 31, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 32, tzinfo=datetime.timezone.utc),), (datetime.datetime(2021, 6, 8, 7, 11, 34, tzinfo=datetime.timezone.utc),)]\n" + ] + } + ], + "source": [ + "times = filtered_world.get_time()\n", + "print(\"Times are:\", times)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "d2973e30", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bbox geos are: [(2.0351596988934304, 2.400814869380193, 1.0, 2.3896888485676846, 2.7472250308939685, 1.0), (2.0351596988934304, 2.400814869380193, 1.0, 2.3896888485676846, 2.7472250308939685, 1.0), (2.0351596988934304, 2.400814869380193, 1.0, 2.392395177954511, 2.7472250308939685, 1.0), (2.0351596988934304, 2.400814869380193, 1.0, 2.392395177954511, 2.7472250308939685, 1.0), (2.0351596988934304, 2.400814869380193, 1.0, 2.392395177954511, 2.7472250308939685, 1.0), (2.0351596988934304, 2.400814869380193, 1.0, 2.392395177954511, 2.7472250308939685, 1.0), (2.0351596988934304, 2.400814869380193, 1.0, 2.392395177954511, 2.7472250308939685, 1.0), (2.0351596988934304, 2.400814869380193, 1.0, 2.392395177954511, 2.7472250308939685, 1.0), (2.0351596988934304, 2.400814869380193, 1.0, 2.392395177954511, 2.7472250308939685, 1.0), (2.0351596988934304, 2.400814869380193, 1.0, 2.3896888485676846, 2.7472250308939685, 1.0), (2.0351596988934304, 2.400814869380193, 1.0, 2.392395177954511, 2.7472250308939685, 1.0), (2.0351596988934304, 2.400814869380193, 1.0, 2.392395177954511, 2.7472250308939685, 1.0), (2.0351596988934304, 2.400814869380193, 1.0, 2.392395177954511, 2.7472250308939685, 1.0), (2.0351596988934304, 2.400814869380193, 1.0, 2.3896888485676846, 2.7472250308939685, 1.0), (2.0351596988934304, 2.3960036171369463, 1.0, 2.3896888485676846, 2.7520362831372154, 1.0), (2.032453369506604, 2.3960036171369463, 1.0, 2.3896888485676846, 2.7472250308939685, 1.0), (2.0351596988934304, 2.3960036171369463, 1.0, 2.3869825191808585, 2.7472250308939685, 1.0), (2.0351596988934304, 2.3960036171369463, 1.0, 2.3869825191808585, 2.7472250308939685, 1.0), (2.0351596988934304, 2.3960036171369463, 1.0, 2.3869825191808585, 2.7472250308939685, 1.0), (2.0351596988934304, 2.3911923648936995, 1.0, 2.3869825191808585, 2.7472250308939685, 1.0), (2.032453369506604, 2.3960036171369463, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0351596988934304, 2.3911923648936995, 1.0, 2.3815698604072058, 2.7472250308939685, 1.0), (2.0351596988934304, 2.3911923648936995, 1.0, 2.3815698604072058, 2.7472250308939685, 1.0), (2.0351596988934304, 2.3911923648936995, 1.0, 2.3815698604072058, 2.7472250308939685, 1.0), (2.032453369506604, 2.3911923648936995, 1.0, 2.384276189794032, 2.7472250308939685, 1.0), (2.0297470401197772, 2.3911923648936995, 1.0, 2.3869825191808585, 2.7472250308939685, 1.0), (2.0297470401197772, 2.3911923648936995, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3911923648936995, 1.0, 2.384276189794032, 2.7472250308939685, 1.0), (2.0297470401197772, 2.3960036171369463, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3911923648936995, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3911923648936995, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3960036171369463, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3960036171369463, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3960036171369463, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.032453369506604, 2.3960036171369463, 1.0, 2.3896888485676846, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3960036171369463, 1.0, 2.392395177954511, 2.7520362831372154, 1.0), (2.032453369506604, 2.3960036171369463, 1.0, 2.392395177954511, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3960036171369463, 1.0, 2.392395177954511, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3960036171369463, 1.0, 2.392395177954511, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3960036171369463, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0297470401197772, 2.400814869380193, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0297470401197772, 2.400814869380193, 1.0, 2.392395177954511, 2.7520362831372154, 1.0), (2.0297470401197772, 2.400814869380193, 1.0, 2.392395177954511, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3960036171369463, 1.0, 2.392395177954511, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3960036171369463, 1.0, 2.392395177954511, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3960036171369463, 1.0, 2.392395177954511, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3960036171369463, 1.0, 2.3896888485676846, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3960036171369463, 1.0, 2.3896888485676846, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3960036171369463, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3960036171369463, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3960036171369463, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3960036171369463, 1.0, 2.384276189794032, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3960036171369463, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3960036171369463, 1.0, 2.3896888485676846, 2.7472250308939685, 1.0), (2.0297470401197772, 2.3960036171369463, 1.0, 2.392395177954511, 2.7472250308939685, 1.0), (2.0297470401197772, 2.3911923648936995, 1.0, 2.397807836728164, 2.7472250308939685, 1.0), (2.0297470401197772, 2.3960036171369463, 1.0, 2.392395177954511, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3911923648936995, 1.0, 2.397807836728164, 2.7472250308939685, 1.0), (2.0297470401197772, 2.3911923648936995, 1.0, 2.3951015073413373, 2.7472250308939685, 1.0), (2.0297470401197772, 2.3863811126504526, 1.0, 2.3951015073413373, 2.7424137786507217, 1.0), (2.0297470401197772, 2.3863811126504526, 1.0, 2.397807836728164, 2.7424137786507217, 1.0), (2.0297470401197772, 2.376758608163959, 1.0, 2.397807836728164, 2.7424137786507217, 1.0), (2.0297470401197772, 2.376758608163959, 1.0, 2.392395177954511, 2.7424137786507217, 1.0), (2.0297470401197772, 2.3863811126504526, 1.0, 2.392395177954511, 2.7472250308939685, 1.0), (2.0297470401197772, 2.3863811126504526, 1.0, 2.392395177954511, 2.7424137786507217, 1.0), (2.0297470401197772, 2.3863811126504526, 1.0, 2.392395177954511, 2.7424137786507217, 1.0), (2.0297470401197772, 2.3863811126504526, 1.0, 2.392395177954511, 2.7424137786507217, 1.0), (2.0297470401197772, 2.3863811126504526, 1.0, 2.392395177954511, 2.7424137786507217, 1.0), (2.0297470401197772, 2.3863811126504526, 1.0, 2.392395177954511, 2.7472250308939685, 1.0), (2.0297470401197772, 2.3911923648936995, 1.0, 2.3896888485676846, 2.7472250308939685, 1.0), (2.0297470401197772, 2.3911923648936995, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3863811126504526, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3911923648936995, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3863811126504526, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3863811126504526, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3863811126504526, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0297470401197772, 2.376758608163959, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0297470401197772, 2.376758608163959, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0297470401197772, 2.376758608163959, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3863811126504526, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3863811126504526, 1.0, 2.3869825191808585, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3863811126504526, 1.0, 2.3896888485676846, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3863811126504526, 1.0, 2.3896888485676846, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3863811126504526, 1.0, 2.392395177954511, 2.7424137786507217, 1.0), (2.0297470401197772, 2.3863811126504526, 1.0, 2.392395177954511, 2.7472250308939685, 1.0), (2.0297470401197772, 2.3863811126504526, 1.0, 2.3951015073413373, 2.7472250308939685, 1.0), (2.0297470401197772, 2.3863811126504526, 1.0, 2.3951015073413373, 2.7520362831372154, 1.0), (2.0297470401197772, 2.3863811126504526, 1.0, 2.3951015073413373, 2.7472250308939685, 1.0), (3.1934686764551166, 2.978165138569819, 1.0, 3.269245899286255, 3.3245753000835943, 1.0), (3.19076234706829, 2.9829763908130658, 1.0, 3.2611269111257757, 3.329386552326841, 1.0), (3.182643358907811, 2.9925988952995595, 1.0, 3.2584205817389496, 3.339009056813335, 1.0), (3.182643358907811, 2.9925988952995595, 1.0, 3.253007922965297, 3.339009056813335, 1.0), (3.1772307001341584, 3.002221399786053, 1.0, 3.247595264191644, 3.3486315612998285, 1.0), (3.169111711973679, 3.002221399786053, 1.0, 3.2448889348048175, 3.339009056813335, 1.0), (3.1609927238132, 3.002221399786053, 1.0, 3.242182605417991, 3.3534428135430754, 1.0), (3.155580065039547, 3.002221399786053, 1.0, 3.2367699466443383, 3.3630653180295695, 1.0), (3.152873735652721, 3.0070326520293, 1.0, 3.2286509584838594, 3.3678765702728164, 1.0), (3.1501674062658944, 3.016655156515794, 1.0, 3.225944629097033, 3.3630653180295695, 1.0), (3.1474610768790683, 3.021466408759041, 1.0, 3.217825640936554, 3.3582540657863227, 1.0), (3.1420484181054156, 3.026277661002288, 1.0, 3.2124129821629013, 3.3726878225160632, 1.0), (3.1339294299449363, 3.0310889132455348, 1.0, 3.2097066527760747, 3.3967440837322975, 1.0), (3.1339294299449363, 3.0310889132455348, 1.0, 3.2097066527760747, 3.415989092705285, 1.0), (3.1339294299449363, 3.0407114177320285, 1.0, 3.204293994002422, 3.4063665882187912, 1.0), (3.1285167711712836, 3.050333922218522, 1.0, 3.1988813352287693, 3.415989092705285, 1.0), (3.1203977830108047, 3.050333922218522, 1.0, 3.1961750058419427, 3.415989092705285, 1.0), (3.1149851242371516, 3.059956426705016, 1.0, 3.19076234706829, 3.4256115971917787, 1.0), (3.1122787948503254, 3.055145174461769, 1.0, 3.188056017681464, 3.4304228494350255, 1.0), (3.1068661360766727, 3.055145174461769, 1.0, 3.1772307001341584, 3.4304228494350255, 1.0), (3.104159806689846, 3.059956426705016, 1.0, 3.174524370747332, 3.4256115971917787, 1.0), (3.10145347730302, 3.0647676789482627, 1.0, 3.1718180413605057, 3.4352341016782724, 1.0), (3.0960408185293673, 3.0695789311915096, 1.0, 3.1718180413605057, 3.4352341016782724, 1.0), (3.0960408185293673, 3.0695789311915096, 1.0, 3.166405382586853, 3.4448566061647665, 1.0), (3.087921830368888, 3.0792014356780033, 1.0, 3.169111711973679, 3.4544791106512602, 1.0), (3.085215500982062, 3.088823940164497, 1.0, 3.166405382586853, 3.4544791106512602, 1.0), (3.085215500982062, 3.0984464446509907, 1.0, 3.166405382586853, 3.4544791106512602, 1.0), (3.085215500982062, 3.103257696894238, 1.0, 3.1609927238132, 3.4544791106512602, 1.0), (3.079802842208409, 3.108068949137485, 1.0, 3.1609927238132, 3.459290362894507, 1.0), (3.0770965128215826, 3.1128802013807317, 1.0, 3.1582863944263737, 3.459290362894507, 1.0), (3.0743901834347565, 3.1225027058672254, 1.0, 3.155580065039547, 3.459290362894507, 1.0), (3.07168385404793, 3.132125210353719, 1.0, 3.152873735652721, 3.459290362894507, 1.0), (3.07168385404793, 3.136936462596966, 1.0, 3.152873735652721, 3.459290362894507, 1.0), (3.07168385404793, 3.136936462596966, 1.0, 3.152873735652721, 3.459290362894507, 1.0), (3.07168385404793, 3.1465589670834597, 1.0, 3.152873735652721, 3.459290362894507, 1.0), (3.07168385404793, 3.1609927238132003, 1.0, 3.152873735652721, 3.459290362894507, 1.0), (3.0743901834347565, 3.165803976056447, 1.0, 3.155580065039547, 3.459290362894507, 1.0), (3.0743901834347565, 3.175426480542941, 1.0, 3.155580065039547, 3.459290362894507, 1.0), (3.07168385404793, 3.1850489850294346, 1.0, 3.1582863944263737, 3.459290362894507, 1.0), (3.0743901834347565, 3.1994827417591756, 1.0, 3.1609927238132, 3.459290362894507, 1.0), (3.0770965128215826, 3.2042939940024224, 1.0, 3.1582863944263737, 3.4544791106512602, 1.0), (3.079802842208409, 3.213916498488916, 1.0, 3.166405382586853, 3.459290362894507, 1.0), (3.0825091715952353, 3.218727750732163, 1.0, 3.169111711973679, 3.459290362894507, 1.0), (3.087921830368888, 3.2283502552186567, 1.0, 3.174524370747332, 3.459290362894507, 1.0), (3.0933344891425407, 3.2427840119483973, 1.0, 3.1799370295209846, 3.459290362894507, 1.0), (3.0960408185293673, 3.252406516434891, 1.0, 3.182643358907811, 3.459290362894507, 1.0), (3.10145347730302, 3.252406516434891, 1.0, 3.1934686764551166, 3.459290362894507, 1.0), (3.1068661360766727, 3.271651525407879, 1.0, 3.1988813352287693, 3.4544791106512602, 1.0), (3.1149851242371516, 3.2908965343808663, 1.0, 3.2070003233892486, 3.4496678584080134, 1.0), (3.1203977830108047, 3.30051903886736, 1.0, 3.2124129821629013, 3.4448566061647665, 1.0), (3.139342088718589, 3.3101415433538537, 1.0, 3.2313572878706855, 3.4544791106512602, 1.0), (3.1420484181054156, 3.3197640478403474, 1.0, 3.2448889348048175, 3.4544791106512602, 1.0), (3.1582863944263737, 3.329386552326841, 1.0, 3.255714252352123, 3.4544791106512602, 1.0), (3.169111711973679, 3.329386552326841, 1.0, 3.2665395698994284, 3.4544791106512602, 1.0), (3.19076234706829, 3.3438203090565817, 1.0, 3.277364887446734, 3.4544791106512602, 1.0), (3.19076234706829, 3.3438203090565817, 1.0, 3.277364887446734, 3.4544791106512602, 1.0), (3.2367699466443383, 3.37749907475931, 1.0, 3.290896534380866, 3.4544791106512602, 1.0), (3.2367699466443383, 3.37749907475931, 1.0, 3.290896534380866, 3.4544791106512602, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.5732794835417299, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.5732794835417299, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.5732794835417299, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.5732794835417299, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.5732794835417299, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.5732794835417299, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.5732794835417299, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.5732794835417299, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.5732794835417299, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.5732794835417299, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.5732794835417299, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.5732794835417299, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.5732794835417299, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.5732794835417299, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.5732794835417299, 1.0), (2.3707445428599, 1.3086606101631515, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3086606101631515, 1.0, 2.4384027775305595, 1.568468231298483, 1.0), (2.3707445428599, 1.3086606101631515, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.4384027775305595, 1.5732794835417299, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.5732794835417299, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.5732794835417299, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.5732794835417299, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.5732794835417299, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.5732794835417299, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.5732794835417299, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.5732794835417299, 1.0), (2.3707445428599, 1.3086606101631515, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3086606101631515, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3086606101631515, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3038493579199046, 1.0, 2.435696448143733, 1.5732794835417299, 1.0), (2.3707445428599, 1.3086606101631515, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3086606101631515, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3086606101631515, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3086606101631515, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3086606101631515, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3086606101631515, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3086606101631515, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3086606101631515, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3086606101631515, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (2.3707445428599, 1.3086606101631515, 1.0, 2.435696448143733, 1.568468231298483, 1.0), (0.4519570076000038, 2.3575135991909715, 1.0, 0.7604785576982099, 2.780903796596697, 1.0), (0.4519570076000038, 2.3575135991909715, 1.0, 0.7604785576982099, 2.780903796596697, 1.0), (0.4519570076000038, 2.3575135991909715, 1.0, 0.7604785576982099, 2.780903796596697, 1.0), (0.4519570076000038, 2.3575135991909715, 1.0, 0.7604785576982099, 2.780903796596697, 1.0), (0.4519570076000038, 2.3575135991909715, 1.0, 0.7604785576982099, 2.780903796596697, 1.0), (0.4519570076000038, 2.3575135991909715, 1.0, 0.7577722283113836, 2.780903796596697, 1.0), (0.4519570076000038, 2.3575135991909715, 1.0, 0.7604785576982099, 2.780903796596697, 1.0), (0.4519570076000038, 2.3575135991909715, 1.0, 0.7604785576982099, 2.780903796596697, 1.0), (0.4519570076000038, 2.3575135991909715, 1.0, 0.7604785576982099, 2.780903796596697, 1.0), (0.4519570076000038, 2.3575135991909715, 1.0, 0.7577722283113836, 2.780903796596697, 1.0), (0.4519570076000038, 2.3575135991909715, 1.0, 0.7577722283113836, 2.780903796596697, 1.0), (0.4519570076000038, 2.3575135991909715, 1.0, 0.7604785576982099, 2.780903796596697, 1.0), (0.4519570076000038, 2.3575135991909715, 1.0, 0.7604785576982099, 2.780903796596697, 1.0), (0.4519570076000038, 2.3575135991909715, 1.0, 0.7577722283113836, 2.780903796596697, 1.0), (0.45466333698683015, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.45466333698683015, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.45466333698683015, 2.3575135991909715, 1.0, 0.7577722283113836, 2.780903796596697, 1.0), (0.45466333698683015, 2.3575135991909715, 1.0, 0.7577722283113836, 2.780903796596697, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3575135991909715, 1.0, 0.7577722283113836, 2.780903796596697, 1.0), (0.4519570076000038, 2.3575135991909715, 1.0, 0.7577722283113836, 2.780903796596697, 1.0), (0.45466333698683015, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3575135991909715, 1.0, 0.7577722283113836, 2.780903796596697, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7604785576982099, 2.785715048839944, 1.0), (0.4519570076000038, 2.3575135991909715, 1.0, 0.7577722283113836, 2.780903796596697, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7604785576982099, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3575135991909715, 1.0, 0.7577722283113836, 2.780903796596697, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7604785576982099, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7604785576982099, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7604785576982099, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7604785576982099, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7604785576982099, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7604785576982099, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7604785576982099, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7604785576982099, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7604785576982099, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.45466333698683015, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.45466333698683015, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.45466333698683015, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.45466333698683015, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3575135991909715, 1.0, 0.7577722283113836, 2.780903796596697, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.45466333698683015, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.45466333698683015, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.45466333698683015, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.45466333698683015, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.45466333698683015, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.45466333698683015, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.45466333698683015, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.45466333698683015, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.45466333698683015, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3478910947044778, 1.0, 0.7577722283113836, 2.7905263010831907, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3527023469477246, 1.0, 0.7577722283113836, 2.785715048839944, 1.0), (0.4519570076000038, 2.3478910947044778, 1.0, 0.7577722283113836, 2.7905263010831907, 1.0), (0.4519570076000038, 2.3478910947044778, 1.0, 0.7550658989245572, 2.7905263010831907, 1.0), (0.4519570076000038, 2.3478910947044778, 1.0, 0.7577722283113836, 2.7905263010831907, 1.0), (0.4519570076000038, 2.3478910947044778, 1.0, 0.7577722283113836, 2.7905263010831907, 1.0), (0.4519570076000038, 2.3478910947044778, 1.0, 0.7577722283113836, 2.7905263010831907, 1.0), (0.4519570076000038, 2.3478910947044778, 1.0, 0.7577722283113836, 2.7905263010831907, 1.0), (0.549384865525753, 1.924500897298752, 1.0, 0.6603443703856342, 2.0399709511366773, 1.0), (0.549384865525753, 1.924500897298752, 1.0, 0.6603443703856342, 2.0399709511366773, 1.0), (0.549384865525753, 1.9196896450555052, 1.0, 0.6576380409988078, 2.0351596988934304, 1.0), (0.5439722067521003, 1.9148783928122584, 1.0, 0.6576380409988078, 2.0399709511366773, 1.0), (0.541265877365274, 1.9148783928122584, 1.0, 0.6576380409988078, 2.0399709511366773, 1.0), (0.5385595479784476, 1.9148783928122584, 1.0, 0.6549317116119815, 2.0399709511366773, 1.0), (0.5250279010443157, 1.9196896450555052, 1.0, 0.6549317116119815, 2.0351596988934304, 1.0), (0.519615242270663, 1.9196896450555052, 1.0, 0.6549317116119815, 2.0351596988934304, 1.0), (0.519615242270663, 1.9148783928122584, 1.0, 0.6522253822251551, 2.0351596988934304, 1.0), (0.5169089128838367, 1.9196896450555052, 1.0, 0.6495190528383288, 2.0351596988934304, 1.0), (0.5250279010443157, 1.924500897298752, 1.0, 0.6468127234515024, 2.0351596988934304, 1.0), (0.519615242270663, 1.924500897298752, 1.0, 0.6441063940646761, 2.0399709511366773, 1.0), (0.5250279010443157, 1.929312149541999, 1.0, 0.6386937352910234, 2.0351596988934304, 1.0), (0.511496254110184, 1.9196896450555052, 1.0, 0.6278684177437178, 2.0351596988934304, 1.0), (0.49796460717605207, 1.924500897298752, 1.0, 0.6224557589700651, 2.0303484466501835, 1.0), (0.49255194840239935, 1.929312149541999, 1.0, 0.6170431001964123, 2.0351596988934304, 1.0), (0.48984561901557294, 1.929312149541999, 1.0, 0.6143367708095859, 2.0351596988934304, 1.0), (0.4763139720814411, 1.929312149541999, 1.0, 0.6116304414227596, 2.0351596988934304, 1.0), (0.47360764269461475, 1.934123401785246, 1.0, 0.6062177826491069, 2.0303484466501835, 1.0), (0.4654886545341356, 1.929312149541999, 1.0, 0.6008051238754542, 2.0303484466501835, 1.0), (0.4654886545341356, 1.929312149541999, 1.0, 0.5953924651018014, 2.0303484466501835, 1.0), (0.47902030146826746, 1.929312149541999, 1.0, 0.5953924651018014, 2.0303484466501835, 1.0), (0.446544348826351, 1.929312149541999, 1.0, 0.571035500620364, 2.0351596988934304, 1.0), (0.4384253606658719, 1.924500897298752, 1.0, 0.571035500620364, 2.0351596988934304, 1.0), (0.4276000431185665, 1.924500897298752, 1.0, 0.5737418300071904, 2.0303484466501835, 1.0), (0.4221873843449137, 1.924500897298752, 1.0, 0.5683291712335377, 2.0351596988934304, 1.0), (0.41677472557126094, 1.9196896450555052, 1.0, 0.5629165124598849, 2.0351596988934304, 1.0), (0.40865573741078187, 1.9196896450555052, 1.0, 0.5575038536862322, 2.0351596988934304, 1.0), (0.3924177610898236, 1.9196896450555052, 1.0, 0.5466785361389267, 2.0351596988934304, 1.0), (0.3870051023161709, 1.9196896450555052, 1.0, 0.541265877365274, 2.0351596988934304, 1.0), (0.38159244354251814, 1.9148783928122584, 1.0, 0.5358532185916213, 2.0303484466501835, 1.0), (0.373473455382039, 1.9100671405690115, 1.0, 0.5304405598179684, 2.0303484466501835, 1.0), (0.3626481378347336, 1.9148783928122584, 1.0, 0.519615242270663, 2.0303484466501835, 1.0), (0.38159244354251814, 1.924500897298752, 1.0, 0.5142025834970103, 2.0303484466501835, 1.0), (0.40053674925030275, 1.9196896450555052, 1.0, 0.5142025834970103, 2.0303484466501835, 1.0), (0.3301721851928171, 1.924500897298752, 1.0, 0.5006709365628784, 2.0303484466501835, 1.0), (0.40053674925030275, 1.924500897298752, 1.0, 0.5087899247233576, 2.0255371944069367, 1.0), (0.3328785145796435, 1.924500897298752, 1.0, 0.48443296024192023, 2.0303484466501835, 1.0), (0.35182282028742806, 1.924500897298752, 1.0, 0.4763139720814411, 2.0255371944069367, 1.0), (0.35182282028742806, 1.924500897298752, 1.0, 0.4763139720814411, 2.0255371944069367, 1.0), (0.3193468676455117, 1.924500897298752, 1.0, 0.4384253606658719, 2.02072594216369, 1.0), (0.3328785145796435, 1.924500897298752, 1.0, 0.4276000431185665, 2.0255371944069367, 1.0), (0.3301721851928171, 1.924500897298752, 1.0, 0.41948105495808735, 2.02072594216369, 1.0), (0.3301721851928171, 1.924500897298752, 1.0, 0.41948105495808735, 2.02072594216369, 1.0), (0.29228357377724795, 1.9196896450555052, 1.0, 0.3870051023161709, 2.0399709511366773, 1.0), (0.2895772443904216, 1.924500897298752, 1.0, 0.3788861141556918, 2.0303484466501835, 1.0), (0.2895772443904216, 1.9196896450555052, 1.0, 0.373473455382039, 2.0255371944069367, 1.0), (0.2895772443904216, 1.9196896450555052, 1.0, 0.373473455382039, 2.0255371944069367, 1.0), (0.02976962325509007, 1.929312149541999, 1.0, 0.2598076211353315, 2.054404707866418, 1.0), (0.0270632938682637, 1.929312149541999, 1.0, 0.2354506566538942, 2.049593455623171, 1.0), (0.02165063509461096, 1.934123401785246, 1.0, 0.22462533910658872, 2.054404707866418, 1.0), (0.00541265877365274, 1.9389346540284929, 1.0, 0.21109369217245685, 2.054404707866418, 1.0), (0.00541265877365274, 1.9389346540284929, 1.0, 0.21109369217245685, 2.054404707866418, 1.0), (0.0, 1.9629909152447271, 1.0, 0.10554684608622843, 2.0640272123529115, 1.0), (0.0, 1.967802167487974, 1.0, 0.09201519915209658, 2.0640272123529115, 1.0), (0.0, 1.9629909152447271, 1.0, 0.08389621099161747, 2.0592159601096647, 1.0), (0.0, 1.9629909152447271, 1.0, 0.08389621099161747, 2.0592159601096647, 1.0), (0.02976962325509007, 2.09770597805564, 1.0, 0.07848355221796473, 2.323834833488243, 1.0), (0.02976962325509007, 2.09770597805564, 1.0, 0.07848355221796473, 2.319023581244996, 1.0), (0.02976962325509007, 2.09770597805564, 1.0, 0.07577722283113836, 2.319023581244996, 1.0), (0.02976962325509007, 2.09770597805564, 1.0, 0.07848355221796473, 2.319023581244996, 1.0), (0.0270632938682637, 2.09770597805564, 1.0, 0.0811898816047911, 2.319023581244996, 1.0), (0.0270632938682637, 2.09770597805564, 1.0, 0.0811898816047911, 2.323834833488243, 1.0), (0.02435696448143733, 2.09770597805564, 1.0, 0.0811898816047911, 2.323834833488243, 1.0), (0.02435696448143733, 2.09770597805564, 1.0, 0.0811898816047911, 2.319023581244996, 1.0), (0.0270632938682637, 2.09770597805564, 1.0, 0.0811898816047911, 2.319023581244996, 1.0), (0.0270632938682637, 2.09770597805564, 1.0, 0.0811898816047911, 2.319023581244996, 1.0), (0.0270632938682637, 2.09770597805564, 1.0, 0.0811898816047911, 2.3094010767585025, 1.0), (0.0270632938682637, 2.092894725812393, 1.0, 0.07848355221796473, 2.3094010767585025, 1.0), (0.02976962325509007, 2.09770597805564, 1.0, 0.07848355221796473, 2.3094010767585025, 1.0), (0.02976962325509007, 2.09770597805564, 1.0, 0.07848355221796473, 2.3094010767585025, 1.0), (0.02976962325509007, 2.09770597805564, 1.0, 0.07848355221796473, 2.3045898245152556, 1.0), (0.03247595264191644, 2.102517230298887, 1.0, 0.07848355221796473, 2.3045898245152556, 1.0), (0.03247595264191644, 2.102517230298887, 1.0, 0.0811898816047911, 2.3045898245152556, 1.0), (0.03247595264191644, 2.09770597805564, 1.0, 0.0811898816047911, 2.3045898245152556, 1.0), (0.03247595264191644, 2.09770597805564, 1.0, 0.0811898816047911, 2.2997785722720088, 1.0), (0.02976962325509007, 2.09770597805564, 1.0, 0.0811898816047911, 2.2997785722720088, 1.0), (0.02976962325509007, 2.09770597805564, 1.0, 0.08389621099161747, 2.3045898245152556, 1.0), (0.0270632938682637, 2.092894725812393, 1.0, 0.08389621099161747, 2.3045898245152556, 1.0), (0.0270632938682637, 2.092894725812393, 1.0, 0.08389621099161747, 2.3045898245152556, 1.0), (0.0270632938682637, 2.0880834735691463, 1.0, 0.08389621099161747, 2.2997785722720088, 1.0), (0.02976962325509007, 2.0880834735691463, 1.0, 0.0811898816047911, 2.2997785722720088, 1.0), (0.02976962325509007, 2.092894725812393, 1.0, 0.0811898816047911, 2.294967320028762, 1.0), (0.0270632938682637, 2.092894725812393, 1.0, 0.08389621099161747, 2.294967320028762, 1.0), (0.0270632938682637, 2.0880834735691463, 1.0, 0.08389621099161747, 2.2997785722720088, 1.0), (0.02976962325509007, 2.092894725812393, 1.0, 0.0811898816047911, 2.290156067785515, 1.0), (0.02976962325509007, 2.092894725812393, 1.0, 0.0811898816047911, 2.290156067785515, 1.0), (0.02976962325509007, 2.092894725812393, 1.0, 0.0811898816047911, 2.290156067785515, 1.0), (0.03247595264191644, 2.0880834735691463, 1.0, 0.08389621099161747, 2.2997785722720088, 1.0), (0.03518228202874281, 2.092894725812393, 1.0, 0.08389621099161747, 2.290156067785515, 1.0), (0.03518228202874281, 2.092894725812393, 1.0, 0.0811898816047911, 2.290156067785515, 1.0), (0.03788861141556918, 2.092894725812393, 1.0, 0.0811898816047911, 2.290156067785515, 1.0), (0.03788861141556918, 2.092894725812393, 1.0, 0.0811898816047911, 2.290156067785515, 1.0), (0.03247595264191644, 2.0880834735691463, 1.0, 0.08389621099161747, 2.3094010767585025, 1.0), (0.03518228202874281, 2.0880834735691463, 1.0, 0.08389621099161747, 2.3094010767585025, 1.0), (0.03788861141556918, 2.092894725812393, 1.0, 0.0811898816047911, 2.2997785722720088, 1.0), (0.03518228202874281, 2.092894725812393, 1.0, 0.0811898816047911, 2.3094010767585025, 1.0), (0.03518228202874281, 2.092894725812393, 1.0, 0.0811898816047911, 2.3094010767585025, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.21514189468504, 1.6213920059741986, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.21514189468504, 1.6213920059741986, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.21514189468504, 1.6213920059741986, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.21514189468504, 1.6213920059741986, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.21514189468504, 1.6213920059741986, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.21514189468504, 1.6213920059741986, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.21514189468504, 1.6213920059741986, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.21514189468504, 1.6213920059741986, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.21514189468504, 1.6213920059741986, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.21514189468504, 1.6213920059741986, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.21514189468504, 1.6213920059741986, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.21514189468504, 1.6213920059741986, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.21514189468504, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.21514189468504, 1.6213920059741986, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.1583089775616864, 1.4722431864335455, 1.0, 1.21514189468504, 1.6213920059741986, 1.0), (1.1583089775616864, 1.4722431864335455, 1.0, 1.21514189468504, 1.6262032582174455, 1.0), (1.1583089775616864, 1.4722431864335455, 1.0, 1.21514189468504, 1.6262032582174455, 1.0), (1.1583089775616864, 1.4674319341902986, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.1583089775616864, 1.4674319341902986, 1.0, 1.21514189468504, 1.6262032582174455, 1.0), (1.1583089775616864, 1.4722431864335455, 1.0, 1.21514189468504, 1.6262032582174455, 1.0), (1.1583089775616864, 1.4674319341902986, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.1583089775616864, 1.4674319341902986, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.1583089775616864, 1.4674319341902986, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.21514189468504, 1.6262032582174455, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.21514189468504, 1.6262032582174455, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.21514189468504, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.21514189468504, 1.6262032582174455, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.21514189468504, 1.6262032582174455, 1.0), (1.1583089775616864, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.21514189468504, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.21514189468504, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4674319341902986, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (1.15560264817486, 1.4626206819470515, 1.0, 1.2178482240718664, 1.6262032582174455, 1.0), (3.3341978045700875, 2.213176031893565, 1.0, 3.388324392306615, 2.5114736709748717, 1.0), (3.3341978045700875, 2.213176031893565, 1.0, 3.388324392306615, 2.5114736709748717, 1.0), (3.3341978045700875, 2.213176031893565, 1.0, 3.388324392306615, 2.5018511664883776, 1.0), (3.401856039240747, 2.40562612162344, 1.0, 3.461395285750927, 2.7712812921102032, 1.0), (3.3991497098539205, 2.40562612162344, 1.0, 3.461395285750927, 2.780903796596697, 1.0), (3.3964433804670944, 2.40562612162344, 1.0, 3.461395285750927, 2.780903796596697, 1.0), (3.3964433804670944, 2.40562612162344, 1.0, 3.461395285750927, 2.780903796596697, 1.0), (3.3964433804670944, 2.40562612162344, 1.0, 3.461395285750927, 2.780903796596697, 1.0), (3.3964433804670944, 2.40562612162344, 1.0, 3.461395285750927, 2.780903796596697, 1.0), (3.3639674278251777, 2.4441161395694153, 1.0, 3.445157309429969, 2.809771310056178, 1.0), (3.3639674278251777, 2.4441161395694153, 1.0, 3.445157309429969, 2.814582562299425, 1.0), (3.3612610984383515, 2.453738644055909, 1.0, 3.4424509800431426, 2.819393814542672, 1.0), (3.3612610984383515, 2.453738644055909, 1.0, 3.4424509800431426, 2.819393814542672, 1.0), (3.3612610984383515, 2.4441161395694153, 1.0, 3.4316256624958372, 2.8530725802454002, 1.0), (3.3612610984383515, 2.4441161395694153, 1.0, 3.4316256624958372, 2.857883832488647, 1.0), (3.3612610984383515, 2.4441161395694153, 1.0, 3.4316256624958372, 2.857883832488647, 1.0), (3.4153876861748786, 2.1891197706773307, 1.0, 3.461395285750927, 2.4729836530288964, 1.0), (3.4153876861748786, 2.1891197706773307, 1.0, 3.461395285750927, 2.4729836530288964, 1.0), (3.4153876861748786, 2.1891197706773307, 1.0, 3.461395285750927, 2.4729836530288964, 1.0), (3.4153876861748786, 2.1891197706773307, 1.0, 3.461395285750927, 2.4681724007856496, 1.0), (3.4153876861748786, 2.1891197706773307, 1.0, 3.461395285750927, 2.4633611485424027, 1.0), (3.4153876861748786, 2.1891197706773307, 1.0, 3.461395285750927, 2.4633611485424027, 1.0), (3.420800344948532, 2.184308518434084, 1.0, 3.461395285750927, 2.458549896299156, 1.0), (3.420800344948532, 2.184308518434084, 1.0, 3.461395285750927, 2.458549896299156, 1.0), (3.420800344948532, 2.184308518434084, 1.0, 3.461395285750927, 2.458549896299156, 1.0), (3.420800344948532, 2.184308518434084, 1.0, 3.461395285750927, 2.453738644055909, 1.0), (3.423506674335358, 2.184308518434084, 1.0, 3.461395285750927, 2.453738644055909, 1.0), (3.423506674335358, 2.184308518434084, 1.0, 3.461395285750927, 2.453738644055909, 1.0), (3.423506674335358, 2.1891197706773307, 1.0, 3.461395285750927, 2.453738644055909, 1.0), (3.423506674335358, 2.1891197706773307, 1.0, 3.461395285750927, 2.453738644055909, 1.0), (3.423506674335358, 2.184308518434084, 1.0, 3.461395285750927, 2.453738644055909, 1.0), (3.4262130037221845, 2.184308518434084, 1.0, 3.461395285750927, 2.453738644055909, 1.0), (3.423506674335358, 2.184308518434084, 1.0, 3.461395285750927, 2.453738644055909, 1.0), (3.4262130037221845, 2.184308518434084, 1.0, 3.461395285750927, 2.448927391812662, 1.0), (3.4289193331090106, 2.184308518434084, 1.0, 3.461395285750927, 2.448927391812662, 1.0), (3.4289193331090106, 2.1939310229205775, 1.0, 3.461395285750927, 2.448927391812662, 1.0), (3.4289193331090106, 2.1939310229205775, 1.0, 3.461395285750927, 2.448927391812662, 1.0), (3.3802054041461362, 2.208364779650318, 1.0, 3.4289193331090106, 2.492228662001884, 1.0), (3.3829117335329624, 2.208364779650318, 1.0, 3.4316256624958372, 2.492228662001884, 1.0), (3.3829117335329624, 2.213176031893565, 1.0, 3.4316256624958372, 2.492228662001884, 1.0), (3.3802054041461362, 2.208364779650318, 1.0, 3.4343319918826634, 2.492228662001884, 1.0), (3.3774990747593097, 2.203553527407071, 1.0, 3.4316256624958372, 2.492228662001884, 1.0), (3.3774990747593097, 2.203553527407071, 1.0, 3.43703832126949, 2.492228662001884, 1.0), (3.3774990747593097, 2.203553527407071, 1.0, 3.43703832126949, 2.492228662001884, 1.0), (3.3802054041461362, 2.1939310229205775, 1.0, 3.4343319918826634, 2.4633611485424027, 1.0), (3.3802054041461362, 2.1939310229205775, 1.0, 3.4343319918826634, 2.4633611485424027, 1.0), (2.619726846447926, 2.102517230298887, 1.0, 2.64679014031619, 2.256477302082787, 1.0), (2.6143141876742733, 2.1073284825421337, 1.0, 2.64679014031619, 2.256477302082787, 1.0), (2.6143141876742733, 2.1073284825421337, 1.0, 2.64679014031619, 2.256477302082787, 1.0), (2.6089015289006205, 2.09770597805564, 1.0, 2.64679014031619, 2.261288554326034, 1.0), (2.6089015289006205, 2.0880834735691463, 1.0, 2.64679014031619, 2.266099806569281, 1.0), (2.6089015289006205, 2.092894725812393, 1.0, 2.64679014031619, 2.256477302082787, 1.0), (2.6089015289006205, 2.0880834735691463, 1.0, 2.64679014031619, 2.256477302082787, 1.0), (2.6089015289006205, 2.0832722213258994, 1.0, 2.641377481542537, 2.256477302082787, 1.0), (2.6061951995137944, 2.078460969082652, 1.0, 2.6386711521557107, 2.266099806569281, 1.0), (2.6061951995137944, 2.078460969082652, 1.0, 2.635964822768884, 2.266099806569281, 1.0), (2.6061951995137944, 2.078460969082652, 1.0, 2.635964822768884, 2.266099806569281, 1.0), (1.2719748118083938, 2.208364779650318, 1.0, 1.3152760819976157, 2.424871130596428, 1.0), (1.266562153034741, 2.217987284136812, 1.0, 1.3152760819976157, 2.4200598783531806, 1.0), (1.2394988591664775, 2.1939310229205775, 1.0, 1.280093799968873, 2.40562612162344, 1.0), (1.2394988591664775, 2.1891197706773307, 1.0, 1.2773874705820467, 2.40562612162344, 1.0), (1.2340862003928246, 2.1939310229205775, 1.0, 1.2746811411952201, 2.40562612162344, 1.0), (1.2340862003928246, 2.184308518434084, 1.0, 1.2719748118083938, 2.40562612162344, 1.0), (1.2340862003928246, 2.213176031893565, 1.0, 1.2719748118083938, 2.400814869380193, 1.0), (1.207022906524561, 2.1698747617043432, 1.0, 1.2394988591664775, 2.3863811126504526, 1.0), (1.2043165771377347, 2.160252257217849, 1.0, 1.2422051885533039, 2.3960036171369463, 1.0), (1.2043165771377347, 2.17468601394759, 1.0, 1.2394988591664775, 2.3863811126504526, 1.0), (1.2016102477509083, 2.1554410049746022, 1.0, 1.2394988591664775, 2.3863811126504526, 1.0), (1.1934912595904292, 2.179497266190837, 1.0, 1.2367925297796512, 2.3815698604072058, 1.0), (1.1907849302036029, 2.179497266190837, 1.0, 1.2367925297796512, 2.376758608163959, 1.0), (1.1907849302036029, 2.1891197706773307, 1.0, 1.2340862003928246, 2.376758608163959, 1.0), (1.1907849302036029, 2.1891197706773307, 1.0, 1.2340862003928246, 2.376758608163959, 1.0), (1.18537227142995, 2.1939310229205775, 1.0, 1.2313798710059982, 2.371947355920712, 1.0), (1.18537227142995, 2.184308518434084, 1.0, 1.2313798710059982, 2.371947355920712, 1.0), (1.18537227142995, 2.1698747617043432, 1.0, 1.2286735416191719, 2.371947355920712, 1.0), (1.18537227142995, 2.17468601394759, 1.0, 1.2259672122323455, 2.371947355920712, 1.0), (1.1799596126562972, 2.1506297527313554, 1.0, 1.2205545534586928, 2.371947355920712, 1.0), (1.1799596126562972, 2.1506297527313554, 1.0, 1.2205545534586928, 2.371947355920712, 1.0), (1.1772532832694709, 2.1458185004881085, 1.0, 1.2178482240718664, 2.3575135991909715, 1.0), (1.1745469538826445, 2.1458185004881085, 1.0, 1.21514189468504, 2.3575135991909715, 1.0), (1.1745469538826445, 2.136195996001615, 1.0, 1.2124355652982137, 2.3623248514342183, 1.0), (1.1745469538826445, 2.136195996001615, 1.0, 1.2124355652982137, 2.3575135991909715, 1.0), (1.1745469538826445, 2.1410072482448617, 1.0, 1.2097292359113874, 2.3575135991909715, 1.0), (1.1718406244958182, 2.1458185004881085, 1.0, 1.207022906524561, 2.3478910947044778, 1.0), (1.1691342951089918, 2.1458185004881085, 1.0, 1.2043165771377347, 2.3478910947044778, 1.0), (1.163721636335339, 2.1554410049746022, 1.0, 1.2016102477509083, 2.3478910947044778, 1.0), (1.163721636335339, 2.165063509461096, 1.0, 1.2016102477509083, 2.3478910947044778, 1.0), (1.163721636335339, 2.165063509461096, 1.0, 1.198903918364082, 2.3478910947044778, 1.0), (1.163721636335339, 2.165063509461096, 1.0, 1.198903918364082, 2.3478910947044778, 1.0), (1.163721636335339, 2.165063509461096, 1.0, 1.1961975889772556, 2.343079842461231, 1.0), (1.1610153069485127, 2.165063509461096, 1.0, 1.1961975889772556, 2.3478910947044778, 1.0), (1.1610153069485127, 2.1554410049746022, 1.0, 1.1961975889772556, 2.3478910947044778, 1.0), (1.1583089775616864, 2.136195996001615, 1.0, 1.2016102477509083, 2.3478910947044778, 1.0), (1.1528963187880337, 2.131384743758368, 1.0, 1.198903918364082, 2.3478910947044778, 1.0), (1.1528963187880337, 2.131384743758368, 1.0, 1.1961975889772556, 2.338268590217984, 1.0), (1.1528963187880337, 2.131384743758368, 1.0, 1.1961975889772556, 2.32864608573149, 1.0), (1.1501899894012073, 2.131384743758368, 1.0, 1.1934912595904292, 2.32864608573149, 1.0), (1.1501899894012073, 2.131384743758368, 1.0, 1.1934912595904292, 2.3334573379747368, 1.0), (1.1501899894012073, 2.126573491515121, 1.0, 1.1907849302036029, 2.32864608573149, 1.0), (1.2692684824215674, 2.213176031893565, 1.0, 1.3152760819976157, 2.424871130596428, 1.0), (1.266562153034741, 2.213176031893565, 1.0, 1.3152760819976157, 2.424871130596428, 1.0), (1.2611494942610884, 2.1891197706773307, 1.0, 1.3152760819976157, 2.424871130596428, 1.0), (1.258443164874262, 2.1939310229205775, 1.0, 1.3152760819976157, 2.424871130596428, 1.0), (1.258443164874262, 2.1939310229205775, 1.0, 1.3152760819976157, 2.424871130596428, 1.0), (1.2367925297796512, 2.184308518434084, 1.0, 1.2773874705820467, 2.40562612162344, 1.0), (1.2340862003928246, 2.184308518434084, 1.0, 1.2773874705820467, 2.410437373866687, 1.0), (1.2286735416191719, 2.165063509461096, 1.0, 1.2719748118083938, 2.40562612162344, 1.0), (1.2286735416191719, 2.165063509461096, 1.0, 1.2719748118083938, 2.40562612162344, 1.0), (1.2016102477509083, 2.160252257217849, 1.0, 1.2394988591664775, 2.3863811126504526, 1.0), (1.198903918364082, 2.160252257217849, 1.0, 1.2394988591664775, 2.3815698604072058, 1.0), (1.198903918364082, 2.160252257217849, 1.0, 1.2394988591664775, 2.3815698604072058, 1.0), (3.3396104633437407, 2.213176031893565, 1.0, 3.393737051080268, 2.4970399142451307, 1.0), (3.3396104633437407, 2.213176031893565, 1.0, 3.393737051080268, 2.4970399142451307, 1.0), (3.3639674278251777, 2.1891197706773307, 1.0, 3.4180940155617052, 2.453738644055909, 1.0), (3.3639674278251777, 2.184308518434084, 1.0, 3.4180940155617052, 2.453738644055909, 1.0), (3.3639674278251777, 2.184308518434084, 1.0, 3.4180940155617052, 2.453738644055909, 1.0), (3.3639674278251777, 2.184308518434084, 1.0, 3.4180940155617052, 2.448927391812662, 1.0), (3.3639674278251777, 2.184308518434084, 1.0, 3.4180940155617052, 2.448927391812662, 1.0), (3.3639674278251777, 2.1891197706773307, 1.0, 3.4180940155617052, 2.448927391812662, 1.0), (3.3666737572120042, 2.1939310229205775, 1.0, 3.420800344948532, 2.4441161395694153, 1.0), (3.3666737572120042, 2.1891197706773307, 1.0, 3.420800344948532, 2.448927391812662, 1.0), (3.3666737572120042, 2.1891197706773307, 1.0, 3.420800344948532, 2.448927391812662, 1.0), (3.3666737572120042, 2.184308518434084, 1.0, 3.420800344948532, 2.453738644055909, 1.0), (3.3666737572120042, 2.184308518434084, 1.0, 3.420800344948532, 2.453738644055909, 1.0), (3.3666737572120042, 2.184308518434084, 1.0, 3.420800344948532, 2.448927391812662, 1.0), (3.3666737572120042, 2.184308518434084, 1.0, 3.420800344948532, 2.448927391812662, 1.0), (3.3666737572120042, 2.184308518434084, 1.0, 3.420800344948532, 2.4441161395694153, 1.0), (3.3666737572120042, 2.184308518434084, 1.0, 3.420800344948532, 2.4441161395694153, 1.0), (3.3666737572120042, 2.184308518434084, 1.0, 3.420800344948532, 2.4441161395694153, 1.0), (3.3693800865988304, 2.1891197706773307, 1.0, 3.4180940155617052, 2.4393048873261685, 1.0), (3.3666737572120042, 2.184308518434084, 1.0, 3.420800344948532, 2.4393048873261685, 1.0), (3.374792745372483, 2.1891197706773307, 1.0, 3.4180940155617052, 2.4441161395694153, 1.0), (3.3774990747593097, 2.184308518434084, 1.0, 3.420800344948532, 2.4441161395694153, 1.0), (3.3774990747593097, 2.184308518434084, 1.0, 3.420800344948532, 2.4441161395694153, 1.0), (3.3829117335329624, 2.1891197706773307, 1.0, 3.4316256624958372, 2.4393048873261685, 1.0), (3.3774990747593097, 2.1891197706773307, 1.0, 3.43703832126949, 2.4344936350829216, 1.0), (3.3774990747593097, 2.1939310229205775, 1.0, 3.43703832126949, 2.4344936350829216, 1.0), (3.3802054041461362, 2.1939310229205775, 1.0, 3.4343319918826634, 2.4344936350829216, 1.0), (3.3829117335329624, 2.1891197706773307, 1.0, 3.4316256624958372, 2.4393048873261685, 1.0), (3.3829117335329624, 2.1891197706773307, 1.0, 3.4316256624958372, 2.4344936350829216, 1.0), (3.385618062919789, 2.1939310229205775, 1.0, 3.4289193331090106, 2.4344936350829216, 1.0), (3.388324392306615, 2.1891197706773307, 1.0, 3.4262130037221845, 2.4344936350829216, 1.0), (3.388324392306615, 2.184308518434084, 1.0, 3.4262130037221845, 2.4296823828396747, 1.0), (3.388324392306615, 2.184308518434084, 1.0, 3.4262130037221845, 2.4296823828396747, 1.0), (3.385618062919789, 2.184308518434084, 1.0, 3.4289193331090106, 2.424871130596428, 1.0), (3.385618062919789, 2.179497266190837, 1.0, 3.4289193331090106, 2.424871130596428, 1.0), (3.385618062919789, 2.184308518434084, 1.0, 3.4289193331090106, 2.424871130596428, 1.0), (3.388324392306615, 2.179497266190837, 1.0, 3.4316256624958372, 2.4200598783531806, 1.0), (3.385618062919789, 2.179497266190837, 1.0, 3.4343319918826634, 2.4152486261099337, 1.0), (3.3910307216934417, 2.179497266190837, 1.0, 3.4343319918826634, 2.4152486261099337, 1.0), (3.3964433804670944, 2.184308518434084, 1.0, 3.439744650656316, 2.4152486261099337, 1.0), (3.3964433804670944, 2.179497266190837, 1.0, 3.445157309429969, 2.4152486261099337, 1.0), (3.3964433804670944, 2.179497266190837, 1.0, 3.445157309429969, 2.4152486261099337, 1.0), (2.116349580498221, 3.2331615074619036, 1.0, 2.7117420456000225, 3.4544791106512602, 1.0), (2.116349580498221, 3.165803976056447, 1.0, 2.700916728052717, 3.4544791106512602, 1.0), (2.1190559098850477, 3.1561814715699534, 1.0, 2.698210398665891, 3.4544791106512602, 1.0), (2.129881227432353, 3.1273139581104723, 1.0, 2.6927977398922383, 3.4544791106512602, 1.0), (2.135293886206006, 3.088823940164497, 1.0, 2.6873850811185855, 3.4496678584080134, 1.0), (2.143412874366485, 3.059956426705016, 1.0, 2.684678751731759, 3.4496678584080134, 1.0), (2.1380002155928324, 3.0407114177320285, 1.0, 2.6900914105054117, 3.4544791106512602, 1.0), (2.146119203753311, 3.021466408759041, 1.0, 2.6792660929581062, 3.4544791106512602, 1.0), (2.1596508506874432, 2.978165138569819, 1.0, 2.668440775410801, 3.4496678584080134, 1.0), (2.165063509461096, 2.934863868380597, 1.0, 2.663028116637148, 3.4544791106512602, 1.0), (2.1758888270084014, 2.9059963549211156, 1.0, 2.64679014031619, 3.4544791106512602, 1.0), (2.200245791489839, 2.857883832488647, 1.0, 2.6089015289006205, 3.459290362894507, 1.0), (2.208364779650318, 2.8482613280021534, 1.0, 2.6007825407401417, 3.459290362894507, 1.0), (2.2191900971976235, 2.838638823515659, 1.0, 2.5926635525796624, 3.4544791106512602, 1.0), (2.213777438423971, 2.814582562299425, 1.0, 2.5872508938060097, 3.4448566061647665, 1.0), (2.2191900971976235, 2.8049600578129312, 1.0, 2.5764255762587043, 3.4352341016782724, 1.0), (2.208364779650318, 2.7905263010831907, 1.0, 2.5872508938060097, 3.4544791106512602, 1.0), (2.208364779650318, 2.77609254435345, 1.0, 2.581838235032357, 3.459290362894507, 1.0), (2.208364779650318, 2.7712812921102032, 1.0, 2.5764255762587043, 3.4544791106512602, 1.0), (2.208364779650318, 2.7616587876237095, 1.0, 2.5710129174850516, 3.4544791106512602, 1.0), (2.211071109037144, 2.7472250308939685, 1.0, 2.568306588098225, 3.4544791106512602, 1.0), (2.213777438423971, 2.737602526407475, 1.0, 2.565600258711399, 3.4544791106512602, 1.0), (2.2191900971976235, 2.732791274164228, 1.0, 2.565600258711399, 3.4352341016782724, 1.0), (2.2191900971976235, 2.7135462651912405, 1.0, 2.565600258711399, 3.415989092705285, 1.0), (2.2191900971976235, 2.694301256218253, 1.0, 2.565600258711399, 3.3967440837322975, 1.0), (2.224602755971276, 2.6798674994885125, 1.0, 2.5710129174850516, 3.37749907475931, 1.0), (2.230015414744929, 2.6750562472452653, 1.0, 2.581838235032357, 3.3726878225160632, 1.0), (2.2381344029054078, 2.6750562472452653, 1.0, 2.589957223192836, 3.339009056813335, 1.0), (2.2435470616790605, 2.6654337427587715, 1.0, 2.598076211353315, 3.3197640478403474, 1.0), (2.248959720452713, 2.6654337427587715, 1.0, 2.6089015289006205, 3.295707786624113, 1.0), (2.2570787086131925, 2.646188733785784, 1.0, 2.619726846447926, 3.2812740298943726, 1.0), (2.259785038000019, 2.6317549770560436, 1.0, 2.633258493382058, 3.257217768678138, 1.0), (2.267904026160498, 2.62213247256955, 1.0, 2.64679014031619, 3.2331615074619036, 1.0), (2.2787293437078033, 2.6076987158398093, 1.0, 2.663028116637148, 3.213916498488916, 1.0), (2.284142002481456, 2.5980762113533156, 1.0, 2.668440775410801, 3.1946714895159287, 1.0), (2.2949673200287615, 2.5884537068668214, 1.0, 2.6792660929581062, 3.165803976056447, 1.0), (2.3057926375760673, 2.574019950137081, 1.0, 2.6900914105054117, 3.1465589670834597, 1.0), (2.3247369432838516, 2.574019950137081, 1.0, 2.7036230574395437, 3.1176914536239786, 1.0), (2.3382685902179836, 2.5595861934073403, 1.0, 2.7117420456000225, 3.0984464446509907, 1.0), (2.349093907765289, 2.5547749411640934, 1.0, 2.727980021920981, 3.0743901834347565, 1.0), (2.3599192253125945, 2.540341184434353, 1.0, 2.7415116688551127, 3.050333922218522, 1.0), (2.3761572016335526, 2.530718679947859, 1.0, 2.749630657015592, 3.0310889132455348, 1.0), (2.3869825191808585, 2.5162849232181186, 1.0, 2.7604559745628974, 3.016655156515794, 1.0), (2.4059268248886427, 2.506662418731625, 1.0, 2.7739876214970294, 2.9974101475428063, 1.0), (2.4194584718227747, 2.4970399142451307, 1.0, 2.7902255978179875, 2.978165138569819, 1.0), (2.43028378937008, 2.48260615751539, 1.0, 2.803757244752119, 2.9541088773535846, 1.0), (2.4465217656910383, 2.4777949052721433, 1.0, 2.8199952210730777, 2.939675120623844, 1.0), (2.4627597420119964, 2.4633611485424027, 1.0, 2.833526868007209, 2.9156188594076093, 1.0), (2.478997718332955, 2.458549896299156, 1.0, 2.847058514941341, 2.9011851026778688, 1.0), (2.4898230358802604, 2.4441161395694153, 1.0, 2.847058514941341, 2.896373850434622, 1.0), (2.5060610122012186, 2.4344936350829216, 1.0, 2.868709150035952, 2.867506336975141, 1.0), (2.5195926591353506, 2.4344936350829216, 1.0, 2.8795344675832575, 2.857883832488647, 1.0), (2.533124306069482, 2.4296823828396747, 1.0, 2.88494712635691, 2.843450075758906, 1.0), (2.546655953003614, 2.424871130596428, 1.0, 2.8957724439042156, 2.838638823515659, 1.0), (2.560187599937746, 2.4152486261099337, 1.0, 2.912010420225174, 2.819393814542672, 1.0), (2.5710129174850516, 2.4152486261099337, 1.0, 2.9228357377724796, 2.809771310056178, 1.0), (2.584544564419183, 2.400814869380193, 1.0, 2.9282483965461323, 2.8001488055696844, 1.0), (2.598076211353315, 2.3911923648936995, 1.0, 2.936367384706611, 2.785715048839944, 1.0), (2.603488870126968, 2.3863811126504526, 1.0, 2.9444863728670905, 2.77609254435345, 1.0), (2.6143141876742733, 2.3863811126504526, 1.0, 2.947192702253917, 2.7616587876237095, 1.0), (2.6251395052215787, 2.3863811126504526, 1.0, 2.9526053610275698, 2.7568475353804622, 1.0), (2.641377481542537, 2.376758608163959, 1.0, 2.9607243491880486, 2.7424137786507217, 1.0), (2.6440838109293634, 2.367136103677465, 1.0, 2.9742559961221806, 2.732791274164228, 1.0), (2.654909128476669, 2.3623248514342183, 1.0, 2.9796686548958333, 2.7231687696777342, 1.0), (2.668440775410801, 2.3575135991909715, 1.0, 2.987787643056312, 2.7135462651912405, 1.0), (2.6792660929581062, 2.3575135991909715, 1.0, 2.9932003018299653, 2.7135462651912405, 1.0), (2.684678751731759, 2.3575135991909715, 1.0, 2.998612960603618, 2.7135462651912405, 1.0), (2.6955040692790644, 2.3527023469477246, 1.0, 3.0094382781509235, 2.6894900039750063, 1.0), (2.7036230574395437, 2.3478910947044778, 1.0, 3.0121446075377496, 2.6846787517317594, 1.0), (2.7117420456000225, 2.338268590217984, 1.0, 3.020263595698229, 2.6750562472452653, 1.0), (2.7171547043736752, 2.32864608573149, 1.0, 3.0283825838587077, 2.6750562472452653, 1.0), (2.733392680694634, 2.319023581244996, 1.0, 3.036501572019187, 2.6654337427587715, 1.0), (2.7442179982419392, 2.319023581244996, 1.0, 3.0446205601796663, 2.655811238272278, 1.0), (2.749630657015592, 2.319023581244996, 1.0, 3.0473268895664924, 2.646188733785784, 1.0), (2.7631623039497235, 2.3142123290017493, 1.0, 3.0608585365006244, 2.6413774815425373, 1.0), (2.7739876214970294, 2.3094010767585025, 1.0, 3.066271195274277, 2.6365662292992904, 1.0), (2.779400280270682, 2.3094010767585025, 1.0, 3.07168385404793, 2.6269437248127967, 1.0), (2.7902255978179875, 2.2997785722720088, 1.0, 3.0770965128215826, 2.617321220326303, 1.0), (2.7983445859784664, 2.2997785722720088, 1.0, 3.085215500982062, 2.612509968083056, 1.0), (2.809169903525772, 2.294967320028762, 1.0, 3.0960408185293673, 2.6028874635965624, 1.0), (2.533124306069482, 2.1169509870286274, 1.0, 2.5764255762587043, 2.319023581244996, 1.0), (2.533124306069482, 2.1169509870286274, 1.0, 2.5764255762587043, 2.319023581244996, 1.0), (2.514180000361698, 2.1121397347853805, 1.0, 2.5628939293245723, 2.32864608573149, 1.0), (2.514180000361698, 2.1121397347853805, 1.0, 2.5628939293245723, 2.32864608573149, 1.0), (2.5060610122012186, 2.1217622392718742, 1.0, 2.538536964843135, 2.323834833488243, 1.0), (2.503354682814392, 2.1121397347853805, 1.0, 2.5412432942299614, 2.32864608573149, 1.0), (2.503354682814392, 2.1169509870286274, 1.0, 2.5412432942299614, 2.3334573379747368, 1.0), (2.500648353427566, 2.1121397347853805, 1.0, 2.538536964843135, 2.3334573379747368, 1.0), (2.4979420240407393, 2.1073284825421337, 1.0, 2.538536964843135, 2.3334573379747368, 1.0), (2.4979420240407393, 2.1073284825421337, 1.0, 2.538536964843135, 2.338268590217984, 1.0), (2.4979420240407393, 2.1121397347853805, 1.0, 2.538536964843135, 2.338268590217984, 1.0), (2.4898230358802604, 2.1217622392718742, 1.0, 2.538536964843135, 2.3334573379747368, 1.0), (2.4898230358802604, 2.1217622392718742, 1.0, 2.538536964843135, 2.3334573379747368, 1.0), (2.9255420671593058, 1.967802167487974, 1.0, 2.968843337348528, 2.1169509870286274, 1.0), (2.9309547259329585, 1.9629909152447271, 1.0, 2.968843337348528, 2.1169509870286274, 1.0), (2.9309547259329585, 1.9629909152447271, 1.0, 2.968843337348528, 2.1169509870286274, 1.0), (2.414045813049122, 2.1458185004881085, 1.0, 2.4627597420119964, 2.376758608163959, 1.0), (2.414045813049122, 2.1458185004881085, 1.0, 2.4627597420119964, 2.376758608163959, 1.0), (2.9823749842826595, 1.9726134197312208, 1.0, 3.0040256193772708, 2.102517230298887, 1.0), (2.9823749842826595, 1.9726134197312208, 1.0, 3.0040256193772708, 2.102517230298887, 1.0), (2.3247369432838516, 2.17468601394759, 1.0, 2.3815698604072058, 2.3960036171369463, 1.0), (2.3220306138970255, 2.17468601394759, 1.0, 2.3761572016335526, 2.400814869380193, 1.0), (2.3220306138970255, 2.17468601394759, 1.0, 2.3761572016335526, 2.400814869380193, 1.0), (2.181301485782054, 2.857883832488647, 1.0, 2.6386711521557107, 3.4448566061647665, 1.0), (0.446544348826351, 1.934123401785246, 1.0, 0.5304405598179684, 2.0255371944069367, 1.0), (0.446544348826351, 1.934123401785246, 1.0, 0.5304405598179684, 2.0255371944069367, 1.0), (0.5087899247233576, 1.934123401785246, 1.0, 0.5845671475544959, 2.0303484466501835, 1.0), (0.5087899247233576, 1.934123401785246, 1.0, 0.5845671475544959, 2.0303484466501835, 1.0), (0.41948105495808735, 1.9148783928122584, 1.0, 0.511496254110184, 2.02072594216369, 1.0), (0.41948105495808735, 1.9148783928122584, 1.0, 0.511496254110184, 2.02072594216369, 1.0), (0.3978304198634764, 1.924500897298752, 1.0, 0.49255194840239935, 2.02072594216369, 1.0), (0.3978304198634764, 1.924500897298752, 1.0, 0.49255194840239935, 2.02072594216369, 1.0), (2.70632938682637, 2.0880834735691463, 1.0, 2.7388053394682865, 2.2324210408665524, 1.0), (2.70632938682637, 2.0880834735691463, 1.0, 2.7388053394682865, 2.2324210408665524, 1.0), (2.641377481542537, 2.0832722213258994, 1.0, 2.6792660929581062, 2.256477302082787, 1.0), (2.641377481542537, 2.0880834735691463, 1.0, 2.6792660929581062, 2.261288554326034, 1.0), (2.641377481542537, 2.0832722213258994, 1.0, 2.6792660929581062, 2.25166604983954, 1.0), (2.641377481542537, 2.0832722213258994, 1.0, 2.6738534341844535, 2.25166604983954, 1.0), (2.6386711521557107, 2.078460969082652, 1.0, 2.671147104797627, 2.242043545353046, 1.0), (2.6386711521557107, 2.078460969082652, 1.0, 2.668440775410801, 2.25166604983954, 1.0), (2.635964822768884, 2.0880834735691463, 1.0, 2.6738534341844535, 2.242043545353046, 1.0), (2.635964822768884, 2.078460969082652, 1.0, 2.6657344460239742, 2.256477302082787, 1.0), (2.635964822768884, 2.078460969082652, 1.0, 2.6657344460239742, 2.256477302082787, 1.0), (3.3612610984383515, 2.203553527407071, 1.0, 3.409975027401226, 2.4441161395694153, 1.0), (3.3612610984383515, 2.203553527407071, 1.0, 3.409975027401226, 2.4441161395694153, 1.0), (3.3396104633437407, 2.4441161395694153, 1.0, 3.420800344948532, 2.886751345948128, 1.0), (3.3314914751832614, 2.4633611485424027, 1.0, 3.423506674335358, 2.8771288414616345, 1.0), (3.3314914751832614, 2.458549896299156, 1.0, 3.423506674335358, 2.8771288414616345, 1.0), (3.3314914751832614, 2.4633611485424027, 1.0, 3.423506674335358, 2.8771288414616345, 1.0), (3.3314914751832614, 2.458549896299156, 1.0, 3.4180940155617052, 2.886751345948128, 1.0), (3.3341978045700875, 2.4633611485424027, 1.0, 3.4153876861748786, 2.896373850434622, 1.0), (3.3341978045700875, 2.458549896299156, 1.0, 3.4153876861748786, 2.9059963549211156, 1.0), (3.3314914751832614, 2.453738644055909, 1.0, 3.4126813567880525, 2.9156188594076093, 1.0), (3.328785145796435, 2.453738644055909, 1.0, 3.4153876861748786, 2.9156188594076093, 1.0), (3.3260788164096087, 2.4633611485424027, 1.0, 3.4126813567880525, 2.925241363894103, 1.0), (3.323372487022782, 2.4681724007856496, 1.0, 3.409975027401226, 2.9156188594076093, 1.0), (3.320666157635956, 2.4729836530288964, 1.0, 3.4072686980144, 2.9156188594076093, 1.0), (3.3179598282491294, 2.4729836530288964, 1.0, 3.404562368627573, 2.9156188594076093, 1.0), (3.3179598282491294, 2.4777949052721433, 1.0, 3.3991497098539205, 2.9059963549211156, 1.0), (3.3152534988623032, 2.4729836530288964, 1.0, 3.3964433804670944, 2.9156188594076093, 1.0), (3.3125471694754767, 2.4729836530288964, 1.0, 3.3991497098539205, 2.9156188594076093, 1.0), (3.3098408400886505, 2.48260615751539, 1.0, 3.3964433804670944, 2.9156188594076093, 1.0), (3.3125471694754767, 2.48260615751539, 1.0, 3.393737051080268, 2.920430111650856, 1.0), (3.3098408400886505, 2.487417409758637, 1.0, 3.3910307216934417, 2.925241363894103, 1.0), (3.3098408400886505, 2.492228662001884, 1.0, 3.3910307216934417, 2.934863868380597, 1.0), (3.3098408400886505, 2.492228662001884, 1.0, 3.3910307216934417, 2.934863868380597, 1.0), (3.304428181314998, 2.492228662001884, 1.0, 3.3910307216934417, 2.939675120623844, 1.0), (3.304428181314998, 2.492228662001884, 1.0, 3.3910307216934417, 2.934863868380597, 1.0), (3.307134510701824, 2.492228662001884, 1.0, 3.388324392306615, 2.944486372867091, 1.0), (3.3098408400886505, 2.492228662001884, 1.0, 3.3910307216934417, 2.9541088773535846, 1.0), (3.3098408400886505, 2.492228662001884, 1.0, 3.3910307216934417, 2.9637313818400783, 1.0), (3.307134510701824, 2.5018511664883776, 1.0, 3.393737051080268, 2.973353886326572, 1.0), (3.304428181314998, 2.506662418731625, 1.0, 3.3910307216934417, 2.973353886326572, 1.0), (3.304428181314998, 2.5114736709748717, 1.0, 3.3910307216934417, 2.973353886326572, 1.0), (3.299015522541345, 2.5162849232181186, 1.0, 3.3910307216934417, 2.978165138569819, 1.0), (3.2963091931545185, 2.5162849232181186, 1.0, 3.388324392306615, 2.978165138569819, 1.0), (3.2936028637676924, 2.5210961754613654, 1.0, 3.385618062919789, 2.978165138569819, 1.0), (3.290896534380866, 2.5259074277046123, 1.0, 3.3829117335329624, 2.978165138569819, 1.0), (3.2881902049940392, 2.530718679947859, 1.0, 3.3802054041461362, 2.973353886326572, 1.0), (3.2881902049940392, 2.5210961754613654, 1.0, 3.374792745372483, 2.9829763908130658, 1.0), (3.285483875607213, 2.5259074277046123, 1.0, 3.372086415985657, 2.9974101475428063, 1.0), (3.285483875607213, 2.530718679947859, 1.0, 3.372086415985657, 2.9925988952995595, 1.0), (3.285483875607213, 2.530718679947859, 1.0, 3.372086415985657, 2.9925988952995595, 1.0), (3.285483875607213, 2.535529932191106, 1.0, 3.372086415985657, 2.9974101475428063, 1.0), (3.2827775462203865, 2.540341184434353, 1.0, 3.3693800865988304, 3.002221399786053, 1.0), (3.2800712168335604, 2.540341184434353, 1.0, 3.372086415985657, 3.0070326520293, 1.0), (3.277364887446734, 2.540341184434353, 1.0, 3.3693800865988304, 3.0070326520293, 1.0), (3.2746585580599077, 2.540341184434353, 1.0, 3.372086415985657, 3.0070326520293, 1.0), (1.3639900109604906, 3.08401268792125, 1.0, 2.165063509461096, 3.459290362894507, 1.0), (1.3369267170922268, 3.0407114177320285, 1.0, 2.1380002155928324, 3.4544791106512602, 1.0), (1.2530305061006093, 2.944486372867091, 1.0, 2.070341980922173, 3.4544791106512602, 1.0), (1.2530305061006093, 2.944486372867091, 1.0, 2.070341980922173, 3.4544791106512602, 1.0), (1.2232608828455191, 2.896373850434622, 1.0, 2.0080964050251664, 3.459290362894507, 1.0), (1.2097292359113874, 2.886751345948128, 1.0, 1.9675014642227708, 3.4448566061647665, 1.0), (1.2016102477509083, 2.857883832488647, 1.0, 1.953969817288639, 3.4448566061647665, 1.0), (1.1772532832694709, 2.838638823515659, 1.0, 1.9269065234203753, 3.4448566061647665, 1.0), (1.1610153069485127, 2.819393814542672, 1.0, 1.8917242413916326, 3.4544791106512602, 1.0), (1.15560264817486, 2.809771310056178, 1.0, 1.8673672769101952, 3.4544791106512602, 1.0), (1.1474836600143807, 2.8001488055696844, 1.0, 1.8484229712024107, 3.459290362894507, 1.0), (1.1366583424670753, 2.785715048839944, 1.0, 1.8186533479473206, 3.459290362894507, 1.0), (1.1285393543065962, 2.7520362831372154, 1.0, 1.7888837246922304, 3.459290362894507, 1.0), (1.1177140367592908, 2.7424137786507217, 1.0, 1.7537014426634876, 3.459290362894507, 1.0), (1.098769731051506, 2.732791274164228, 1.0, 1.7320508075688767, 3.459290362894507, 1.0), (1.0852380841173743, 2.7183575174344874, 1.0, 1.710400172474266, 3.459290362894507, 1.0), (1.0717064371832425, 2.694301256218253, 1.0, 1.6779242198323494, 3.459290362894507, 1.0), (1.0581747902491105, 2.6654337427587715, 1.0, 1.661686243511391, 3.4352341016782724, 1.0), (1.0662937784095898, 2.646188733785784, 1.0, 1.6346229496431275, 3.4063665882187912, 1.0), (1.060881119635937, 2.655811238272278, 1.0, 1.6210913027089955, 3.37749907475931, 1.0), (1.0473494727018051, 2.646188733785784, 1.0, 1.602146997001211, 3.339009056813335, 1.0), (1.0365241551544997, 2.62213247256955, 1.0, 1.5804963619066, 3.3101415433538537, 1.0), (1.031111496380847, 2.617321220326303, 1.0, 1.558845726811989, 3.2908965343808663, 1.0), (1.022992508220368, 2.5980762113533156, 1.0, 1.542607750491031, 3.2620290209213847, 1.0), (1.0148735200598886, 2.5884537068668214, 1.0, 1.5209571153964199, 3.2331615074619036, 1.0), (1.323395070158095, 3.0359001654887816, 1.0, 2.1380002155928324, 3.459290362894507, 1.0), (1.323395070158095, 3.0359001654887816, 1.0, 2.1380002155928324, 3.459290362894507, 1.0), (1.2638558236479147, 2.9637313818400783, 1.0, 2.0865799572431314, 3.459290362894507, 1.0)]\n" + ] + } + ], + "source": [ + "geos = filtered_world.get_bbox_geo()\n", + "print(\"Bbox geos are:\",geos)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a548cc6e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Trajectory distances are:\n", + "[('{0@2021-06-08 07:10:30+00, 0@2021-06-08 07:10:31+00, 0@2021-06-08 07:10:32+00, 0@2021-06-08 07:10:33+00, 0@2021-06-08 07:10:34+00, 0@2021-06-08 07:10:35+00, 0@2021-06-08 07:10:36+00, 0@2021-06-08 07:10:37+00, 0@2021-06-08 07:10:38+00, 0@2021-06-08 07:10:39+00, 0@2021-06-08 07:10:40+00, 0@2021-06-08 07:10:41+00, 0@2021-06-08 07:10:42+00, 0@2021-06-08 07:10:43+00, 0@2021-06-08 07:10:44+00, 0@2021-06-08 07:10:45+00, 0@2021-06-08 07:10:46+00, 0@2021-06-08 07:10:47+00, 0@2021-06-08 07:10:48+00, 0@2021-06-08 07:10:49+00, 0@2021-06-08 07:10:50+00, 0@2021-06-08 07:10:51+00, 0@2021-06-08 07:10:52+00, 0@2021-06-08 07:10:53+00, 0@2021-06-08 07:10:54+00, 0@2021-06-08 07:10:55+00, 0@2021-06-08 07:10:56+00, 0@2021-06-08 07:10:57+00}',), ('{0@2021-06-08 07:10:30+00, 0@2021-06-08 07:10:31+00, 0@2021-06-08 07:10:32+00, 0@2021-06-08 07:10:33+00, 0@2021-06-08 07:10:34+00, 0@2021-06-08 07:10:35+00, 0@2021-06-08 07:10:36+00, 0@2021-06-08 07:10:37+00, 0@2021-06-08 07:10:38+00, 0@2021-06-08 07:10:39+00, 0@2021-06-08 07:10:40+00, 0@2021-06-08 07:10:41+00, 0@2021-06-08 07:10:42+00, 0@2021-06-08 07:10:43+00, 0@2021-06-08 07:10:44+00, 0@2021-06-08 07:10:45+00, 0@2021-06-08 07:10:46+00, 0@2021-06-08 07:10:47+00, 0@2021-06-08 07:10:48+00, 0@2021-06-08 07:10:49+00, 0@2021-06-08 07:10:50+00, 0@2021-06-08 07:10:51+00, 0@2021-06-08 07:10:52+00, 0@2021-06-08 07:10:53+00, 0@2021-06-08 07:10:54+00, 0@2021-06-08 07:10:55+00, 0@2021-06-08 07:10:56+00, 0@2021-06-08 07:10:57+00}',), ('{0@2021-06-08 07:10:37+00, 0@2021-06-08 07:10:38+00, 0@2021-06-08 07:10:39+00, 0@2021-06-08 07:10:40+00, 0@2021-06-08 07:10:41+00, 0@2021-06-08 07:10:42+00, 0@2021-06-08 07:10:43+00, 0@2021-06-08 07:10:44+00, 0@2021-06-08 07:10:45+00, 0@2021-06-08 07:10:46+00, 0@2021-06-08 07:10:47+00, 0@2021-06-08 07:10:49+00, 0@2021-06-08 07:10:50+00, 0@2021-06-08 07:10:51+00, 0@2021-06-08 07:10:52+00, 0@2021-06-08 07:10:53+00, 0@2021-06-08 07:10:54+00, 0@2021-06-08 07:10:55+00, 0@2021-06-08 07:10:56+00, 0@2021-06-08 07:10:57+00}',), (None,)]\n" + ] + } + ], + "source": [ + "print(\"Trajectory distances are:\")\n", + "print(filtered_world.get_distance(0, 30))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c20e8370", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Trajectory speeds are:\n", + "[(None,), (None,), (None,), (None,)]\n" + ] + } + ], + "source": [ + "print(\"Trajectory speeds are:\")\n", + "print(filtered_world.get_speed(0, 30))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8e1aa7af", + "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.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/benchmarks/new_apperception_benchmark.py b/benchmarks/new_apperception_benchmark.py new file mode 100644 index 00000000..eb8523b0 --- /dev/null +++ b/benchmarks/new_apperception_benchmark.py @@ -0,0 +1,135 @@ +#!/usr/bin/env python +# coding: utf-8 + +# In[14]: + + +import lens +import point +from new_world import empty_world + +# Let's define some attribute for constructing the world first +name = "traffic_scene" # world name +units = "metrics" # world units +video_file = "./amber_videos/traffic-scene-mini.mp4" # example video file +lens_attrs = {"fov": 120, "cam_origin": (0, 0, 0), "skew_factor": 0} +point_attrs = {"p_id": "p1", "cam_id": "cam1", "x": 0, "y": 0, "z": 0, "time": None, "type": "pos"} +camera_attrs = {"ratio": 0.5} +fps = 30 + +# 1. define a world +traffic_world = empty_world(name="my-world") + +# 2. construct a camera +fov, res, cam_origin, skew_factor = ( + lens_attrs["fov"], + [1280, 720], + lens_attrs["cam_origin"], + lens_attrs["skew_factor"], +) +cam_lens = lens.PinholeLens(res, cam_origin, fov, skew_factor) + +pt_id, cam_id, x, y, z, time, pt_type = ( + point_attrs["p_id"], + point_attrs["cam_id"], + point_attrs["x"], + point_attrs["y"], + point_attrs["z"], + point_attrs["time"], + point_attrs["type"], +) +location = point.Point(pt_id, cam_id, (x, y, z), time, pt_type) + +ratio = camera_attrs["ratio"] + +# ingest the camera into the world +traffic_world = traffic_world.add_camera( + cam_id=cam_id, + location=location, + ratio=ratio, + video_file=video_file, + metadata_identifier=name + "_" + cam_id, + lens=cam_lens, +) + +# Call execute on the world to run the detection algorithm and save the real data to the database +recognized_world = traffic_world.recognize(cam_id) + +volume = traffic_world.select_intersection_of_interest_or_use_default(cam_id=cam_id) + + +# In[15]: + + +cams = traffic_world.get_camera() +lens = traffic_world.get_len() +ids = traffic_world.world_id +print("cameras are", cams) +print("lens are", lens) +print("ids are", ids) + + +# In[16]: + + +filtered_world = ( + recognized_world.filter_traj_type("car").filter_traj_volume(volume).interval(0, fps * 3) +) +filtered_ids = filtered_world.get_traj_key() +print("filtered_ids are", filtered_ids) + + +# In[17]: + + +trajectory = filtered_world.get_traj() +print("trajectories are", trajectory) + + +# In[18]: + + +# draw overlay +# import matplotlib.pyplot as plt +# +# +# traffic_world.overlay_trajectory(cam_id, trajectory) +# plt.show() + + +# In[26]: + + +# render tracking video +filtered_world.get_video([cam_id]) + + +# In[21]: + + +times = filtered_world.get_time() +print("Times are:", times) + + +# In[22]: + + +geos = filtered_world.get_bbox_geo() +print("Bbox geos are:", geos) + + +# In[23]: + + +print("Trajectory distances are:") +print(filtered_world.get_distance(0, 30)) + + +# In[24]: + + +print("Trajectory speeds are:") +print(filtered_world.get_speed(0, 30)) + + +# In[ ]: diff --git a/benchmarks/scenic_benchmark.py b/benchmarks/scenic_benchmark.py new file mode 100644 index 00000000..86ef2f94 --- /dev/null +++ b/benchmarks/scenic_benchmark.py @@ -0,0 +1,86 @@ +import lens +import point +from new_compute_lib import compute_heading +from new_world import empty_world + +# Let's define some attribute for constructing the world first +name = "traffic_scene" # world name +units = "metrics" # world units +video_file = "./amber_videos/traffic-scene-mini.mp4" # example video file +lens_attrs = {"fov": 120, "cam_origin": (0, 0, 0), "skew_factor": 0} +point_attrs = {"p_id": "p1", "cam_id": "cam1", "x": 0, "y": 0, "z": 0, "time": None, "type": "pos"} +camera_attrs = {"ratio": 0.5} +fps = 30 + +# 1. define a world +traffic_world = empty_world(name="my-world") + +# 2. construct a camera +fov, res, cam_origin, skew_factor = ( + lens_attrs["fov"], + [1280, 720], + lens_attrs["cam_origin"], + lens_attrs["skew_factor"], +) +cam_lens = lens.PinholeLens(res, cam_origin, fov, skew_factor) + +pt_id, cam_id, x, y, z, time, pt_type = ( + point_attrs["p_id"], + point_attrs["cam_id"], + point_attrs["x"], + point_attrs["y"], + point_attrs["z"], + point_attrs["time"], + point_attrs["type"], +) +location = point.Point(pt_id, cam_id, (x, y, z), time, pt_type) + +ratio = camera_attrs["ratio"] + +# ingest the camera into the world +traffic_world = traffic_world.add_camera( + cam_id=cam_id, + location=location, + ratio=ratio, + video_file=video_file, + metadata_identifier=name + "_" + cam_id, + lens=cam_lens, +) + +# Call execute on the world to run the detection algorithm and save the real data to the database +recognized_world = traffic_world.recognize(cam_id) + +# Use case #1 + +volume = traffic_world.select_by_range( + cam_id=cam_id, x_range=(0.01082532, 3.01034039), z_range=(0, 2) +) + + +filtered_world = recognized_world.filter_traj_type("car").filter_traj_volume(volume) +filtered_ids = filtered_world.get_traj_key() +print("filtered_ids are", filtered_ids) + +trajectory = filtered_world.get_traj() +print("trajectories are", trajectory) + +# Use case #2 + +volume = traffic_world.select_by_range( + cam_id=cam_id, x_range=(0.01082532, 3.01034039), z_range=(0, 2) +) + + +filtered_world = ( + recognized_world.filter_traj_type("car") + .filter_traj_volume(volume) + .filter_traj_heading(lessThan=8.5, greaterThan=-7.5) +) +filtered_ids = filtered_world.get_traj_key() +print("filtered_ids are", filtered_ids) + +trajectory = filtered_world.get_traj() +print("trajectories are", trajectory) + +heading = compute_heading(trajectory) +print("heading are", heading) diff --git a/benchmarks/scenic_equivelants.ipynb b/benchmarks/scenic_equivelants.ipynb new file mode 100644 index 00000000..f8175287 --- /dev/null +++ b/benchmarks/scenic_equivelants.ipynb @@ -0,0 +1,588 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "# Deleting the .apperception_cache if it exists, as to avoid DB conflict errors\n", + "import os\n", + "import shutil\n", + "\n", + "dirpath = os.path.join('.apperception_cache')\n", + "if os.path.exists(dirpath) and os.path.isdir(dirpath):\n", + " shutil.rmtree(dirpath)\n", + "\n", + "dirpath = os.path.join('output')\n", + "if os.path.exists(dirpath) and os.path.isdir(dirpath):\n", + " shutil.rmtree(dirpath)\n", + "os.mkdir(dirpath)\n", + "\n", + "# This piece of code is unsafe, and should not be run if not needed. \n", + "# It serves for test purposes when one recieves a \"dead kernel\" error.\n", + "os.environ[\"KMP_DUPLICATE_LIB_OK\"]=\"TRUE\"" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: '.apperception_cache/2022-03-04 07;30;49.195866_b0836101-4935-450b-a2e0-22f469cf8994_trafficScene.ap.yaml'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/var/folders/jk/04mdk5z529z3kdnl2cl6ty3h0000gn/T/ipykernel_22556/3245952245.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[0;31m# 1. define a world\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 19\u001b[0;31m \u001b[0mtraffic_world\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mempty_world\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 20\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[0;31m# 2. construct a camera\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Desktop/apperception/apperception/new_world.py\u001b[0m in \u001b[0;36mempty_world\u001b[0;34m(name)\u001b[0m\n\u001b[1;32m 480\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmatched_files\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 481\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0m_empty_world_from_file\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmatched_files\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 482\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_empty_world\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 483\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 484\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Desktop/apperception/apperception/new_world.py\u001b[0m in \u001b[0;36m_empty_world\u001b[0;34m(name)\u001b[0m\n\u001b[1;32m 495\u001b[0m \u001b[0mtimestamp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdatetime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdatetime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mutcnow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 496\u001b[0m \u001b[0mlog_file\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfilename\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimestamp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mworld_id\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 497\u001b[0;31m \u001b[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlog_file\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"w\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 498\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwrite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0myaml\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msafe_dump\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 499\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mWorld\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mworld_id\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimestamp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '.apperception_cache/2022-03-04 07;30;49.195866_b0836101-4935-450b-a2e0-22f469cf8994_trafficScene.ap.yaml'" + ] + } + ], + "source": [ + "import sys\n", + "sys.path.append(os.path.join(os.getcwd(),\"apperception\"))\n", + "\n", + "### IMPORTS\n", + "import lens\n", + "import point\n", + "from new_world import empty_world\n", + "\n", + "# Let's define some attribute for constructing the world first\n", + "name = \"trafficScene\" # world name\n", + "units = \"metrics\" # world units\n", + "video_file = \"amber_videos/traffic-scene.mp4\" # example video file\n", + "lens_attrs = {\"fov\": 120, \"cam_origin\": (0, 0, 0), \"skew_factor\": 0}\n", + "point_attrs = {\"p_id\": \"p1\", \"cam_id\": \"cam1\", \"x\": 0, \"y\": 0, \"z\": 0, \"time\": None, \"type\": \"pos\"}\n", + "camera_attrs = {\"ratio\": 0.5}\n", + "fps = 30\n", + "\n", + "# 1. define a world\n", + "traffic_world = empty_world(name)\n", + "\n", + "# 2. construct a camera\n", + "fov, res, cam_origin, skew_factor = (\n", + " lens_attrs[\"fov\"],\n", + " [1280, 720],\n", + " lens_attrs[\"cam_origin\"],\n", + " lens_attrs[\"skew_factor\"],\n", + ")\n", + "cam_lens = lens.PinholeLens(res, cam_origin, fov, skew_factor)\n", + "\n", + "pt_id, cam_id, x, y, z, time, pt_type = (\n", + " point_attrs[\"p_id\"],\n", + " point_attrs[\"cam_id\"],\n", + " point_attrs[\"x\"],\n", + " point_attrs[\"y\"],\n", + " point_attrs[\"z\"],\n", + " point_attrs[\"time\"],\n", + " point_attrs[\"type\"],\n", + ")\n", + "location = point.Point(pt_id, cam_id, (x, y, z), time, pt_type)\n", + "\n", + "ratio = camera_attrs[\"ratio\"]\n", + "\n", + "# ingest the camera into the world\n", + "traffic_world = traffic_world.add_camera(\n", + " cam_id=cam_id,\n", + " location=location,\n", + " ratio=ratio,\n", + " video_file=video_file,\n", + " metadata_identifier=name + \"_\" + cam_id,\n", + " lens=cam_lens,\n", + ")\n", + "\n", + "# Call execute on the world to run the detection algorithm and save the real data to the database\n", + "recognized_world = traffic_world.recognize(cam_id)\n", + "\n", + "volume = traffic_world.select_intersection_of_interest_or_use_default(cam_id=cam_id)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cameras are [('cam1', 0.5, 0.0, 0.0, 0.0, 369.5041722813606, 207.84609690826534, 120, 0.0)]\n", + "lens are [(0.5, 0.0, 0.0, 0.0, 120, 0.0)]\n" + ] + } + ], + "source": [ + "cams = traffic_world.get_camera()\n", + "lens = traffic_world.get_len()\n", + "# ids = traffic_world.get_id()\n", + "print(\"cameras are\", cams)\n", + "print(\"lens are\", lens)\n", + "# print(\"ids are\", ids)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "get_traj_key SELECT sq2.itemid FROM (SELECT DISTINCT sq1.* FROM (SELECT * FROM (SELECT * FROM item_general_trajectory WHERE worldId='cd5ca1e8-dc85-45bb-9a78-fe66a587ad06') sq0 WHERE sq0.objecttype='car') sq1 CROSS JOIN cameras WHERE ST_X(cameras.origin)-getX(sq1.trajCentroids)>=-10 AND ST_X(cameras.origin)-getX(sq1.trajCentroids)<=10 AND ST_Y(cameras.origin)-getX(sq1.trajCentroids)>=-15 AND ST_Y(cameras.origin)-getX(sq1.trajCentroids)<=70 AND ST_Z(cameras.origin)-getX(sq1.trajCentroids)>=-inf AND ST_Z(cameras.origin)-getX(sq1.trajCentroids)<=inf) sq2\n" + ] + }, + { + "ename": "InFailedSqlTransaction", + "evalue": "current transaction is aborted, commands ignored until end of transaction block\n", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mInFailedSqlTransaction\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/var/folders/jk/04mdk5z529z3kdnl2cl6ty3h0000gn/T/ipykernel_22556/1961925502.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 22\u001b[0m \u001b[0;31m# and we dont care about the offset relative to the camera's z position. We also dont care about the relative heading difference.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 23\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 24\u001b[0;31m \u001b[0mfiltered_ids\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfiltered_world\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_traj_key\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 25\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"filtered_ids are\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfiltered_ids\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 26\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Desktop/apperception/apperception/new_world.py\u001b[0m in \u001b[0;36mget_traj_key\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 168\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_traj_key\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 170\u001b[0;31m return derive_world(\n\u001b[0m\u001b[1;32m 171\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 172\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0mType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTRAJ\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Desktop/apperception/apperception/new_world.py\u001b[0m in \u001b[0;36m_execute_from_root\u001b[0;34m(self, type)\u001b[0m\n\u001b[1;32m 393\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 394\u001b[0m \u001b[0;31m# print(query)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 395\u001b[0;31m \u001b[0mquery\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_execute\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mquery\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mquery\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 396\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 397\u001b[0m \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mquery\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Desktop/apperception/apperception/new_world.py\u001b[0m in \u001b[0;36m_execute\u001b[0;34m(self, **kwargs)\u001b[0m\n\u001b[1;32m 402\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;34m\"world_id\"\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mfn_spec\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mfn_spec\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvarkw\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 403\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m\"world_id\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_world_id\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_kwargs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 404\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_kwargs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 405\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 406\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_print_lineage\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Desktop/apperception/apperception/new_db.py\u001b[0m in \u001b[0;36mget_traj_key\u001b[0;34m(self, query)\u001b[0m\n\u001b[1;32m 193\u001b[0m \u001b[0mq\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mSnowflakeQuery\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mquery\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mselect\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"itemid\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 194\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"get_traj_key\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mq\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_sql\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 195\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcur\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexecute\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mq\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_sql\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 196\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcur\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfetchall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 197\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mInFailedSqlTransaction\u001b[0m: current transaction is aborted, commands ignored until end of transaction block\n" + ] + } + ], + "source": [ + "import time\n", + "start_time = time.time()\n", + "### Scenic Code ###\n", + "# ego = Car\n", + "# Car offset by (Range(-10, 10), Range(20, 40))\n", + "\n", + "### Apperception Query ###\n", + "filtered_world = recognized_world.filter_traj_type(\"car\")\n", + "\n", + "## OPTION 1 ###\n", + "# filtered_world = filtered_world.filter_relative_to_type(x_range=(-10, 10), y_range=(-1, 5), z_range=(-10, 0),\n", + "# type=\"camera\")\n", + "# The idea is that the user passes in a lambda function, that specifies the relationship that must be met between the queried\n", + "# object, and some object of the type passed to the function. In this case, the lambda function filters such that the offset \n", + "# is between -10 and 10 in the x direction, and between 20 and 40 in the y direction, relative to some camera.\n", + "\n", + "### OPTION 2 ###\n", + "filtered_world = filtered_world.filter_pred_relative_to_type(pred = lambda obj: (cam.x - 10) <= obj.x <= (cam.x + 10) and (cam.y - 15) <= obj.y <= (cam.y + 70))\n", + "# The idea is that filter_offset_type() takes in two arguments: the offset in terms of coordinates, a relative heading \n", + "# as well as the type of object to be offset from. In this case, we want it to be somehwere between -10 and 10 units\n", + "# offset relative to a camera's x position, somehwere between 20 and 40 units offset relative to some camera's y position, \n", + "# and we dont care about the offset relative to the camera's z position. We also dont care about the relative heading difference.\n", + "\n", + "filtered_ids = filtered_world.get_traj_key()\n", + "print(\"filtered_ids are\", filtered_ids)\n", + "\n", + "print(\"----------------------------------------------------------------------\")\n", + "print(\"Total execution time is: %s seconds\" % (time.time() - start_time))\n", + "print(\"Device Details: \\n Processor: AMD Ryzen 7 5800H \\n RAM Size: 16GB \\n Graphics Card: NVIDIA GeForce RTX 3060 Laptop\")\n", + "print(\"----------------------------------------------------------------------\")\n", + "# traffic-scene-shorter (length of 4 seconds): runtime of 81.82859063148499 seconds\n", + "# traffic-scene (length of 20 seconds): runtime of 98.58345794677734 seconds\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(598, 4)\n", + "(88, 4)\n", + "incorrect length: 88\n", + "(24, 4)\n", + "incorrect length: 24\n", + "output video files ./output/trafficScene_cam1car-4-a51f7975-379b-4df4-b4ce-7ba216f0b05e.mp4,./output/trafficScene_cam1car-6-a51f7975-379b-4df4-b4ce-7ba216f0b05e.mp4,./output/trafficScene_cam1car-9-a51f7975-379b-4df4-b4ce-7ba216f0b05e.mp4\n" + ] + } + ], + "source": [ + "filtered_world.get_video([cam_id], boxed=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# ### Scenic Code ###\n", + "# # ego = Car\n", + "# # Car\n", + "\n", + "# ### Apperception Query ###\n", + "# filtered_world = recognized_world.filter_traj_type(\"car\").interval(0, fps * 3)\n", + "# filtered_ids = filtered_world.get_traj_key()\n", + "# print(\"filtered_ids are\", filtered_ids)\n", + "\n", + "# # render tracking video\n", + "# filtered_world.get_video([cam_id])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# ### Scenic Code ###\n", + "# # ego = Car\n", + "# # Car offset by (Range(-10, 10), Range(20, 40)), \n", + "# # \tfacing Range(-5, 5) deg\n", + "\n", + "# ### Apperception Query ###\n", + "# filtered_world = recognized_world.filter_traj_type(\"car\")\n", + "\n", + "# ## OPTION 1 ###\n", + "# filtered_world = filtered_world.filter_relative_to_type(relative=lambda obj, camera: -10 <= (camera.x - obj.x) <= 10 \\\n", + "# and 20 <= (camera.y - obj.y) <= 40,\n", + "# type=\"camera\")\n", + "\n", + "# ### OPTION 2 ###\n", + "# filtered_world = filtered_world.filter_relative_to_type(offset=((-10, 10), (20, 40), None), heading=None, type=\"camera\")\n", + "\n", + "# filtered_world = filtered_world.filter_heading(-5, 5)\n", + "# # Filters for objects that have heading between -5 and 5 degrees\n", + "\n", + "# filtered_ids = filtered_world.get_traj_key()\n", + "# print(\"filtered_ids are\", filtered_ids)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# ### Scenic Code ###\n", + "# # ego = Car\n", + "# # Car offset by (Range(-10, 10), Range(20, 40)), \n", + "# # \tfacing Range(-5, 5) deg relative to ego\n", + "\n", + "# ### Apperception Query ###\n", + "# filtered_world = recognized_world.filter_traj_type(\"car\")\n", + "\n", + "# ## OPTION 1 ###\n", + "# filtered_world = filtered_world.filter_relative_to_type(relative=lambda obj, camera: -10 <= (camera.x - obj.x) <= 10 \\\n", + "# and 20 <= (camera.y - obj.y) <= 40 \\\n", + "# and -5 <= (camera.heading - obj.heading) <= 5,\n", + "# type=\"camera\")\n", + "# # Now filtering for a relative heading between -5 and 5 degrees\n", + "\n", + "# ### OPTION 2 ###\n", + "# filtered_world = filtered_world.filter_relative_to_type(offset=((-10, 10), (20, 40), None), heading=(-5, 5), type=\"camera\")\n", + "# # Now filtering for a relative heading between -5 and 5 degrees\n", + "\n", + "# filtered_ids = filtered_world.get_traj_key()\n", + "# print(\"filtered_ids are\", filtered_ids)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# ### Scenic Code ###\n", + "# # ego = Car\n", + "# # Car left of ego by 0.25 \n", + "\n", + "# ### Apperception Query ###\n", + "# filtered_world = recognized_world.filter_traj_type(\"car\")\n", + "\n", + "# ## OPTION 1 ###\n", + "# def left_of(obj, camera):\n", + "# expec_x = obj.x + 0.25 * np.cos(camera.heading)\n", + "# expec_y = obj.y - 0.25 * np.sin(camera.heading)\n", + "# # Should also allow some sort of variation, to account for noise (and since exact equality is unlikley)\n", + "# return (expec_x == camera.x) and (expec_y == camera.y)\n", + "\n", + "# filtered_world = filtered_world.filter_relative_to_type(relative=left_of, type=\"camera\")\n", + "# # Now filtering such that the car is left of ego by 0.25 units\n", + "\n", + "# ### OPTION 2 ##\n", + "# # Not possible\n", + "\n", + "# filtered_ids = filtered_world.get_traj_key()\n", + "# print(\"filtered_ids are\", filtered_ids)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# ### Scenic Code ###\n", + "# # ego = Car\n", + "# # badAngle = Range(10, 20) deg\n", + "# # Car left of ego by 0.25,\n", + "# # \tfacing badAngle relative to ego\n", + "\n", + "# ### Apperception Query ###\n", + "# filtered_world = recognized_world.filter_traj_type(\"car\")\n", + "\n", + "# ## OPTION 1 ###\n", + "# def filter(obj, camera):\n", + "# expec_x = obj.x + 0.25 * np.cos(camera.heading)\n", + "# expec_y = obj.y - 0.25 * np.sin(camera.heading)\n", + "# # Should also allow some sort of variation, to account for noise (and since exact equality is unlikley)\n", + "# return (expec_x == camera.x) and (expec_y == camera.y) and 10 <= (camera.heading - obj.heading) <= 20\n", + "\n", + "# filtered_world = filtered_world.filter_relative_to_type(relative=filter, type=\"camera\")\n", + "# # Now filtering such that the car is left of ego by 0.25 units\n", + "\n", + "# ### OPTION 2 ##\n", + "# # Not possible\n", + "\n", + "# filtered_ids = filtered_world.get_traj_key()\n", + "# print(\"filtered_ids are\", filtered_ids)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# def roadDirection(x, y, z):\n", + "# # TODO: Implement\n", + "# # Returns the direction (in 360 degree angle form) of the road at the coordinates (x, y, z)\n", + "# # If their is no such road, returns a value of None\n", + "# return None" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "#### FURTHER QUERIES WILL USE THE OPTION 1 LISTED ABOVE ####" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "### Scenic Code ###\n", + "# weather = Uniform(\"sunny\", \"rainy\", \"thunder\")\n", + "# time = Range(10, 12)\n", + "#\n", + "# ego = car on road\n", + "# otherCar = Car ahead of ego by Range(4, 19)\n", + "# require not (otherCar in intersection)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "### Scenic Code ###\n", + "# spot = OrientedPoint on curb\n", + "# ego = Car at (spot offset by (Range(2,4), Range(5,10)))\n", + "# sideCar = Car left of spot by Range(1,3)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "### Scenic Code ###\n", + "# def placeObjs(car, numCars):\n", + "# for i in range(numCars):\n", + "# car = Car ahead of car by Range(4, 5)\n", + "# leftCar = Car left of car by Normal(2, 0.1), facing roadDirection\n", + "# rightCar = Car right of car by Normal(3, 0.1), facing Range(0, 10) deg relative to ego.heading\n", + "# return leftCar, rightCar\n", + "\n", + "# spawn_point = 207.26 @ 8.72\n", + "# ego = Car at spawn_point, with visible_distance 200\n", + "\n", + "# leftCar, rightCar = placeObjs(ego, 2)\n", + "# require (distance to leftCar) < 200\n", + "# require (distance to rightCar) < 200\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "### Scenic Code ###\n", + "# def placeObjs(numPeds):\n", + "# for i in range(numPeds):\n", + "# Pedestrian offset by Range(-5, 5) @ Range(0, 200),\n", + "# facing Range(-120, 120) deg relative to ego.heading\n", + "\n", + "# spawn_point = 207.26 @ 8.72\n", + "# ego = Car at spawn_point,\n", + "# with visibleDistance 200\n", + "\n", + "# placeObjs(3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "### Scenic Code ###\n", + "# ego = Car on drivableRoad,\n", + "# facing Range(-15, 15) deg relative to roadDirection,\n", + "# with visibleDistance 50, \n", + "# with viewAngle 135 deg\n", + "# ped = Pedestrian on roadsOrIntersections,\n", + "# with regionContainedIn roadRegion,\n", + "# facing Range(-180, 180) deg\n", + "\n", + "# require abs(relative heading of ped from ego) > 70 deg" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "### Scenic Code ###\n", + "# offset = Uniform(-1, 1) * Range(90, 180) deg\n", + "\n", + "# ego = Car on drivableRoad,\n", + "# facing offset relative to roadDirection,\n", + "# with visibleDistance 50,\n", + "# with viewAngle 135 deg\n", + "\n", + "# otherCar = Car on visible road,\n", + "# facing Range(-15, 15) deg relative to roadDirection\n", + "\n", + "# require (distance from ego to otherCar) < 10" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "### Scenic Code ###\n", + "# ego = Car on drivableRoad,\n", + "# facing Range(-15, 15) deg relative to roadDirection,\n", + "# with visibleDistance 50,\n", + "# with viewAngle 135 deg\n", + "\n", + "# other1 = Car on intersection,\n", + "# facing -1 * Range(50, 135) deg relative to ego.heading\n", + "\n", + "# other2 = Car on intersection,\n", + "# facing -1 * Range(50, 135) deg relative to ego.heading\n", + "\n", + "# require abs(relative heading of other1 from other2) > 100 deg\n", + "# require (distance from ego to intersectionRegion) < 10" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "### Scenic Code ###\n", + "# ego = Car on drivableRoad,\n", + "# facing Range(-15, 15) deg relative to roadDirection,\n", + "# with visibleDistance 50,\n", + "# with viewAngle 135 deg\n", + "\n", + "# point1 = OrientedPoint ahead of ego by Range(0, 40)\n", + "# Car at (point1 offset by Range(-1, 1) & 0),\n", + "# facing Range(-15, 15) deg relative to roadDirection\n", + "\n", + "# oppositeCar = Car offset by (Range(-10, -1), Range(0, 50)),\n", + "# facing Range(140, 180) deg relative to ego.heading\n", + "\n", + "# point2 = OrientedPoint ahead of oppositeCar by Range(0, 40)\n", + "# Car at (point2 offset by Range(-1, 1) @ 0),\n", + "# facing Range(-15, 15) deg relative to roadDirection" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "### Scenic Code ###\n", + "# lanesWithRightLane = filter(lambda i: i._laneToRight, network.laneSections)\n", + "# egoLane = Uniform(*lanesWithRightLane)\n", + "\n", + "# ego = Car on egoLane,\n", + "# facing Range(-15, 15) deg relative to roadDirection\n", + "# cutInCar = Car offset by Range(0, 4) @ Range(0, 5),\n", + "# facing -1*Range(15, 30) deg relative to roadDirection" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# I think there are 3 main things that need to now be implemented in Apperception to allow incorparation with Scenic:\n", + "# 1. A way to have the arbitrary filters that were possible in the old API (the predicate lambda functions that could be passed)\n", + "# 2. A way to have filters with regardes to other objects. For example, I could say I want \"cars that are to the left of a bus by 0.25m\" or such. I would assume this could also be implemented as a lambda function filter (I have included an example fo this in the scenic_equivelants notebook).\n", + "# 3. Some way to not only recognize what the type of an object is, but recognize the type of point it is on. For example, recognizing that the Car is on a road, or that the Car is in an intersection (this is something that is done quite a lot in Scenic).\n", + "# - For this, we might not have to incorporate it into apperception, and can make it the users responsibility (and they can create their own filters that do this), but I am not too sure" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "interpreter": { + "hash": "36b9f45d2c0c5940d48526f9dac9a46c8afda5d718c8f108cd3f22cd85be16c2" + }, + "kernelspec": { + "display_name": "Python 3.8.8 ('base')", + "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.8.12" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/scenic_test.ipynb b/benchmarks/scenic_test.ipynb similarity index 100% rename from scenic_test.ipynb rename to benchmarks/scenic_test.ipynb diff --git a/requirements.txt b/requirements.txt index 55ee9da9..fb33b64f 100644 --- a/requirements.txt +++ b/requirements.txt @@ -14,4 +14,6 @@ matplotlib pillow jupyter torch -numpy \ No newline at end of file +numpy +pyquaternion +PyQt5 \ No newline at end of file diff --git a/scenic_equivelants.py b/scenic_equivelants.py new file mode 100644 index 00000000..db7fb548 --- /dev/null +++ b/scenic_equivelants.py @@ -0,0 +1,367 @@ +# %% +# Deleting the .apperception_cache if it exists, as to avoid DB conflict errors +import os +import shutil + +dirpath = os.path.join('.apperception_cache') +if os.path.exists(dirpath) and os.path.isdir(dirpath): + shutil.rmtree(dirpath) + +dirpath = os.path.join('output') +if os.path.exists(dirpath) and os.path.isdir(dirpath): + shutil.rmtree(dirpath) +os.mkdir(dirpath) + +# This piece of code is unsafe, and should not be run if not needed. +# It serves for test purposes when one recieves a "dead kernel" error. +os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE" + +# %% +import sys +sys.path.append(os.path.join(os.getcwd(),"apperception")) + +### IMPORTS +import lens +import point +from new_world import empty_world + +# Let's define some attribute for constructing the world first +name = "trafficScene" # world name +units = "metrics" # world units +video_file = "amber_videos/traffic-scene.mp4" # example video file +lens_attrs = {"fov": 120, "cam_origin": (0, 0, 0), "skew_factor": 0} +point_attrs = {"p_id": "p1", "cam_id": "cam1", "x": 0, "y": 0, "z": 0, "time": None, "type": "pos"} +camera_attrs = {"ratio": 0.5} +fps = 30 + +# 1. define a world +traffic_world = empty_world(name) + +# 2. construct a camera +fov, res, cam_origin, skew_factor = ( + lens_attrs["fov"], + [1280, 720], + lens_attrs["cam_origin"], + lens_attrs["skew_factor"], +) +cam_lens = lens.PinholeLens(res, cam_origin, fov, skew_factor) + +pt_id, cam_id, x, y, z, time, pt_type = ( + point_attrs["p_id"], + point_attrs["cam_id"], + point_attrs["x"], + point_attrs["y"], + point_attrs["z"], + point_attrs["time"], + point_attrs["type"], +) +location = point.Point(pt_id, cam_id, (x, y, z), time, pt_type) + +ratio = camera_attrs["ratio"] + +# ingest the camera into the world +traffic_world = traffic_world.add_camera( + cam_id=cam_id, + location=location, + ratio=ratio, + video_file=video_file, + metadata_identifier=name + "_" + cam_id, + lens=cam_lens, +) + +# Call execute on the world to run the detection algorithm and save the real data to the database +recognized_world = traffic_world.recognize(cam_id) + +volume = traffic_world.select_intersection_of_interest_or_use_default(cam_id=cam_id) + +# %% +cams = traffic_world.get_camera() +lens = traffic_world.get_len() +# ids = traffic_world.get_id() +print("cameras are", cams) +print("lens are", lens) +# print("ids are", ids) + +# %% +import time +start_time = time.time() +### Scenic Code ### +# ego = Car +# Car offset by (Range(-10, 10), Range(20, 40)) + +### Apperception Query ### +filtered_world = recognized_world.filter_traj_type("car") + +## OPTION 1 ### +# filtered_world = filtered_world.filter_relative_to_type(x_range=(-10, 10), y_range=(-1, 5), z_range=(-10, 0), +# type="camera") +# The idea is that the user passes in a lambda function, that specifies the relationship that must be met between the queried +# object, and some object of the type passed to the function. In this case, the lambda function filters such that the offset +# is between -10 and 10 in the x direction, and between 20 and 40 in the y direction, relative to some camera. + +### OPTION 2 ### +filtered_world = filtered_world.filter_pred_relative_to_type(pred = lambda obj: (cam.x - 10) <= obj.x <= (cam.x + 10) and (cam.y - 15) <= obj.y <= (cam.y + 70)) +# The idea is that filter_offset_type() takes in two arguments: the offset in terms of coordinates, a relative heading +# as well as the type of object to be offset from. In this case, we want it to be somehwere between -10 and 10 units +# offset relative to a camera's x position, somehwere between 20 and 40 units offset relative to some camera's y position, +# and we dont care about the offset relative to the camera's z position. We also dont care about the relative heading difference. + +filtered_ids = filtered_world.get_traj_key() +print("filtered_ids are", filtered_ids) + +print("----------------------------------------------------------------------") +print("Total execution time is: %s seconds" % (time.time() - start_time)) +print("Device Details: \n Processor: AMD Ryzen 7 5800H \n RAM Size: 16GB \n Graphics Card: NVIDIA GeForce RTX 3060 Laptop") +print("----------------------------------------------------------------------") +# traffic-scene-shorter (length of 4 seconds): runtime of 81.82859063148499 seconds +# traffic-scene (length of 20 seconds): runtime of 98.58345794677734 seconds + + +# %% +filtered_world.get_video([cam_id], boxed=True) + +# %% +# ### Scenic Code ### +# # ego = Car +# # Car + +# ### Apperception Query ### +# filtered_world = recognized_world.filter_traj_type("car").interval(0, fps * 3) +# filtered_ids = filtered_world.get_traj_key() +# print("filtered_ids are", filtered_ids) + +# # render tracking video +# filtered_world.get_video([cam_id]) + +# %% +# ### Scenic Code ### +# # ego = Car +# # Car offset by (Range(-10, 10), Range(20, 40)), +# # facing Range(-5, 5) deg + +# ### Apperception Query ### +# filtered_world = recognized_world.filter_traj_type("car") + +# ## OPTION 1 ### +# filtered_world = filtered_world.filter_relative_to_type(relative=lambda obj, camera: -10 <= (camera.x - obj.x) <= 10 \ +# and 20 <= (camera.y - obj.y) <= 40, +# type="camera") + +# ### OPTION 2 ### +# filtered_world = filtered_world.filter_relative_to_type(offset=((-10, 10), (20, 40), None), heading=None, type="camera") + +# filtered_world = filtered_world.filter_heading(-5, 5) +# # Filters for objects that have heading between -5 and 5 degrees + +# filtered_ids = filtered_world.get_traj_key() +# print("filtered_ids are", filtered_ids) + +# %% +# ### Scenic Code ### +# # ego = Car +# # Car offset by (Range(-10, 10), Range(20, 40)), +# # facing Range(-5, 5) deg relative to ego + +# ### Apperception Query ### +# filtered_world = recognized_world.filter_traj_type("car") + +# ## OPTION 1 ### +# filtered_world = filtered_world.filter_relative_to_type(relative=lambda obj, camera: -10 <= (camera.x - obj.x) <= 10 \ +# and 20 <= (camera.y - obj.y) <= 40 \ +# and -5 <= (camera.heading - obj.heading) <= 5, +# type="camera") +# # Now filtering for a relative heading between -5 and 5 degrees + +# ### OPTION 2 ### +# filtered_world = filtered_world.filter_relative_to_type(offset=((-10, 10), (20, 40), None), heading=(-5, 5), type="camera") +# # Now filtering for a relative heading between -5 and 5 degrees + +# filtered_ids = filtered_world.get_traj_key() +# print("filtered_ids are", filtered_ids) + +# %% +# ### Scenic Code ### +# # ego = Car +# # Car left of ego by 0.25 + +# ### Apperception Query ### +# filtered_world = recognized_world.filter_traj_type("car") + +# ## OPTION 1 ### +# def left_of(obj, camera): +# expec_x = obj.x + 0.25 * np.cos(camera.heading) +# expec_y = obj.y - 0.25 * np.sin(camera.heading) +# # Should also allow some sort of variation, to account for noise (and since exact equality is unlikley) +# return (expec_x == camera.x) and (expec_y == camera.y) + +# filtered_world = filtered_world.filter_relative_to_type(relative=left_of, type="camera") +# # Now filtering such that the car is left of ego by 0.25 units + +# ### OPTION 2 ## +# # Not possible + +# filtered_ids = filtered_world.get_traj_key() +# print("filtered_ids are", filtered_ids) + +# %% +# ### Scenic Code ### +# # ego = Car +# # badAngle = Range(10, 20) deg +# # Car left of ego by 0.25, +# # facing badAngle relative to ego + +# ### Apperception Query ### +# filtered_world = recognized_world.filter_traj_type("car") + +# ## OPTION 1 ### +# def filter(obj, camera): +# expec_x = obj.x + 0.25 * np.cos(camera.heading) +# expec_y = obj.y - 0.25 * np.sin(camera.heading) +# # Should also allow some sort of variation, to account for noise (and since exact equality is unlikley) +# return (expec_x == camera.x) and (expec_y == camera.y) and 10 <= (camera.heading - obj.heading) <= 20 + +# filtered_world = filtered_world.filter_relative_to_type(relative=filter, type="camera") +# # Now filtering such that the car is left of ego by 0.25 units + +# ### OPTION 2 ## +# # Not possible + +# filtered_ids = filtered_world.get_traj_key() +# print("filtered_ids are", filtered_ids) + +# %% +# def roadDirection(x, y, z): +# # TODO: Implement +# # Returns the direction (in 360 degree angle form) of the road at the coordinates (x, y, z) +# # If their is no such road, returns a value of None +# return None + +# %% +#### FURTHER QUERIES WILL USE THE OPTION 1 LISTED ABOVE #### + +# %% +### Scenic Code ### +# weather = Uniform("sunny", "rainy", "thunder") +# time = Range(10, 12) +# +# ego = car on road +# otherCar = Car ahead of ego by Range(4, 19) +# require not (otherCar in intersection) + +# %% +### Scenic Code ### +# spot = OrientedPoint on curb +# ego = Car at (spot offset by (Range(2,4), Range(5,10))) +# sideCar = Car left of spot by Range(1,3) + +# %% +### Scenic Code ### +# def placeObjs(car, numCars): +# for i in range(numCars): +# car = Car ahead of car by Range(4, 5) +# leftCar = Car left of car by Normal(2, 0.1), facing roadDirection +# rightCar = Car right of car by Normal(3, 0.1), facing Range(0, 10) deg relative to ego.heading +# return leftCar, rightCar + +# spawn_point = 207.26 @ 8.72 +# ego = Car at spawn_point, with visible_distance 200 + +# leftCar, rightCar = placeObjs(ego, 2) +# require (distance to leftCar) < 200 +# require (distance to rightCar) < 200 + + +# %% +### Scenic Code ### +# def placeObjs(numPeds): +# for i in range(numPeds): +# Pedestrian offset by Range(-5, 5) @ Range(0, 200), +# facing Range(-120, 120) deg relative to ego.heading + +# spawn_point = 207.26 @ 8.72 +# ego = Car at spawn_point, +# with visibleDistance 200 + +# placeObjs(3) + +# %% +### Scenic Code ### +# ego = Car on drivableRoad, +# facing Range(-15, 15) deg relative to roadDirection, +# with visibleDistance 50, +# with viewAngle 135 deg +# ped = Pedestrian on roadsOrIntersections, +# with regionContainedIn roadRegion, +# facing Range(-180, 180) deg + +# require abs(relative heading of ped from ego) > 70 deg + +# %% +### Scenic Code ### +# offset = Uniform(-1, 1) * Range(90, 180) deg + +# ego = Car on drivableRoad, +# facing offset relative to roadDirection, +# with visibleDistance 50, +# with viewAngle 135 deg + +# otherCar = Car on visible road, +# facing Range(-15, 15) deg relative to roadDirection + +# require (distance from ego to otherCar) < 10 + +# %% +### Scenic Code ### +# ego = Car on drivableRoad, +# facing Range(-15, 15) deg relative to roadDirection, +# with visibleDistance 50, +# with viewAngle 135 deg + +# other1 = Car on intersection, +# facing -1 * Range(50, 135) deg relative to ego.heading + +# other2 = Car on intersection, +# facing -1 * Range(50, 135) deg relative to ego.heading + +# require abs(relative heading of other1 from other2) > 100 deg +# require (distance from ego to intersectionRegion) < 10 + +# %% +### Scenic Code ### +# ego = Car on drivableRoad, +# facing Range(-15, 15) deg relative to roadDirection, +# with visibleDistance 50, +# with viewAngle 135 deg + +# point1 = OrientedPoint ahead of ego by Range(0, 40) +# Car at (point1 offset by Range(-1, 1) & 0), +# facing Range(-15, 15) deg relative to roadDirection + +# oppositeCar = Car offset by (Range(-10, -1), Range(0, 50)), +# facing Range(140, 180) deg relative to ego.heading + +# point2 = OrientedPoint ahead of oppositeCar by Range(0, 40) +# Car at (point2 offset by Range(-1, 1) @ 0), +# facing Range(-15, 15) deg relative to roadDirection + +# %% +### Scenic Code ### +# lanesWithRightLane = filter(lambda i: i._laneToRight, network.laneSections) +# egoLane = Uniform(*lanesWithRightLane) + +# ego = Car on egoLane, +# facing Range(-15, 15) deg relative to roadDirection +# cutInCar = Car offset by Range(0, 4) @ Range(0, 5), +# facing -1*Range(15, 30) deg relative to roadDirection + +# %% +# I think there are 3 main things that need to now be implemented in Apperception to allow incorparation with Scenic: +# 1. A way to have the arbitrary filters that were possible in the old API (the predicate lambda functions that could be passed) +# 2. A way to have filters with regardes to other objects. For example, I could say I want "cars that are to the left of a bus by 0.25m" or such. I would assume this could also be implemented as a lambda function filter (I have included an example fo this in the scenic_equivelants notebook). +# 3. Some way to not only recognize what the type of an object is, but recognize the type of point it is on. For example, recognizing that the Car is on a road, or that the Car is in an intersection (this is something that is done quite a lot in Scenic). +# - For this, we might not have to incorporate it into apperception, and can make it the users responsibility (and they can create their own filters that do this), but I am not too sure + +# %% + + + diff --git a/setup.sh b/setup.sh index 0519ae1a..834c8ae1 100755 --- a/setup.sh +++ b/setup.sh @@ -16,7 +16,11 @@ mv checkpoints/ ./yolov4-deepsort cp ./configs/yolov4-config.py ./yolov4-deepsort/core/config.py # setup YoloV5 -git clone --recurse-submodules git@github.com:mikel-brostrom/Yolov5_DeepSort_Pytorch.git yolov5-deepsort +yolov5_dir="yolov5-deepsort" +git clone --recurse-submodules git@github.com:mikel-brostrom/Yolov5_DeepSort_Pytorch.git "${yolov5_dir}" +pushd "${yolov5_dir}" +git checkout 8aec0b5 +popd cp ./configs/yolov5-deepsort-config.yaml ./yolov5-deepsort/deep_sort_pytorch/configs/deep_sort.yaml pushd yolov5-deepsort python3 -m pip install -r requirements.txt